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()*/
