double calculateEntropy(double *dataVector, int vectorLength)
{
double entropy = 0.0;
double tempValue = 0.0;
int i;
ProbabilityState state = calculateProbability(dataVector,vectorLength);
/*H(X) = - sum p(x) log p(x)*/
for (i = 0; i < state.numStates; i++)
{
tempValue = state.probabilityVector[i];
if (tempValue > 0)
{
entropy -= tempValue * log(tempValue);
}
}
entropy /= log(2.0);
FREE_FUNC(state.probabilityVector);
state.probabilityVector = NULL;
return entropy;
}/*calculateEntropy(double *,int)*/
void CueContrastKernel::runkernel(CvPoint2D32f* nextpos, CSCVector* prob_cand, float* rel, float hval) {
if(debug) std::cout << getName() << "::runkernel()\n";
bool result = false;
int count = 0;
CvPoint2D32f oldpos = m_y0;
//CvSize objsize = m_track.winnerSize;
if(debug) std::cout << getName() << "::runkernel()::oldpos = [" << oldpos.x << " " << oldpos.y << "]\n";
while(!result){
switch(m_opmode) {
case SIMPLE:
//cropNResize(&oldpos, &objsize, hval);
cropNResize(&oldpos, &m_objsizenorm, hval);
calculateProbability(prob_cand, hval);
break;
default:
std::cerr << getName() << "::runkernel()::Currently only SIMPLE mode is supported!\n";
return;
}
computeWeights(prob_cand); // Step2
findNextLocation(nextpos, hval); // Step 3
//if(debug) std::cout << getName() << "::runkernel()::nextpos = [" << nextpos->x << " " << nextpos->y << "]\n";
result = checkCondition(&oldpos, nextpos, count); // Step 6
if(debug) std::cout << getName() << "::runkernel()::count = " << count << ", nextpos = [" << nextpos->x << ", " << nextpos->y << "]\n";
count++;
}
(*rel) = computeSimilarity(prob_cand, &m_target_model);
if(debug) std::cout << getName() << "::runkernel()::while() loop complete::count = " << count << ", rel = " << (*rel) << ", nextpos = [" << nextpos->x << ", " << nextpos->y << "]\n";
}
void CueContrastKernel::test() {
int startx = std::min(m_track.winnerSize.width, m_track.winnerPos.x - cvRound((float)m_track.winnerSize.width/2.0));
int endx = std::max(m_track.imageSize.width-m_track.winnerSize.width, m_track.winnerPos.x + cvRound((float)m_track.winnerSize.width/2.0));
int starty = std::min(m_track.winnerSize.height, m_track.winnerPos.y - cvRound((float)m_track.winnerSize.height/2.0));
int endy = std::max(m_track.imageSize.height-m_track.winnerSize.height, m_track.winnerPos.y + cvRound((float)m_track.winnerSize.height/2.0));
CvPoint2D32f pos;
cvSetZero(mp_cvoutputimg->ipl);
float* salmap = (float*)(mp_cvoutputimg->ipl->imageData);
int salwidth = mp_cvoutputimg->width;
for(int j = starty;j<endy;++j) {
for(int i = startx;i<endx;++i) {
pos.x = i;
pos.y = j;
cropNResize(&pos, &(m_track.winnerSize), 1.0);
calculateProbability(&(mp_target_candidate[0]), 1.0);
float sim = computeSimilarity(&(mp_target_candidate[0]), &m_target_model);
salmap[j*salwidth + i] = sim;
}
}
cvSalImageOut.out();
}
double calculateRenyiEntropy(double alpha, double *dataVector, int vectorLength)
{
double entropy = 0.0;
double tempValue = 0.0;
int i;
ProbabilityState state = calculateProbability(dataVector,vectorLength);
/*H_\alpha(X) = 1/(1-alpha) * log(2)(sum p(x)^alpha)*/
for (i = 0; i < state.numStates; i++)
{
tempValue = state.probabilityVector[i];
if (tempValue > 0)
{
entropy += pow(tempValue,alpha);
/*printf("Entropy = %f, i = %d\n", entropy,i);*/
}
}
/*printf("Entropy = %f\n", entropy);*/
entropy = log(entropy);
entropy /= log(2.0);
entropy /= (1.0-alpha);
/*printf("Entropy = %f\n", entropy);*/
FREE_FUNC(state.probabilityVector);
state.probabilityVector = NULL;
return entropy;
}/*calculateRenyiEntropy(double,double*,int)*/
double calcEntropy(uint* dataVector, int vectorLength) {
ProbabilityState state = calculateProbability(dataVector, vectorLength);
double h = entropy(state);
freeProbabilityState(state);
return h;
}/*calcEntropy(uint* ,int)*/
double WayMergeManipulation::calculateScore(ConstOsmMapPtr map) const
{
assert(isValid(map));
_p = calculateProbability(map);
return _p;
}
int main(void) {
int cases;
char temp[100];
scanf("%d", &cases);
for(int c=1;c<=cases;c++) {
scanf("%d %s", &numRoads, temp);
numCities = 0;
for(int i=0;i<numRoads;i++) {
scanf("%s %s %d", roads[i].city1, roads[i].city2, &roads[i].time);
roads[i].id1 = getCity(roads[i].city1);
roads[i].id2 = getCity(roads[i].city2);
roads[i].prob = 0;
}
calculateMinDistances();
calculateRoutes();
calculateProbability(getCity(temp));
printf("Case #%d:", c);
for(int i=0;i<numRoads;i++) printf(" %.7f", roads[i].prob);
printf("\n");
}
}
void CueContrastKernel::initialize() {
if(debug) std::cout << getName() << "::initialize()\n";
obtainInput();
TrackData* track = trackIn.getBuffer();
if(!track) {
if(debug) std::cerr << getName() << "::ERROR::initialize()::trackIn is NULL!...\n";
return;
}
if(track->reliability < m_threshold) {
if(debug) std::cerr << getName() << "::ERROR::initialize()::track->reliability below threshold!...\n";
return;
}
if (!mp_cvoutputimg) {
unsigned int width = mp_cvimg1->width;
unsigned int height = mp_cvimg1->height;
if(debug) std::cout << getName() << "::initialize()::mp_cvimg1 size = [" << width << " " << height << "]\n";
mp_cvoutputimg = new CVImage(cvSize(width, height), CV_32FC1, 0);
cvSalImageOut.setBuffer(mp_cvoutputimg);
}
cvSetZero(mp_cvoutputimg->ipl);
if(!mp_cvimg1) { std::cerr << getName() << "::ERROR::initialize()::mp_cvimg1 is NULL!\n"; return; }
float xratio, yratio;
xratio = (float)(mp_cvimg1->width) / (float)(track->imageSize.width);
yratio = (float)(mp_cvimg1->height) / (float)(track->imageSize.height);
m_track.winnerPos.x = cvRound( (float)(track->winnerPos.x) * xratio );
m_track.winnerPos.y = cvRound( (float)(track->winnerPos.y) * yratio );
m_track.winnerSize.width = cvRound( (float)(track->winnerSize.width) * xratio );
m_track.winnerSize.height = cvRound( (float)(track->winnerSize.height) * xratio );
m_track.winnerRect.x = m_track.winnerPos.x - cvRound( (float)(m_track.winnerSize.width)/2.0 );
m_track.winnerRect.y = m_track.winnerPos.y - cvRound( (float)(m_track.winnerSize.height)/2.0 );
m_track.winnerRect.width = m_track.winnerSize.width;
m_track.winnerRect.height = m_track.winnerSize.height;
m_track.reliability = track->reliability;
m_track.imageSize.width = mp_cvimg1->width;
m_track.imageSize.height = mp_cvimg1->height;
// mp_objSize = &(m_track.winnerSize);
m_objsize = m_track.winnerSize;
if(!m_forceNormSize) m_objsizenorm = m_objsize;
m_target_model.setZero();
for(int i = 0;i<3;i++) mp_target_candidate[i].setZero();
unsigned int size;
if(m_forceMinSize) {
size = std::max(m_track.winnerSize.width, m_minSize);
m_track.winnerSize.width = size;
size = std::max(m_track.winnerSize.height, m_minSize);
m_track.winnerSize.height = size;
}
size = (m_track.winnerSize.width) * (m_track.winnerSize.height);
m_weight.allocate(size);
m_weight.setZero();
CvPoint2D32f winner;
winner.x = (float)(m_track.winnerPos.x);
winner.y = (float)(m_track.winnerPos.y);
CvSize objsize;
objsize = m_track.winnerSize;
if(debug) std::cout << getName() << "::initialize()::obj size = [" << objsize.width << " " << objsize.height << "]\n";
if(mp_cvmaskimg) delete mp_cvmaskimg;
mp_cvmaskimg = NULL;
float* src = m_target_model.getData();
float* dst = mp_target_candidate[0].getData();
float* orig = m_target_orig.getData();
float sim;
switch(m_opmode) {
case SIMPLE:
//cropNResize(&winner, &objsize, 1.0);
cropNResize(&winner, &m_objsizenorm, 1.0);
calculateProbability(&m_target_model, 1.0);
memcpy((char*)dst, (char*)src, m_totalnumbins*sizeof(float));
memcpy((char*)orig, (char*)src, m_totalnumbins*sizeof(float));
sim = computeSimilarity(&(mp_target_candidate[0]), &m_target_model);
drawGrayBall(&winner, &objsize);
break;
default:
std::cerr << getName() << "::initialize()::ERROR::Currently only SIMPLE mode is supported!\n";
return;
}
cvSalImageOut.out();
if(draw) {
mpDrawModel->dataIn.setBuffer(&m_target_model);
mpDrawCandidate->dataIn.setBuffer(&(mp_target_candidate[0]));
mpDrawModel->execute();
mpDrawCandidate->execute();
cvModelOut.setBuffer(mpDrawModel->cvImageOut.getBuffer());
cvCandidateOut.setBuffer(mpDrawCandidate->cvImageOut.getBuffer());
cvModelOut.out();
cvCandidateOut.out();
}
m_init = true;
if(debug) std::cout << getName() << "::initialize() complete\n";
}
/*******************************************************************************
**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()*/
double calcCondRenyiEnt(double alpha, double *dataVector, double *conditionVector, int uniqueInCondVector, int vectorLength)
{
/*uniqueInCondVector = is the number of unique values in the cond vector.*/
/*condEntropy = sum p(y) * sum p(x|y)^alpha(*/
/*
** first generate the seperate variables
*/
double *seperateVectors = (double *) checkedCalloc(uniqueInCondVector*vectorLength,sizeof(double));
int *seperateVectorCount = (int *) checkedCalloc(uniqueInCondVector,sizeof(int));
double seperateVectorProb = 0.0;
int i,j;
double entropy = 0.0;
double tempValue = 0.0;
int currentValue;
double tempEntropy;
ProbabilityState state;
double **seperateVectors2D = (double **) checkedCalloc(uniqueInCondVector,sizeof(double*));
for(j=0; j < uniqueInCondVector; j++)
seperateVectors2D[j] = seperateVectors + (int)j*vectorLength;
for (i = 0; i < vectorLength; i++)
{
currentValue = (int) (conditionVector[i] - 1.0);
/*printf("CurrentValue = %d\n",currentValue);*/
seperateVectors2D[currentValue][seperateVectorCount[currentValue]] = dataVector[i];
seperateVectorCount[currentValue]++;
}
for (j = 0; j < uniqueInCondVector; j++)
{
tempEntropy = 0.0;
seperateVectorProb = ((double)seperateVectorCount[j]) / vectorLength;
state = calculateProbability(seperateVectors2D[j],seperateVectorCount[j]);
/*H_\alpha(X) = 1/(1-alpha) * log(2)(sum p(x)^alpha)*/
for (i = 0; i < state.numStates; i++)
{
tempValue = state.probabilityVector[i];
if (tempValue > 0)
{
tempEntropy += pow(tempValue,alpha);
/*printf("Entropy = %f, i = %d\n", entropy,i);*/
}
}
/*printf("Entropy = %f\n", entropy);*/
tempEntropy = log(tempEntropy);
tempEntropy /= log(2.0);
tempEntropy /= (1.0-alpha);
entropy += tempEntropy;
FREE_FUNC(state.probabilityVector);
}
FREE_FUNC(seperateVectors2D);
seperateVectors2D = NULL;
FREE_FUNC(seperateVectors);
FREE_FUNC(seperateVectorCount);
seperateVectors = NULL;
seperateVectorCount = NULL;
return entropy;
}/*calcCondRenyiEnt(double *,double *,int)*/
