double* discWeightedCondMI(uint k, uint noOfSamples, uint noOfFeatures, double **featureMatrix, double *classColumn, double *weightVector, double *outputFeatures, double *featureScores) { uint *intFeatures = (uint *) checkedCalloc(noOfSamples*noOfFeatures,sizeof(uint)); uint *intClass = (uint *) checkedCalloc(noOfSamples,sizeof(uint)); int *intOutputs = (int *) checkedCalloc(k,sizeof(int)); uint **intFeature2D = (uint**) checkedCalloc(noOfFeatures,sizeof(uint*)); int i; for (i = 0; i < noOfFeatures; i++) { intFeature2D[i] = intFeatures + i*noOfSamples; normaliseArray(featureMatrix[i],intFeature2D[i],noOfSamples); } normaliseArray(classColumn,intClass,noOfSamples); weightedCondMI(k,noOfSamples,noOfFeatures,intFeature2D,intClass,weightVector,intOutputs,featureScores); for (i = 0; i < k; i++) { outputFeatures[i] = intOutputs[i]; } FREE_FUNC(intFeatures); FREE_FUNC(intClass); FREE_FUNC(intOutputs); FREE_FUNC(intFeature2D); intFeatures = NULL; intClass = NULL; intOutputs = NULL; intFeature2D = NULL; return outputFeatures; }/*discWeightedCondMI(int,int,int,double[][],double[],double[],double[],double[])*/
ProbabilityState calculateProbability(double *dataVector, int vectorLength) { int *normalisedVector; int *stateCounts; double *stateProbs; int numStates; /*double fractionalState;*/ ProbabilityState state; int i; double length = vectorLength; normalisedVector = (int *) checkedCalloc(vectorLength,sizeof(int)); numStates = normaliseArray(dataVector,normalisedVector,vectorLength); stateCounts = (int *) checkedCalloc(numStates,sizeof(int)); stateProbs = (double *) checkedCalloc(numStates,sizeof(double)); /* optimised version, may have floating point problems fractionalState = 1.0 / vectorLength; for (i = 0; i < vectorLength; i++) { stateProbs[normalisedVector[i]] += fractionalState; } */ /* Optimised for number of FP operations now O(states) instead of O(vectorLength) */ for (i = 0; i < vectorLength; i++) { stateCounts[normalisedVector[i]] += 1; } for (i = 0; i < numStates; i++) { stateProbs[i] = stateCounts[i] / length; } FREE_FUNC(stateCounts); FREE_FUNC(normalisedVector); stateCounts = NULL; normalisedVector = NULL; state.probabilityVector = stateProbs; state.numStates = numStates; return state; }/*calculateProbability(double *,int)*/
WeightedProbState calculateWeightedProbability(double *dataVector, double *exampleWeightVector, int vectorLength) { int *normalisedVector; int *stateCounts; double *stateProbs; double *stateWeights; int numStates; WeightedProbState state; int i; double length = vectorLength; normalisedVector = (int *) checkedCalloc(vectorLength,sizeof(int)); numStates = normaliseArray(dataVector,normalisedVector,vectorLength); stateCounts = (int *) checkedCalloc(numStates,sizeof(int)); stateProbs = (double *) checkedCalloc(numStates,sizeof(double)); stateWeights = (double *) checkedCalloc(numStates,sizeof(double)); for (i = 0; i < vectorLength; i++) { stateCounts[normalisedVector[i]] += 1; stateWeights[normalisedVector[i]] += exampleWeightVector[i]; } for (i = 0; i < numStates; i++) { stateProbs[i] = stateCounts[i] / length; stateWeights[i] /= stateCounts[i]; } FREE_FUNC(stateCounts); FREE_FUNC(normalisedVector); stateCounts = NULL; normalisedVector = NULL; state.probabilityVector = stateProbs; state.stateWeightVector = stateWeights; state.numStates = numStates; return state; }/*calculateProbability(double *,int)*/
JointProbabilityState calculateJointProbability(double *firstVector, double *secondVector, int vectorLength) { int *firstNormalisedVector; int *secondNormalisedVector; int *firstStateCounts; int *secondStateCounts; int *jointStateCounts; double *firstStateProbs; double *secondStateProbs; double *jointStateProbs; int firstNumStates; int secondNumStates; int jointNumStates; int i; double length = vectorLength; JointProbabilityState state; firstNormalisedVector = (int *) checkedCalloc(vectorLength,sizeof(int)); secondNormalisedVector = (int *) checkedCalloc(vectorLength,sizeof(int)); firstNumStates = normaliseArray(firstVector,firstNormalisedVector,vectorLength); secondNumStates = normaliseArray(secondVector,secondNormalisedVector,vectorLength); jointNumStates = firstNumStates * secondNumStates; firstStateCounts = (int *) checkedCalloc(firstNumStates,sizeof(int)); secondStateCounts = (int *) checkedCalloc(secondNumStates,sizeof(int)); jointStateCounts = (int *) checkedCalloc(jointNumStates,sizeof(int)); firstStateProbs = (double *) checkedCalloc(firstNumStates,sizeof(double)); secondStateProbs = (double *) checkedCalloc(secondNumStates,sizeof(double)); jointStateProbs = (double *) checkedCalloc(jointNumStates,sizeof(double)); /* optimised version, less numerically stable double fractionalState = 1.0 / vectorLength; for (i = 0; i < vectorLength; i++) { firstStateProbs[firstNormalisedVector[i]] += fractionalState; secondStateProbs[secondNormalisedVector[i]] += fractionalState; jointStateProbs[secondNormalisedVector[i] * firstNumStates + firstNormalisedVector[i]] += fractionalState; } */ /* Optimised for number of FP operations now O(states) instead of O(vectorLength) */ for (i = 0; i < vectorLength; i++) { firstStateCounts[firstNormalisedVector[i]] += 1; secondStateCounts[secondNormalisedVector[i]] += 1; jointStateCounts[secondNormalisedVector[i] * firstNumStates + firstNormalisedVector[i]] += 1; } for (i = 0; i < firstNumStates; i++) { firstStateProbs[i] = firstStateCounts[i] / length; } for (i = 0; i < secondNumStates; i++) { secondStateProbs[i] = secondStateCounts[i] / length; } for (i = 0; i < jointNumStates; i++) { jointStateProbs[i] = jointStateCounts[i] / length; } FREE_FUNC(firstNormalisedVector); FREE_FUNC(secondNormalisedVector); FREE_FUNC(firstStateCounts); FREE_FUNC(secondStateCounts); FREE_FUNC(jointStateCounts); firstNormalisedVector = NULL; secondNormalisedVector = NULL; firstStateCounts = NULL; secondStateCounts = NULL; jointStateCounts = NULL; /* **typedef struct **{ ** double *jointProbabilityVector; ** int numJointStates; ** double *firstProbabilityVector; ** int numFirstStates; ** double *secondProbabilityVector; ** int numSecondStates; **} JointProbabilityState; */ state.jointProbabilityVector = jointStateProbs; state.numJointStates = jointNumStates; state.firstProbabilityVector = firstStateProbs; state.numFirstStates = firstNumStates; state.secondProbabilityVector = secondStateProbs; state.numSecondStates = secondNumStates; return state; }/*calculateJointProbability(double *,double *, int)*/
WeightedJointProbState calculateWeightedJointProbability(double *firstVector, double *secondVector, double *weightVector, int vectorLength) { int *firstNormalisedVector; int *secondNormalisedVector; int *firstStateCounts; int *secondStateCounts; int *jointStateCounts; double *firstStateProbs; double *secondStateProbs; double *jointStateProbs; double *firstWeightVec; double *secondWeightVec; double *jointWeightVec; int firstNumStates; int secondNumStates; int jointNumStates; int i; double length = vectorLength; WeightedJointProbState state; firstNormalisedVector = (int *) checkedCalloc(vectorLength,sizeof(int)); secondNormalisedVector = (int *) checkedCalloc(vectorLength,sizeof(int)); firstNumStates = normaliseArray(firstVector,firstNormalisedVector,vectorLength); secondNumStates = normaliseArray(secondVector,secondNormalisedVector,vectorLength); jointNumStates = firstNumStates * secondNumStates; firstStateCounts = (int *) checkedCalloc(firstNumStates,sizeof(int)); secondStateCounts = (int *) checkedCalloc(secondNumStates,sizeof(int)); jointStateCounts = (int *) checkedCalloc(jointNumStates,sizeof(int)); firstStateProbs = (double *) checkedCalloc(firstNumStates,sizeof(double)); secondStateProbs = (double *) checkedCalloc(secondNumStates,sizeof(double)); jointStateProbs = (double *) checkedCalloc(jointNumStates,sizeof(double)); firstWeightVec = (double *) checkedCalloc(firstNumStates,sizeof(double)); secondWeightVec = (double *) checkedCalloc(secondNumStates,sizeof(double)); jointWeightVec = (double *) checkedCalloc(jointNumStates,sizeof(double)); for (i = 0; i < vectorLength; i++) { firstStateCounts[firstNormalisedVector[i]] += 1; secondStateCounts[secondNormalisedVector[i]] += 1; jointStateCounts[secondNormalisedVector[i] * firstNumStates + firstNormalisedVector[i]] += 1; firstWeightVec[firstNormalisedVector[i]] += weightVector[i]; secondWeightVec[secondNormalisedVector[i]] += weightVector[i]; jointWeightVec[secondNormalisedVector[i] * firstNumStates + firstNormalisedVector[i]] += weightVector[i]; } for (i = 0; i < firstNumStates; i++) { if (firstStateCounts[i]) { firstStateProbs[i] = firstStateCounts[i] / length; firstWeightVec[i] /= firstStateCounts[i]; } } for (i = 0; i < secondNumStates; i++) { if (secondStateCounts[i]) { secondStateProbs[i] = secondStateCounts[i] / length; secondWeightVec[i] /= secondStateCounts[i]; } } for (i = 0; i < jointNumStates; i++) { if (jointStateCounts[i]) { jointStateProbs[i] = jointStateCounts[i] / length; jointWeightVec[i] /= jointStateCounts[i]; } } FREE_FUNC(firstNormalisedVector); FREE_FUNC(secondNormalisedVector); FREE_FUNC(firstStateCounts); FREE_FUNC(secondStateCounts); FREE_FUNC(jointStateCounts); firstNormalisedVector = NULL; secondNormalisedVector = NULL; firstStateCounts = NULL; secondStateCounts = NULL; jointStateCounts = NULL; /* **typedef struct **{ ** double *jointProbabilityVector; ** double *jointWeightVector; ** int numJointStates; ** double *firstProbabilityVector; ** double *firstWeightVector; ** int numFirstStates; ** double *secondProbabilityVector; ** double *secondWeightVector; ** int numSecondStates; **} WeightedJointProbState; */ state.jointProbabilityVector = jointStateProbs; state.jointWeightVector = jointWeightVec; state.numJointStates = jointNumStates; state.firstProbabilityVector = firstStateProbs; state.firstWeightVector = firstWeightVec; state.numFirstStates = firstNumStates; state.secondProbabilityVector = secondStateProbs; state.secondWeightVector = secondWeightVec; state.numSecondStates = secondNumStates; return state; }/*calculateJointProbability(double *,double *, int)*/
static void calculateTempo(struct btrack * bt){ double aux_buffer[512]; // adaptive threshold on input adaptiveThreshold(bt->resampledOnsetDF,512, aux_buffer); // calculate auto-correlation function of detection function calculateBalancedACF(bt->resampledOnsetDF, bt->acf); // calculate output of comb filterbank calculateOutputOfCombFilterBank(bt); // adaptive threshold on rcf adaptiveThreshold(bt->combFilterBankOutput,128, aux_buffer); int t_index; int t_index2; // calculate tempo observation vector from beat period observation vector for (int i = 0;i < 41;i++) { t_index = (int) round(bt->tempoToLagFactor / ((double) ((2*i)+80))); t_index2 = (int) round(bt->tempoToLagFactor / ((double) ((4*i)+160))); bt->tempoObservationVector[i] = bt->combFilterBankOutput[t_index-1] + bt->combFilterBankOutput[t_index2-1]; } double maxval; double maxind; double curval; // if tempo is fixed then always use a fixed set of tempi as the previous observation probability function if(bt->tempoFixed) { for (int k = 0;k < 41;k++) { bt->prevDelta[k] = bt->prevDeltaFixed[k]; } } for(int j=0;j < 41;j++) { maxval = -1; for (int i = 0;i < 41;i++) { curval = bt->prevDelta[i]*bt->tempoTransitionMatrix[i][j]; if (curval > maxval) { maxval = curval; } } bt->delta[j] = maxval*bt->tempoObservationVector[j]; } normaliseArray(bt->delta,41); maxind = -1; maxval = -1; for (int j=0;j < 41;j++) { if (bt->delta[j] > maxval) { maxval = bt->delta[j]; maxind = j; } bt->prevDelta[j] = bt->delta[j]; } bt->beatPeriod = round((60.0*44100.0)/(((2*maxind)+80)*((double) bt->hopSize))); if (bt->beatPeriod > 0) { bt->estimatedTempo = 60.0/((((double) bt->hopSize) / 44100.0)*bt->beatPeriod); } }
/******************************************************************************* **entry point for the mex call **nlhs - number of outputs **plhs - pointer to array of outputs **nrhs - number of inputs **prhs - pointer to array of inputs *******************************************************************************/ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /***************************************************************************** ** this function takes a flag and a variable number of arguments ** depending on the value of the flag and returns either a construct ** containing probability estimates, a merged vector or a double value ** representing an entropy or mutual information *****************************************************************************/ int flag, i, numberOfSamples, checkSamples, thirdCheckSamples, numberOfFeatures, checkFeatures, thirdCheckFeatures; int numArities, errorTest; double *dataVector, *condVector, *targetVector, *firstVector, *secondVector, *output, *numStates; double *matrix, *mergedVector, *arities; int *outputIntVector, *intArities; double *jointOutput, *numJointStates, *firstOutput, *numFirstStates, *secondOutput, *numSecondStates; ProbabilityState state; JointProbabilityState jointState; /*if (nlhs != 1) { printf("Incorrect number of output arguments\n"); }//if not 1 output */ switch (nrhs) { case 2: { /*printf("Must be H(X), calculateProbability(X), merge(X), normaliseArray(X)\n");*/ break; } case 3: { /*printf("Must be H(XY), H(X|Y), calculateJointProbability(XY), I(X;Y)\n");*/ break; } case 4: { /*printf("Must be I(X;Y|Z)\n");*/ break; } default: { printf("Incorrect number of arguments, format is MIToolbox(\"FLAG\",varargin)\n"); break; } } /* number to function map ** 1 = calculateProbability ** 2 = calculateJointProbability ** 3 = mergeArrays ** 4 = H(X) ** 5 = H(XY) ** 6 = H(X|Y) ** 7 = I(X;Y) ** 8 = I(X;Y|Z) ** 9 = normaliseArray */ flag = *mxGetPr(prhs[0]); switch (flag) { case 1: { /* **calculateProbability */ numberOfSamples = mxGetM(prhs[1]); dataVector = (double *) mxGetPr(prhs[1]); /*ProbabilityState calculateProbability(double *dataVector, int vectorLength);*/ state = calculateProbability(dataVector,numberOfSamples); plhs[0] = mxCreateDoubleMatrix(state.numStates,1,mxREAL); plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL); output = (double *)mxGetPr(plhs[0]); numStates = (double *) mxGetPr(plhs[1]); *numStates = state.numStates; for (i = 0; i < state.numStates; i++) { output[i] = state.probabilityVector[i]; } break; }/*case 1 - calculateProbability*/ case 2: { /* **calculateJointProbability */ numberOfSamples = mxGetM(prhs[1]); firstVector = (double *) mxGetPr(prhs[1]); secondVector = (double *) mxGetPr(prhs[2]); /*JointProbabilityState calculateJointProbability(double *firstVector, double *secondVector int vectorLength);*/ jointState = calculateJointProbability(firstVector,secondVector,numberOfSamples); plhs[0] = mxCreateDoubleMatrix(jointState.numJointStates,1,mxREAL); plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL); plhs[2] = mxCreateDoubleMatrix(jointState.numFirstStates,1,mxREAL); plhs[3] = mxCreateDoubleMatrix(1,1,mxREAL); plhs[4] = mxCreateDoubleMatrix(jointState.numSecondStates,1,mxREAL); plhs[5] = mxCreateDoubleMatrix(1,1,mxREAL); jointOutput = (double *)mxGetPr(plhs[0]); numJointStates = (double *) mxGetPr(plhs[1]); firstOutput = (double *)mxGetPr(plhs[2]); numFirstStates = (double *) mxGetPr(plhs[3]); secondOutput = (double *)mxGetPr(plhs[4]); numSecondStates = (double *) mxGetPr(plhs[5]); *numJointStates = jointState.numJointStates; *numFirstStates = jointState.numFirstStates; *numSecondStates = jointState.numSecondStates; for (i = 0; i < jointState.numJointStates; i++) { jointOutput[i] = jointState.jointProbabilityVector[i]; } for (i = 0; i < jointState.numFirstStates; i++) { firstOutput[i] = jointState.firstProbabilityVector[i]; } for (i = 0; i < jointState.numSecondStates; i++) { secondOutput[i] = jointState.secondProbabilityVector[i]; } break; }/*case 2 - calculateJointProbability */ case 3: { /* **mergeArrays */ numberOfSamples = mxGetM(prhs[1]); numberOfFeatures = mxGetN(prhs[1]); numArities = 0; if (nrhs > 2) { numArities = mxGetN(prhs[2]); /*printf("arities = %d, features = %d, samples = %d\n",numArities,numberOfFeatures,numberOfSamples);*/ } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); if (numArities == 0) { /* **no arities therefore compress output */ if ((numberOfFeatures > 0) && (numberOfSamples > 0)) { matrix = (double *) mxGetPr(prhs[1]); mergedVector = (double *) mxCalloc(numberOfSamples,sizeof(double)); plhs[0] = mxCreateDoubleMatrix(numberOfSamples,1,mxREAL); output = (double *)mxGetPr(plhs[0]); /*int mergeMultipleArrays(double *inputMatrix, double *outputVector, int matrixWidth, int vectorLength)*/ mergeMultipleArrays(matrix, mergedVector, numberOfFeatures, numberOfSamples); for (i = 0; i < numberOfSamples; i++) { output[i] = mergedVector[i]; } mxFree(mergedVector); mergedVector = NULL; } } else if (numArities == numberOfFeatures) { if ((numberOfFeatures > 0) && (numberOfSamples > 0)) { matrix = (double *) mxGetPr(prhs[1]); mergedVector = (double *) mxCalloc(numberOfSamples,sizeof(double)); arities = (double *) mxGetPr(prhs[2]); intArities = (int *) mxCalloc(numberOfFeatures,sizeof(int)); for (i = 0; i < numArities; i++) { intArities[i] = (int) floor(arities[i]); } /*int mergeMultipleArrays(double *inputMatrix, double *outputVector, int matrixWidth, int *arities, int vectorLength);*/ errorTest = mergeMultipleArraysArities(matrix, mergedVector, numberOfFeatures, intArities, numberOfSamples); if (errorTest != -1) { plhs[0] = mxCreateDoubleMatrix(numberOfSamples,1,mxREAL); output = (double *)mxGetPr(plhs[0]); for (i = 0; i < numberOfSamples; i++) { output[i] = mergedVector[i]; } } else { printf("Incorrect arities supplied. More states in data than specified\n"); } mxFree(mergedVector); mergedVector = NULL; } } else { printf("Number of arities does not match number of features, arities should be a row vector\n"); } break; }/*case 3 - mergeArrays*/ case 4: { /* **H(X) */ numberOfSamples = mxGetM(prhs[1]); numberOfFeatures = mxGetN(prhs[1]); dataVector = (double *) mxGetPr(prhs[1]); plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL); output = (double *)mxGetPr(plhs[0]); if (numberOfFeatures == 1) { /*double calculateEntropy(double *dataVector, int vectorLength);*/ *output = calculateEntropy(dataVector,numberOfSamples); } else { printf("No columns in input\n"); *output = -1.0; } break; }/*case 4 - H(X)*/ case 5: { /* **H(XY) */ numberOfSamples = mxGetM(prhs[1]); checkSamples = mxGetM(prhs[2]); numberOfFeatures = mxGetN(prhs[1]); checkFeatures = mxGetN(prhs[2]); firstVector = mxGetPr(prhs[1]); secondVector = mxGetPr(prhs[2]); plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL); output = (double *)mxGetPr(plhs[0]); if ((numberOfFeatures == 1) && (checkFeatures == 1)) { if ((numberOfSamples == 0) && (checkSamples == 0)) { *output = 0.0; } else if (numberOfSamples == 0) { *output = calculateEntropy(secondVector,numberOfSamples); } else if (checkSamples == 0) { *output = calculateEntropy(firstVector,numberOfSamples); } else if (numberOfSamples == checkSamples) { /*double calculateJointEntropy(double *firstVector, double *secondVector, int vectorLength);*/ *output = calculateJointEntropy(firstVector,secondVector,numberOfSamples); } else { printf("Vector lengths do not match, they must be the same length\n"); *output = -1.0; } } else { printf("No columns in input\n"); *output = -1.0; } break; }/*case 5 - H(XY)*/ case 6: { /* **H(X|Y) */ numberOfSamples = mxGetM(prhs[1]); checkSamples = mxGetM(prhs[2]); numberOfFeatures = mxGetN(prhs[1]); checkFeatures = mxGetN(prhs[2]); dataVector = mxGetPr(prhs[1]); condVector = mxGetPr(prhs[2]); plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL); output = (double *)mxGetPr(plhs[0]); if ((numberOfFeatures == 1) && (checkFeatures == 1)) { if (numberOfSamples == 0) { *output = 0.0; } else if (checkSamples == 0) { *output = calculateEntropy(dataVector,numberOfSamples); } else if (numberOfSamples == checkSamples) { /*double calculateConditionalEntropy(double *dataVector, double *condVector, int vectorLength);*/ *output = calculateConditionalEntropy(dataVector,condVector,numberOfSamples); } else { printf("Vector lengths do not match, they must be the same length\n"); *output = -1.0; } } else { printf("No columns in input\n"); *output = -1.0; } break; }/*case 6 - H(X|Y)*/ case 7: { /* **I(X;Y) */ numberOfSamples = mxGetM(prhs[1]); checkSamples = mxGetM(prhs[2]); numberOfFeatures = mxGetN(prhs[1]); checkFeatures = mxGetN(prhs[2]); firstVector = mxGetPr(prhs[1]); secondVector = mxGetPr(prhs[2]); plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL); output = (double *)mxGetPr(plhs[0]); if ((numberOfFeatures == 1) && (checkFeatures == 1)) { if ((numberOfSamples == 0) || (checkSamples == 0)) { *output = 0.0; } else if (numberOfSamples == checkSamples) { /*double calculateMutualInformation(double *firstVector, double *secondVector, int vectorLength);*/ *output = calculateMutualInformation(firstVector,secondVector,numberOfSamples); } else { printf("Vector lengths do not match, they must be the same length\n"); *output = -1.0; } } else { printf("No columns in input\n"); *output = -1.0; } break; }/*case 7 - I(X;Y)*/ case 8: { /* **I(X;Y|Z) */ numberOfSamples = mxGetM(prhs[1]); checkSamples = mxGetM(prhs[2]); thirdCheckSamples = mxGetM(prhs[3]); numberOfFeatures = mxGetN(prhs[1]); checkFeatures = mxGetN(prhs[2]); thirdCheckFeatures = mxGetN(prhs[3]); firstVector = mxGetPr(prhs[1]); targetVector = mxGetPr(prhs[2]); condVector = mxGetPr(prhs[3]); plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL); output = (double *)mxGetPr(plhs[0]); if ((numberOfFeatures == 1) && (checkFeatures == 1)) { if ((numberOfSamples == 0) || (checkSamples == 0)) { *output = 0.0; } else if ((thirdCheckSamples == 0) || (thirdCheckFeatures != 1)) { *output = calculateMutualInformation(firstVector,targetVector,numberOfSamples); } else if ((numberOfSamples == checkSamples) && (numberOfSamples == thirdCheckSamples)) { /*double calculateConditionalMutualInformation(double *firstVector, double *targetVector, double *condVector, int vectorLength);*/ *output = calculateConditionalMutualInformation(firstVector,targetVector,condVector,numberOfSamples); } else { printf("Vector lengths do not match, they must be the same length\n"); *output = -1.0; } } else { printf("No columns in input\n"); *output = -1.0; } break; }/*case 8 - I(X;Y|Z)*/ case 9: { /* **normaliseArray */ numberOfSamples = mxGetM(prhs[1]); dataVector = (double *) mxGetPr(prhs[1]); outputIntVector = (int *) mxCalloc(numberOfSamples,sizeof(int)); plhs[0] = mxCreateDoubleMatrix(numberOfSamples,1,mxREAL); plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL); output = (double *)mxGetPr(plhs[0]); numStates = (double *) mxGetPr(plhs[1]); /*int normaliseArray(double *inputVector, int *outputVector, int vectorLength);*/ *numStates = normaliseArray(dataVector, outputIntVector, numberOfSamples); for (i = 0; i < numberOfSamples; i++) { output[i] = outputIntVector[i]; } break; }/*case 9 - normaliseArray*/ default: { printf("Unrecognised flag\n"); break; }/*default*/ }/*switch(flag)*/ return; }/*mexFunction()*/