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