mxArray *sf_c13_ARP_02_RPSs_Bdr_GK_BIS2_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("yPPzDIGn5DPyGYnrHi4YC"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
mxArray *sf_c3_ARP_02_RPSsmile_Glove_atomicError_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("6ToljhSGzQbPoAkW7t0cfB"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
/** * Input arguments: dataset (matrix), params (struct) * Output arguments: index (pointer to index), params (struct), speedup(double) */ static void _build_index(int nOutArray, mxArray* OutArray[], int nInArray, const mxArray* InArray[]) { /* Check the number of input arguments */ if(nInArray != 2) { mexErrMsgTxt("Incorrect number of input arguments"); } /* Check the number of output arguments */ if ((nOutArray == 0)||(nOutArray > 3)) { mexErrMsgTxt("Incorrect number of outputs."); } const mxArray* datasetMat = InArray[0]; check_allowed_type(datasetMat); int dcount = mxGetN(datasetMat); int length = mxGetM(datasetMat); const mxArray* pStruct = InArray[1]; /* get index parameters */ FLANNParameters p; matlabStructToFlannStruct(pStruct, p); float speedup = -1; TypedIndex* typedIndex = new TypedIndex(); if (mxIsSingle(datasetMat)) { float* dataset = (float*) mxGetData(datasetMat); typedIndex->index = flann_build_index_float(dataset,dcount,length, &speedup, &p); typedIndex->type = FLANN_FLOAT32; } else if (mxIsDouble(datasetMat)) { double* dataset = (double*) mxGetData(datasetMat); typedIndex->index = flann_build_index_double(dataset,dcount,length, &speedup, &p); typedIndex->type = FLANN_FLOAT64; } else if (mxIsUint8(datasetMat)) { unsigned char* dataset = (unsigned char*) mxGetData(datasetMat); typedIndex->index = flann_build_index_byte(dataset,dcount,length, &speedup, &p); typedIndex->type = FLANN_UINT8; } else if (mxIsInt32(datasetMat)) { int* dataset = (int*) mxGetData(datasetMat); typedIndex->index = flann_build_index_int(dataset,dcount,length, &speedup, &p); typedIndex->type = FLANN_INT32; } mxClassID classID; if (sizeof(flann_index_t)==4) { classID = mxUINT32_CLASS; } else if (sizeof(flann_index_t)==8) { classID = mxUINT64_CLASS; } /* Allocate memory for Output Matrix */ OutArray[0] = mxCreateNumericMatrix(1, 1, classID, mxREAL); /* Get pointer to Output matrix and store result*/ TypedIndex** pOut = (TypedIndex**)mxGetData(OutArray[0]); pOut[0] = typedIndex; if (nOutArray > 1) { const char* fieldnames[] = {"algorithm", "checks", "trees", "branching", "iterations", "centers_init", "cb_index"}; OutArray[1] = mxCreateStructMatrix(1, 1, sizeof(fieldnames)/sizeof(const char*), fieldnames); flannStructToMatlabStruct(p, OutArray[1]); } if (nOutArray > 2) { OutArray[2] = mxCreateDoubleMatrix(1, 1, mxREAL); double* pSpeedup = mxGetPr(OutArray[2]); *pSpeedup = speedup; } }
mxArray *sf_c2_DSHMHittingSecondORder_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("CA8SwQL6JonaLH0nyQxer"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,3,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,2,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,2,"type",mxType); } mxSetField(mxData,2,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
mxArray *sf_c41_EP_IdleRandMerg_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("owiJaNyyUF6NPDrFrFjQvH"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,2,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
mxArray *sf_c4_trajectory_test_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = {"checksum","inputs","parameters","outputs"}; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,4,autoinheritanceFields); { mxArray *mxChecksum = mxCreateDoubleMatrix(4,1,mxREAL); double *pr = mxGetPr(mxChecksum); pr[0] = (double)(3468697740U); pr[1] = (double)(2591828673U); pr[2] = (double)(139957213U); pr[3] = (double)(1717524660U); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = {"size","type","complexity"}; mxArray *mxData = mxCreateStructMatrix(1,8,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,2,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,2,"type",mxType); } mxSetField(mxData,2,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,3,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,3,"type",mxType); } mxSetField(mxData,3,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,4,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,4,"type",mxType); } mxSetField(mxData,4,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,5,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,5,"type",mxType); } mxSetField(mxData,5,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,6,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,6,"type",mxType); } mxSetField(mxData,6,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,7,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,7,"type",mxType); } mxSetField(mxData,7,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0,mxREAL)); } { const char *dataFields[] = {"size","type","complexity"}; mxArray *mxData = mxCreateStructMatrix(1,3,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,2,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,2,"type",mxType); } mxSetField(mxData,2,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } return(mxAutoinheritanceInfo); }
PsychError PSYCHHIDSetReport(void) { long error; pRecDevice device; int deviceIndex; int reportType; // kIOHIDReportTypeInput=0, kIOHIDReportTypeOutput=1, or kIOHIDReportTypeFeature=2 int reportID; unsigned char *reportBuffer; int reportSize; const mxArray *report; mxArray **outErr; int i; PsychPushHelp(useString,synopsisString,seeAlsoString); if(PsychIsGiveHelp()){PsychGiveHelp();return(PsychError_none);}; PsychErrorExit(PsychCapNumOutputArgs(1)); PsychErrorExit(PsychCapNumInputArgs(4)); outErr=PsychGetOutArgMxPtr(1); assert(outErr!=NULL); PsychCopyInIntegerArg(1,TRUE,&deviceIndex); PsychCopyInIntegerArg(2,TRUE,&reportType); PsychCopyInIntegerArg(3,TRUE,&reportID); report=PsychGetInArgMxPtr(4); reportBuffer=(void *)mxGetPr(report); assert(reportBuffer!=NULL); switch(mxGetClassID(report)){ case mxCHAR_CLASS: case mxINT8_CLASS: case mxUINT8_CLASS: case mxINT16_CLASS: case mxUINT16_CLASS: case mxINT32_CLASS: case mxUINT32_CLASS: break; default: PrintfExit("\"report\" array must be char or integer (8-, 16-, or 32-bit)."); break; } reportSize=mxGetElementSize(report)*mxGetNumberOfElements(report); PsychHIDVerifyInit(); device=PsychHIDGetDeviceRecordPtrFromIndex(deviceIndex); if(reportSize>0 && reportID!=0) *reportBuffer=0xff&reportID; // copy low byte of reportID to first byte of report. // Apple defines constants for the reportType with values (0,1,2) that are one less that those specified by USB (1,2,3). assert(kIOHIDReportTypeInput==0 && kIOHIDReportTypeOutput==1 && kIOHIDReportTypeFeature==2); if(reportType==0){ printf("SetReport(reportType %d, reportID %d, report ",reportType,reportID); for(i=0;i<reportSize;i++)printf("%d ",(int)reportBuffer[i]); printf(")\n"); error=0; }else{ if(1){ IOHIDDeviceInterface122 **interface; interface=(IOHIDDeviceInterface122 **)(device->interface); if(interface)error=(*interface)->setReport(interface,reportType-1,reportID,reportBuffer,(UInt32)reportSize,50,NULL,NULL,NULL); else PrintfExit("PsychHID SetReport: Bad interface.\n"); }else error=HIDSetReport(device,reportType-1,reportID,reportBuffer,(UInt32)reportSize); } if(reportID==0x11){ PsychGetPrecisionTimerSeconds(&AInScanStart); } //if(error)printf("Warning: PsychHID: HIDSetReport error %ld (0x%lx).",error,error); if(0){ *outErr=mxCreateDoubleMatrix(1,1,mxREAL); if(*outErr==NULL)PrintfExit("Couldn't allocate \"err\"."); *mxGetPr(*outErr)=(double)error; }else{ const char *fieldNames[]={"n", "name", "description"}; char *name="",*description=""; mxArray *fieldValue; PsychHIDErrors(error,&name,&description); *outErr=mxCreateStructMatrix(1,1,3,fieldNames); fieldValue=mxCreateString(name); if(fieldValue==NULL)PrintfExit("Couldn't allocate \"err\"."); mxSetField(*outErr,0,"name",fieldValue); fieldValue=mxCreateString(description); if(fieldValue==NULL)PrintfExit("Couldn't allocate \"err\"."); mxSetField(*outErr,0,"description",fieldValue); fieldValue=mxCreateDoubleMatrix(1,1,mxREAL); if(fieldValue==NULL)PrintfExit("Couldn't allocate \"err\"."); *mxGetPr(fieldValue)=(double)error; mxSetField(*outErr,0,"n",fieldValue); } return(PsychError_none); }
/* Function: mdlJacobian ====================================================== * Abstract: populate the model's Jacobian data. * See the on-line documentation for mxCreateSparse for * information regarding the format of Ir, Jc, and Pr data. * * [ A | B ] * J = [ --+-- ] (= D here) * [ C | D ] * */ static void mdlJacobian(SimStruct *S) { #if defined(MATLAB_MEX_FILE) real_T *Pr = ssGetJacobianPr(S); real_T *out; real_T *temp; uint_T nr = (uint_T) mxGetScalar(NUMREG(S)); ParStruc *Par = ssGetUserData(S); const real_T *Reg = ssGetInputPortRealSignal(S,0); /* input signals are contiguous */ int_T k; mxArray *plhs; mxArray *prhs[3]; mxArray *ParStruct, *TreeParStruct; mxArray *TypeStr; const char **fnamesPar; const char **fnamesTree; /* plhs = mxCreateDoubleMatrix(1,nr,mxREAL); */ TypeStr = mxCreateString("treepartition"); fnamesPar = mxCalloc(8, sizeof(*fnamesPar)); fnamesTree = mxCalloc(5, sizeof(*fnamesTree)); /* memory error check */ if ( (fnamesPar==NULL) || (fnamesTree==NULL) || (TypeStr==NULL) || (prhs==NULL)){ ssSetErrorStatus(S, "Could not allocate memory for Jacobian computation."); return; } /* Tree struct field names */ fnamesTree[0] = "TreeLevelPntr"; fnamesTree[1] = "AncestorDescendantPntr"; fnamesTree[2] = "LocalizingVectors"; fnamesTree[3] = "LocalCovMatrix"; fnamesTree[4] = "LocalParVector"; /* Parameter struct field names */ fnamesPar[0] = "NumberOfUnits"; fnamesPar[1] = "Threshold"; fnamesPar[2] = "RegressorMean"; fnamesPar[3] = "OutputOffset"; fnamesPar[4] = "LinearCoef"; fnamesPar[5] = "SampleLength"; fnamesPar[6] = "NoiseVariance"; fnamesPar[7] = "Tree"; TreeParStruct = mxCreateStructMatrix(1,1,5,fnamesTree); ParStruct = mxCreateStructMatrix(1,1,8,fnamesPar); /* do memory error check */ if ((TreeParStruct==NULL) || (ParStruct==NULL)){ ssSetErrorStatus(S, "Could not allocate memory for Jacobian computation."); return; } /* set fields of Parameters.Tree struct */ mxSetFieldByNumber(TreeParStruct, 0, 0, mxDuplicateArray(TREE_TREELEVELPNTR(S))); mxSetFieldByNumber(TreeParStruct, 0, 1, mxDuplicateArray(TREE_ANCESTORDESCENDANTPNTR(S))); mxSetFieldByNumber(TreeParStruct, 0, 2, mxDuplicateArray(TREE_LOCALIZINGVECTORS(S))); mxSetFieldByNumber(TreeParStruct, 0, 3, mxDuplicateArray(TREE_LOCALCOVMATRIX(S))); mxSetFieldByNumber(TreeParStruct, 0, 4, mxDuplicateArray(TREE_LOCALPARVECTOR(S))); /* set fields of Paramater struct */ mxSetFieldByNumber(ParStruct, 0, 0, mxDuplicateArray(NUMUNITS(S))); mxSetFieldByNumber(ParStruct, 0, 1, mxDuplicateArray(OPT_THRESHOLD(S))); mxSetFieldByNumber(ParStruct, 0, 2, mxDuplicateArray(PAR_REGRESSORMEAN(S))); mxSetFieldByNumber(ParStruct, 0, 3, mxDuplicateArray(PAR_OUTPUTOFFSET(S))); mxSetFieldByNumber(ParStruct, 0, 4, mxDuplicateArray(PAR_LINEARCOEF(S))); mxSetFieldByNumber(ParStruct, 0, 5, mxDuplicateArray(PAR_SAMPLELENGTH(S))); mxSetFieldByNumber(ParStruct, 0, 6, mxDuplicateArray(PAR_NOISEVARIANCE(S))); mxSetFieldByNumber(ParStruct, 0, 7, TreeParStruct); prhs[0] = mxCreateDoubleMatrix(1,nr,mxREAL); temp = mxGetPr(prhs[0]); for (k=0; k<nr; k++){ temp[k] = Reg[k]; } /* mxSetPr(prhs[0],Reg); */ prhs[1] = ParStruct; prhs[2] = TypeStr; /* * Call utEvalStateJacobian to compute the regressors * M file: dydx = utEvalStateJacobian(x,par,type) */ mexCallMATLAB(1,&plhs,3,prhs,"utEvalStateJacobian"); out = mxGetPr(plhs); for(k=0; k<nr; k++){ Pr[k] = out[k]; } mxFree((void *)fnamesTree); mxFree((void *)fnamesPar); mxDestroyArray(plhs); mxDestroyArray(prhs[0]); mxDestroyArray(TypeStr); mxDestroyArray(ParStruct); #endif }
mxArray *sf_c2_MigrationOWBG_Proto4_1DLinear2DNonLinear_get_autoinheritance_info (void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("WX6I1bkALKqCGoJ8R10IgH"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,2,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
mxArray* exportMatlab(Hkms<T>& hkms, bool getids) { //size of array uint nnodes = hkms.hkms[0].size(); uint ntrees = hkms.opt.ntrees; //The output is a structure array: nodes, opt, class int nfields1 = 3; const char* fieldnames1[] = {"nodes", "opt", "class"}; mxArray* out = mxCreateStructMatrix(1, 1, nfields1, fieldnames1); //make the nodes matrix: ntables X nnodes int nfields2 = 5; const char* fieldnames2[] = {"means", "plist", "classids", "visited", "meanstd"}; mxArray* nodes = mxCreateStructMatrix(ntrees, nnodes, nfields2, fieldnames2); mxSetField(out, 0, "nodes", nodes); //add the options to the first one mxSetField(out, 0, "opt", exportHkmOptions(hkms.opt)); //add class T t; mxSetField(out, 0, "class", mxCreateDoubleScalar((double)getClassIDfromT(t))); // cout << "nnodes:" << nnodes << endl; mxArray* a; //now loop and build nodes for (uint t=0; t<ntrees; ++t) { //get that tree Hkm<T>& hkm = hkms.hkms[t]; for (uint i=0; i<nnodes; ++i) { // cout << "node:" << i+1 << endl; //rows for trees, columns for nodes within the tree //so index is i*ntrees (to get the right column) + t (row) mwSize nid = i*ntrees+t; //get the node HkmNode<T> &node = hkm.at(i+1); //get the data into an mxarray mxSetField(nodes, nid, "means", fillMxArray(node.means)); //visited a = mxCreateNumericMatrix(1, 1, mxUINT8_CLASS, mxREAL); *((uint8_t*)mxGetData(a)) = (uint8_t) node.visited; mxSetField(nodes, nid, "visited", a); //meanStds mxSetField(nodes, nid, "meanstd", exportMeanStds(node.meanStds)); //get the lists if (getids && node.size()>0) { //plist // cout << "plist" << endl; mxSetField(nodes, nid, "plist", exportHkmPointList(node.plist)); //classids // cout << "classids" << endl; mxSetField(nodes, nid, "classids", exportHkmClassIds(node.classIds)); } } } return out; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // mexPrintf("\nin sim_create\n"); // sizeof(long long) == sizeof(void *) = 64 !!! long long *ptr; int ii; /* RHS */ // model bool set_nu = false, set_nx = false, set_T = false, set_x = false, set_u = false; int nu, nx; double T; double *x, *u; if(mxGetField( prhs[0], 0, "dim_nx" )!=NULL) { set_nx = true; nx = mxGetScalar( mxGetField( prhs[0], 0, "dim_nx" ) ); } if(mxGetField( prhs[0], 0, "dim_nu" )!=NULL) { set_nu = true; nu = mxGetScalar( mxGetField( prhs[0], 0, "dim_nu" ) ); } if(mxGetField( prhs[0], 0, "T" )!=NULL) { set_T = true; T = mxGetScalar( mxGetField( prhs[0], 0, "T" ) ); } if(mxGetField( prhs[0], 0, "x" )!=NULL) { set_x = true; x = mxGetPr( mxGetField( prhs[0], 0, "x" ) ); } if(mxGetField( prhs[0], 0, "u" )!=NULL) { set_u = true; u = mxGetPr( mxGetField( prhs[0], 0, "u" ) ); } // opts_struct // int num_stages = mxGetScalar( mxGetField( prhs[1], 0, "num_stages" ) ); // int num_steps = mxGetScalar( mxGetField( prhs[1], 0, "num_steps" ) ); // bool sens_forw; char *c_ptr = mxArrayToString( mxGetField( prhs[1], 0, "sens_forw" ) ); if (!strcmp(c_ptr, "true")) sens_forw = true; else sens_forw = false; // mexPrintf("\n%d\n", sens_forw); // char *method = mxArrayToString( mxGetField( prhs[1], 0, "method" ) ); // mexPrintf("\n%s\n", method); /* LHS */ // field names of output struct char *fieldnames[6]; fieldnames[0] = (char*)mxMalloc(50); fieldnames[1] = (char*)mxMalloc(50); fieldnames[2] = (char*)mxMalloc(50); fieldnames[3] = (char*)mxMalloc(50); fieldnames[4] = (char*)mxMalloc(50); fieldnames[5] = (char*)mxMalloc(50); memcpy(fieldnames[0],"config",sizeof("config")); memcpy(fieldnames[1],"dims",sizeof("dims")); memcpy(fieldnames[2],"opts",sizeof("opts")); memcpy(fieldnames[3],"in",sizeof("in")); memcpy(fieldnames[4],"out",sizeof("out")); memcpy(fieldnames[5],"solver",sizeof("solver")); // create output struct plhs[0] = mxCreateStructMatrix(1, 1, 6, (const char **) fieldnames); mxFree( fieldnames[0] ); mxFree( fieldnames[1] ); mxFree( fieldnames[2] ); mxFree( fieldnames[3] ); mxFree( fieldnames[4] ); mxFree( fieldnames[5] ); /* plan & config */ sim_solver_plan plan; if(!strcmp(method, "erk")) { // mexPrintf("\n%s\n", method); plan.sim_solver = ERK; } else if(!strcmp(method, "irk")) { // mexPrintf("\n%s\n", method); plan.sim_solver = IRK; } else { mexPrintf("\nmethod not supported %s\n", method); return; } sim_config *config = sim_config_create(plan); /* dims */ void *dims = sim_dims_create(config); if(set_nx) sim_dims_set(config, dims, "nx", &nx); if(set_nu) sim_dims_set(config, dims, "nu", &nu); /* opts */ sim_opts *opts = sim_opts_create(config, dims); sim_opts_set(config, opts, "num_stages", &num_stages); sim_opts_set(config, opts, "num_steps", &num_steps); sim_opts_set(config, opts, "sens_forw", &sens_forw); /* in */ sim_in *in = sim_in_create(config, dims); if(sens_forw==true) { // mexPrintf("\nsens forw true!\n"); double *Sx = calloc(nx*nx, sizeof(double)); for(ii=0; ii<nx; ii++) Sx[ii*(nx+1)] = 1.0; double *Su = calloc(nx*nu, sizeof(double)); // d_print_mat(nx, nx, Sx, nx); // d_print_mat(nx, nu, Su, nx); sim_in_set(config, dims, in, "Sx", Sx); sim_in_set(config, dims, in, "Su", Su); free(Sx); free(Su); } if(set_T) { sim_in_set(config, dims, in, "T", &T); } if(set_x) { sim_in_set(config, dims, in, "x", x); } if(set_u) { sim_in_set(config, dims, in, "u", u); } /* out */ sim_out *out = sim_out_create(config, dims); /* solver */ sim_solver *solver = sim_solver_create(config, dims, opts); /* populate output struct */ // config mxArray *config_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL); ptr = mxGetData(config_mat); ptr[0] = (long long) config; mxSetField(plhs[0], 0, "config", config_mat); // dims mxArray *dims_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL); ptr = mxGetData(dims_mat); ptr[0] = (long long) dims; mxSetField(plhs[0], 0, "dims", dims_mat); // opts mxArray *opts_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL); ptr = mxGetData(opts_mat); ptr[0] = (long long) opts; mxSetField(plhs[0], 0, "opts", opts_mat); // in mxArray *in_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL); ptr = mxGetData(in_mat); ptr[0] = (long long) in; mxSetField(plhs[0], 0, "in", in_mat); // out mxArray *out_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL); ptr = mxGetData(out_mat); ptr[0] = (long long) out; mxSetField(plhs[0], 0, "out", out_mat); // solver mxArray *solver_mat = mxCreateNumericMatrix(1, 1, mxINT64_CLASS, mxREAL); ptr = mxGetData(solver_mat); ptr[0] = (long long) solver; mxSetField(plhs[0], 0, "solver", solver_mat); /* return */ return; }
//-------------------------------------------------------------- // function: mexFunction - Entry point from Matlab environment // INPUTS: // nlhs - number of left hand side arguments (outputs) // plhs[] - pointer to table where created matrix pointers are // to be placed // nrhs - number of right hand side arguments (inputs) // prhs[] - pointer to table of input matrices //-------------------------------------------------------------- void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { ELEMENT_ATTRIBUTES Attributes; int ByteCount; // Total number of bytes required for C structure int Alignment = 8; int SwapFlag; // Byte Swapping Flag int LittleEndian = 0; // 0/1=local machine is big/litle Endian int ii; // Determine local byte ordering { unsigned char pattern[2] = {0x12, 0x34}; unsigned short word1 = 0x1234; unsigned short word2 = *(unsigned short *)&pattern; LittleEndian = (word1 == word2) ? 0 : 1; } SwapFlag = LittleEndian; // Default = assume data is big endian if (nlhs == 0) MatlabCStruct_DebugFlag = 1; else MatlabCStruct_DebugFlag = 0; if (nrhs < 1) mexErrMsgTxt("Not enough input arguments."); if (nrhs >= 3) { for (ii=2; ii<nrhs; ii++) { // Double = alignment specifier if (mxIsDouble(prhs[ii])) { if (mxGetNumberOfElements(prhs[ii]) != 1) mexErrMsgTxt("Alignment specifier must be single element (1, 2, 4, or 8)"); Alignment = (int)*mxGetPr(prhs[ii]); if (Alignment != 1 && Alignment != 2 && Alignment != 4 && Alignment != 8) mexWarnMsgTxt("Alignment specifier normally has of value of 1, 2, 4, or 8"); } else if (mxIsChar(prhs[ii])) { char ch; if (mxGetNumberOfElements(prhs[ii]) != 1) mexErrMsgTxt("Byte-ordering specifier must be single element ('n','l','b' or 'r')"); ch = *(char *)mxGetData(prhs[ii]); switch(ch) { case 'n': SwapFlag = 0; break; // Native byte ordering requested case 'b': SwapFlag = LittleEndian; break; // Big Endian data case 'l': SwapFlag = !LittleEndian; break; // Big Endian data case 'r': SwapFlag = 1; break; // Reverse byte ordering default: mexErrMsgTxt("Byte-ordering specifier must be one if 'n','l','b' or 'r'"); } } else mexErrMsgTxt("Optional Arguments must be either Aligmnent Specifier (1,2,4,8), or Byte-orderin Specifier ('n','l','b','r')"); } } Attributes = MatlabCStruct(prhs[0], Alignment, 0, (unsigned char *)-1, NULL, SwapFlag); ByteCount = Attributes.ElementCount*Attributes.StorageSize; if (nrhs >= 2 && !mxIsEmpty(prhs[1])) { mxClassID ClassID; ClassID = mxGetClassID(prhs[1]); if (ClassID != mxUINT8_CLASS && ClassID != mxINT8_CLASS) mexErrMsgTxt("Byte data vector must be of type INT8 or UINT8"); if (ByteCount != mxGetNumberOfElements(prhs[1])) { char msg[100]; sprintf(msg, "Number of elements in Byte data vector (%d) does not match structure size (%d)", mxGetNumberOfElements(prhs[1]), ByteCount); mexErrMsgTxt(msg); } plhs[0] = mxDuplicateArray(prhs[0]); MatlabCStruct(plhs[0], Alignment, 0, NULL, mxGetData(prhs[1]), SwapFlag); } else // Create output structure for Attributes { char *FieldNames[] = {"size","align"}; plhs[0] = mxCreateStructMatrix(1, 1, 2, FieldNames); mxSetField(plhs[0], 0, "size", mxCreateScalarDouble(ByteCount)); mxSetField(plhs[0], 0, "align", mxCreateScalarDouble(Attributes.Alignment)); if (nlhs >= 2) { // Extract C Data from array plhs[1] = mxCreateNumericMatrix(1, ByteCount, mxUINT8_CLASS, mxREAL); MatlabCStruct(prhs[0], Alignment, 0, mxGetData(plhs[1]), NULL, SwapFlag); } } } // end mexFunction()
mxArray *sf_c3_Puncture_Through_Wall_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = {"checksum","inputs","parameters","outputs"}; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,4,autoinheritanceFields); { mxArray *mxChecksum = mxCreateDoubleMatrix(4,1,mxREAL); double *pr = mxGetPr(mxChecksum); pr[0] = (double)(3712764182U); pr[1] = (double)(627272230U); pr[2] = (double)(224265117U); pr[3] = (double)(3379235871U); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = {"size","type","complexity"}; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0,mxREAL)); } { const char *dataFields[] = {"size","type","complexity"}; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = {"base","aliasId","fixpt"}; mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(0)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } return(mxAutoinheritanceInfo); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { FILE* fp = NULL; int fd; int i; int total_msg_cnt,cnt; int log_flag; u_int16_t buf_len; char buff[BUFSIZE]; char *outputFileName; log_flag = 1; csi_status = (csi_struct*)malloc(sizeof(csi_struct)); /* check usage */ if (0 == nrhs){ log_flag = 0; mexPrintf("/* log off */\n"); } if (1 == nrhs){ mexPrintf("/* log on */\n"); mxGetString(prhs[0], buff, BUFSIZE); sprintf(outputFileName, "%s", buff); fp = fopen(outputFileName,"a"); if (!fp){ mexPrintf("Fail to open <output_file>, are you root?\n"); fclose(fp); set_err_return_value(plhs, nlhs, 1); return; } } if (nrhs > 1){ mexPrintf(" Too many input arguments !\n"); set_err_return_value(plhs, nlhs, 1); return; } fd = open_csi_device(); if (fd < 0){ perror("Failed to open the device..."); set_err_return_value(plhs, nlhs, errno); return; } mexPrintf("#Receiving data! Press Ctrl+C to quit!\n"); quit = 0; total_msg_cnt = 0; while(1){ if (1 == quit) break; /* keep listening to the kernel and waiting for the csi report */ cnt = read_csi_buf(buf_addr,fd,BUFSIZE); if (cnt){ total_msg_cnt += 1; /* fill the status struct with information about the rx packet */ record_status(buf_addr, cnt, csi_status); /* * fill the payload buffer with the payload * fill the CSI matrix with the extracted CSI value */ record_csi_payload(buf_addr, csi_status, data_buf, csi_matrix); /* Till now, we store the packet status in the struct csi_status * store the packet payload in the data buffer * store the csi matrix in the csi buffer * with all those data, we can build our own processing function! */ /*porcess_csi(data_buf, csi_status, csi_matrix);*/ /*Return the csi_matrix combined with csi_status properly.*/ int k, nc_idx, nr_idx; int nr = csi_status->nr; int nc = csi_status->nc; int num_tones = csi_status->num_tones; mxArray *csi = csiMatrix2mxArray(csi_matrix, nr, nc, num_tones); const char *fieldNames[] = {"channel", "chanBW", "rate", "nr", "nc", "num_tones", "rssi", "rssi_0", "rssi_1", "rssi_2", "payload_len", "csi"}; #define NUMBER_OF_FIELDS (sizeof(fieldNames)/sizeof(*fieldNames)) plhs[0] = mxCreateStructMatrix(1, 1, NUMBER_OF_FIELDS, fieldNames); int fieldNumbers[NUMBER_OF_FIELDS]; for (k = 0; k < NUMBER_OF_FIELDS; k++) fieldNumbers[k] = mxGetFieldNumber(plhs[0], fieldNames[k]); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[0], mxCreateDoubleScalar((double)csi_status->channel)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[1], mxCreateDoubleScalar((double)csi_status->chanBW)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[2], mxCreateDoubleScalar((double)csi_status->rate)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[3], mxCreateDoubleScalar((double)csi_status->nr)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[4], mxCreateDoubleScalar((double)csi_status->nc)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[5], mxCreateDoubleScalar((double)csi_status->num_tones)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[6], mxCreateDoubleScalar((double)csi_status->rssi)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[7], mxCreateDoubleScalar((double)csi_status->rssi_0)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[8], mxCreateDoubleScalar((double)csi_status->rssi_1)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[9], mxCreateDoubleScalar((double)csi_status->rssi_2)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[10], mxCreateDoubleScalar((double)csi_status->payload_len)); mxSetFieldByNumber(plhs[0], 0, fieldNumbers[11], csi); mexPrintf("Recv %dth msg with rate: 0x%02x | payload len: %d\n",total_msg_cnt,csi_status->rate,csi_status->payload_len); /* log the received data for off-line processing */ if (log_flag){ buf_len = csi_status->buf_len; fwrite(&buf_len,1,2,fp); fwrite(buf_addr,1,buf_len,fp); } else break; } } if (fp) fclose(fp); close_csi_device(fd); free(csi_status); return; }
mxArray *sf_c1_Qmod_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("Rk3PHQL8hwPgv0HChPhxjG"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,5,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(4); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,2,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,2,"type",mxType); } mxSetField(mxData,2,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,3,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,3,"type",mxType); } mxSetField(mxData,3,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(3); mxSetField(mxData,4,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,4,"type",mxType); } mxSetField(mxData,4,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
/** The MEX interface function. */ void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { static unsigned initialized = 0; unsigned ctrl; int ctrlIndex, i, j; unsigned strategy; unsigned initType; real_t* xEnd = NULL; real_t* uEnd = NULL; const mxArray* src = prhs[ 0 ]; const char *infoNames[ 9 ] = {"status", "cpuTime", "simTime", "qpTime", "condenseTime", "regularizeTime", "kktValue", "objValue", "nIterations"}; mxArray* info; double status, cpuTime, kktValue, objValue; double tmp[ 1 ]; mxArray* shPtr; acado_timer tmr; double nIterations = 0; const char *outNames[ NOO_4 ]; outNames[ 0 ] = "info"; outNames[ 1 ] = "x"; outNames[ 2 ] = "u"; outNames[ 3 ] = "mu"; #if ACADO_NXA outNames[ NOO ] = "z"; #endif #if ACADO_USE_ARRIVAL_COST == 1 outNames[ NOO_2 ] = "xAC"; outNames[NOO_2 + 1] = "SAC"; #endif #if ACADO_COMPUTE_COVARIANCE_MATRIX == 1 outNames[ NOO_3 ] = "sigmaN"; #endif if (nrhs != 1) mexErrMsgTxt( "This function requires exactly one input: a structure with parameters."); if (nlhs != 1) mexErrMsgTxt( "This function returns one output."); if( !mxIsStruct( src ) ) mexErrMsgTxt("The function argument must be a structure."); /* Get the control flag. */ if (getArray(0, src, 0, "control", tmp, 1, 1) == 0) ctrl = (unsigned)tmp[ 0 ]; else ctrl = 0; /* Get the initialization flag. */ if (getArray(0, src, 0, "initialization", tmp, 1, 1) == 0) initType = (unsigned)tmp[ 0 ]; else initType = 0; /* Copy MATLAB arrays to C arrays. */ getArray(1, src, 0, "x", acadoVariables.x, ACADO_N + 1, ACADO_NX); getArray(1, src, 0, "u", acadoVariables.u, ACADO_N, ACADO_NU); getArray(1, src, 0, "mu", acadoVariables.mu, ACADO_N, ACADO_NX); #if ACADO_NXA getArray(1, src, 0, "z", acadoVariables.z, ACADO_N, ACADO_NXA); #endif #if ACADO_NOD getArray(1, src, 0, "od", acadoVariables.od, ACADO_N + 1, ACADO_NOD); #endif #if ACADO_INITIAL_STATE_FIXED getArray(1, src, 0, "x0", acadoVariables.x0, ACADO_NX, 1); #endif /* ACADO_INITIAL_STATE_FIXED */ #if (ACADO_HARDCODED_CONSTRAINT_VALUES == 0) && ( (ACADO_QP_SOLVER == ACADO_QPOASES) || (ACADO_QP_SOLVER == ACADO_QPOASES3) ) if (!initialized) { acado_initializeSolver(); } /* Bounds */ #if ACADO_INITIAL_STATE_FIXED == 1 getArray(1, src, 0, "lbValues", acadoVariables.lbValues, ACADO_N * ACADO_NU, 1); getArray(1, src, 0, "ubValues", acadoVariables.ubValues, ACADO_N * ACADO_NU, 1); #else getArray(1, src, 0, "lbValues", acadoVariables.lbValues, ACADO_NX + ACADO_N * ACADO_NU, 1); getArray(1, src, 0, "ubValues", acadoVariables.ubValues, ACADO_NX + ACADO_N * ACADO_NU, 1); #endif /* ACADO_INITIAL_STATE_FIXED == 0 */ #if QPOASES_NCMAX > 0 /* Affine constraints */ getArray(1, src, 0, "lbAValues", acadoVariables.lbAValues, QPOASES_NCMAX, 1); getArray(1, src, 0, "ubAValues", acadoVariables.ubAValues, QPOASES_NCMAX, 1); #endif /* QPOASES_NCMAX > 0 */ #endif /* (ACADO_HARDCODED_CONSTRAINT_VALUES == 0) && ( (ACADO_QP_SOLVER == ACADO_QPOASES) || (ACADO_QP_SOLVER == ACADO_QPOASES3) ) */ #if (ACADO_QP_SOLVER == ACADO_QPDUNES) if (!initialized) { acado_initializeSolver(); } #endif #if ACADO_USE_ARRIVAL_COST == 1 getArray(1, src, 0, "xAC", acadoVariables.xAC, ACADO_NX, 1); getArray(1, src, 0, "SAC", acadoVariables.SAC, ACADO_NX, ACADO_NX); getArray(1, src, 0, "WL", acadoVariables.WL, ACADO_NX, ACADO_NX); #endif /* Shifting strategy */ shPtr = mxGetField(src, 0, "shifting"); if (shPtr != NULL) { if( !mxIsStruct( shPtr ) ) mexErrMsgTxt("Field \"shifting\" must be defined with a structure."); /* Get the shifting strategy flag */ getArray(1, shPtr, 0, "strategy", tmp, 1, 1); strategy = (unsigned)tmp[ 0 ]; if (strategy > 2) mexErrMsgTxt("Valid options for the shifting strategy are 1 or 2."); getArray(0, shPtr, 0, "xEnd", xEnd, ACADO_NX, 1); getArray(0, shPtr, 0, "uEnd", uEnd, ACADO_NU, 1); } else strategy = 0; acado_tic( &tmr ); /* Call solver */ switch ( ctrl ) { case 0: /* Simple operational mode. Run one RTI with optional shifting. */ if ( !initialized ) { memset(&acadoWorkspace, 0, sizeof( acadoWorkspace )); #if ACADO_HARDCODED_CONSTRAINT_VALUES == 1 acado_initializeSolver(); #endif /* ACADO_HARDCODED_CONSTRAINT_VALUES == 1 */ /*for( i = 0; i < ACADO_N*ACADO_RK_NIS; i++ ) { for( j = 0; j < ACADO_RK_NSTAGES*(ACADO_NX+ACADO_NXA); j++ ) { acadoWorkspace.rk_A_traj[i*ACADO_RK_NSTAGES*(ACADO_NX+ACADO_NXA)*ACADO_RK_NSTAGES*(ACADO_NX+ACADO_NXA)+j*ACADO_RK_NSTAGES*(ACADO_NX+ACADO_NXA)+j] = 1.0; } }*/ if (initType == 1) { acado_initializeNodesByForwardSimulation(); } #if ACADO_USE_ARRIVAL_COST == 1 acado_updateArrivalCost( 1 ); #endif /* ACADO_USE_ARRIVAL_COST == 1 */ initialized = 1; } else if (strategy == 1 || strategy == 2) { #if ACADO_USE_ARRIVAL_COST == 1 acado_updateArrivalCost( 0 ); #endif /* ACADO_USE_ARRIVAL_COST == 1 */ acado_shiftStates(strategy, xEnd, uEnd); acado_shiftControls(uEnd); } rien_preparationStep(); status = (double)rien_feedbackStep(); kktValue = acado_getKKT(); objValue = acado_getObjective(); #if ( (ACADO_QP_SOLVER == ACADO_QPOASES) || (ACADO_QP_SOLVER == ACADO_QPOASES3) ) nIterations = (double)acado_getNWSR(); #endif /* ( (ACADO_QP_SOLVER == ACADO_QPOASES) || (ACADO_QP_SOLVER == ACADO_QPOASES3) ) */ break; case 1: /* Initialize */ memset(&acadoWorkspace, 0, sizeof( acadoWorkspace )); acado_initializeSolver(); if (initType == 1) { acado_initializeNodesByForwardSimulation(); } #if ACADO_USE_ARRIVAL_COST == 1 acado_updateArrivalCost( 1 ); #endif /* ACADO_USE_ARRIVAL_COST == 1 */ break; case 2: /* Preparation step */ rien_preparationStep(); break; case 3: /* Feedback step */ status = (double)rien_feedbackStep(); kktValue = acado_getKKT(); objValue = acado_getObjective(); #if ( (ACADO_QP_SOLVER == ACADO_QPOASES) || (ACADO_QP_SOLVER == ACADO_QPOASES3) ) nIterations = (double)acado_getNWSR(); #endif /* ( (ACADO_QP_SOLVER == ACADO_QPOASES) || (ACADO_QP_SOLVER == ACADO_QPOASES3) ) */ break; case 4: /* Shifting */ #if ACADO_USE_ARRIVAL_COST == 1 acado_updateArrivalCost( 0 ); #endif /* ACADO_USE_ARRIVAL_COST == 1 */ acado_shiftStates(strategy, xEnd, uEnd); acado_shiftControls( uEnd ); break; default: /* Return an error */ mexErrMsgTxt("Unknown control code."); } cpuTime = acado_toc( &tmr ); /* Prepare return argument */ plhs[ 0 ] = mxCreateStructMatrix(1, 1, NOO_4, outNames); setArray(plhs[ 0 ], 0, "x", acadoVariables.x, ACADO_N + 1, ACADO_NX); setArray(plhs[ 0 ], 0, "u", acadoVariables.u, ACADO_N, ACADO_NU); setArray(plhs[ 0 ], 0, "mu", acadoVariables.mu, ACADO_N, ACADO_NX); #if ACADO_NXA > 0 setArray(plhs[ 0 ], 0, "z", acadoVariables.z, ACADO_N, ACADO_NXA); #endif #if ACADO_USE_ARRIVAL_COST == 1 setArray(plhs[ 0 ], 0, "xAC", acadoVariables.xAC, ACADO_NX, 1); setArray(plhs[ 0 ], 0, "SAC", acadoVariables.SAC, ACADO_NX, ACADO_NX); #endif /* ACADO_USE_ARRIVAL_COST */ #if ACADO_COMPUTE_COVARIANCE_MATRIX == 1 setArray(plhs[ 0 ], 0, "sigmaN", acadoVariables.sigmaN, ACADO_NX, ACADO_NX); #endif /* ACADO_COMPUTE_COVARIANCE_MATRIX */ /* Create the info structure. */ info = mxCreateStructMatrix(1, 1, 9, infoNames); setArray(info, 0, "status", &status, 1, 1); setArray(info, 0, "cpuTime", &cpuTime, 1, 1); setArray(info, 0, "simTime", &simTime, 1, 1); setArray(info, 0, "qpTime", &qpTime, 1, 1); setArray(info, 0, "condenseTime", &condenseTime, 1, 1); setArray(info, 0, "regularizeTime", ®ularizeTime, 1, 1); setArray(info, 0, "kktValue", &kktValue, 1, 1); setArray(info, 0, "objValue", &objValue, 1, 1); #if ( (ACADO_QP_SOLVER == ACADO_QPOASES) || (ACADO_QP_SOLVER == ACADO_QPOASES3) ) setArray(info, 0, "nIterations", &nIterations, 1, 1); #endif /* ( (ACADO_QP_SOLVER == ACADO_QPOASES) || (ACADO_QP_SOLVER == ACADO_QPOASES3) ) */ mxSetField(plhs[ 0 ], 0, "info", info); /* Cleanup of the allocated memory */ FREE( xEnd ); FREE( uEnd ); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { if (nrhs < 1) mexErrMsgTxt("One input required."); else if (nrhs > 2) mexErrMsgTxt("Too many input arguments."); if (nlhs > 1) mexErrMsgTxt("Too many output arguments."); if (nrhs == 2) if ((mxGetClassID(prhs[1]) != mxDOUBLE_CLASS) || (mxGetNumberOfElements(prhs[1]) != 1)) mexErrMsgTxt("Second input argument must be a real (double) value."); // Redirection of the btk::Logger::Warning stream. btk::MEXWarnLogToWarnMsgTxt warnRedir = btk::MEXWarnLogToWarnMsgTxt("btk:GetGroundReactionWrenches"); // First output btk::Acquisition::Pointer acq = btk_MOH_get_object<btk::Acquisition>(prhs[0]); btk::ForcePlatformsExtractor::Pointer fpExtractor = btk::ForcePlatformsExtractor::New(); fpExtractor->SetInput(acq); btk::GroundReactionWrenchFilter::Pointer grwFilter = btk::GroundReactionWrenchFilter::New(); if (nrhs == 2) { grwFilter->SetThresholdState(true); grwFilter->SetThresholdValue(mxGetScalar(prhs[1])); } grwFilter->SetInput(fpExtractor->GetOutput()); btk::WrenchCollection::Pointer grws = grwFilter->GetOutput(); grws->Update(); const char* fieldnames[] = {"P", "F", "M"}; int numberOfFields = sizeof(fieldnames) / sizeof(char*); int numberOfForcePlates = grws->GetItemNumber(); plhs[0] = mxCreateStructMatrix(numberOfForcePlates, 1, numberOfFields, fieldnames); btk::WrenchCollection::ConstIterator itWrench = grws->Begin(); for (int i = 0 ; i < numberOfForcePlates ; ++i) { if (itWrench->get() != 0) { int numberOfFrames = (*itWrench)->GetPosition()->GetFrameNumber(); // Position mxArray* position = mxCreateDoubleMatrix(numberOfFrames, 3, mxREAL); memcpy(mxGetPr(position), (*itWrench)->GetPosition()->GetValues().data(), mxGetNumberOfElements(position) * sizeof(double)); mxSetFieldByNumber(plhs[0], i, 0, position); // Force mxArray* force = mxCreateDoubleMatrix(numberOfFrames, 3, mxREAL); memcpy(mxGetPr(force), (*itWrench)->GetForce()->GetValues().data(), mxGetNumberOfElements(force) * sizeof(double)); mxSetFieldByNumber(plhs[0], i, 1, force); // Moment mxArray* moment = mxCreateDoubleMatrix(numberOfFrames, 3, mxREAL); memcpy(mxGetPr(moment), (*itWrench)->GetMoment()->GetValues().data(), mxGetNumberOfElements(moment) * sizeof(double)); mxSetFieldByNumber(plhs[0], i, 2, moment); } else { std::string warnText = "Ground reaction wrench #" + btk::ToString(i) + " is empty. Send an email to BTK developers to inform them."; mexWarnMsgIdAndTxt("btk:GetGroundReactionWrenches", warnText.c_str()); } ++itWrench; } };
mxArray *sf_c8_WorkstationModel_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("oo47cGgFPDtsRTvscifTEE"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,2,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
mxArray *sf_c2_Demo_Kinect_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("ytkMaZ3LJMwsAy7iUSYW1D"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,7,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,2,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,2,"type",mxType); } mxSetField(mxData,2,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,3,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,3,"type",mxType); } mxSetField(mxData,3,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,4,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,4,"type",mxType); } mxSetField(mxData,4,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,5,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,5,"type",mxType); } mxSetField(mxData,5,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,6,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,6,"type",mxType); } mxSetField(mxData,6,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { mxSetField(mxAutoinheritanceInfo,0,"outputs",mxCreateDoubleMatrix(0,0,mxREAL)); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { if(strcmp(glp_version(),"4.18")<0){ mexErrMsgTxt("This MEX interface is compatible only with GLPK version 4.18 or higher."); } if (nrhs != 9){ mexPrintf("MEX interface to GLPK Version %s\n",glp_version()); mexPrintf("Internal interface for the GNU GLPK library.\n"); mexPrintf("You should use the 'glpk' function instead.\n\n"); mexPrintf("SYNTAX: [xopt, fmin, status, extra] = glpkcc(c, a, b, lb, ub, ctype, vartype, sense, param)\n"); return; } //-- 1nd Input. A column array containing the objective function //-- coefficients. int mrowsc = mxGetM(C_IN); double *c=mxGetPr(C_IN); if (c == NULL) mexErrMsgTxt("glpkcc: invalid value of C"); //-- 2nd Input. A matrix containing the constraints coefficients. // If matrix A is NOT a sparse matrix double *A = mxGetPr(A_IN); // get the matrix if(A==NULL) mexErrMsgTxt("glpkcc: invalid value of A"); int mrowsA = mxGetM(A_IN); int *rn; int *cn; double *a; int nz = 0; if(!mxIsSparse(A_IN)){ rn=(int *)mxCalloc(mrowsA*mrowsc+1,sizeof(int)); cn=(int *)mxCalloc(mrowsA*mrowsc+1,sizeof(int)); a=(double *)mxCalloc(mrowsA*mrowsc+1,sizeof(double)); for (int i = 0; i < mrowsA; i++){ for (int j = 0; j < mrowsc; j++){ if (A[i+j*mrowsA] != 0){ nz++; rn[nz] = i + 1; cn[nz] = j + 1; a[nz] = A[i+j*mrowsA]; } } } }else{ /* NOTE: nnz is the actual number of nonzeros and is stored as the last element of the jc array where the size of the jc array is the number of columns + 1 */ nz = *(mxGetJc(A_IN) + mrowsc); int *jc = mxGetJc(A_IN); int *ir = mxGetIr(A_IN); double *pr = mxGetPr(A_IN); rn=(int *)mxCalloc(nz+1,sizeof(int)); cn=(int *)mxCalloc(nz+1,sizeof(int)); a=(double *)mxCalloc(nz+1,sizeof(double)); int nelc,count,row; count=0; row=0; for(int i=1;i<=mrowsc;i++){ nelc=jc[i]-jc[i-1]; for(int j=0;j<nelc;j++){ count++; rn[count]=ir[row]+1; cn[count]=i; a[count]=pr[row]; row++; } } } //-- 3rd Input. A column array containing the right-hand side value // for each constraint in the constraint matrix. double *b = mxGetPr(B_IN); if (b==NULL) mexErrMsgTxt("glpkcc: invalid value of b"); //-- 4th Input. An array of length mrowsc containing the lower //-- bound on each of the variables. double *lb = mxGetPr(LB_IN); if (lb==NULL) mexErrMsgTxt("glpkcc: invalid value of lb"); //-- LB argument, default: Free int *freeLB=(int *)mxCalloc(mrowsc,sizeof(int)); for (int i = 0; i < mrowsc; i++) { if (lb[i]==-mxGetInf()){ freeLB[i] = 1; }else freeLB[i] = 0; } //-- 5th Input. An array of at least length numcols containing the upper //-- bound on each of the variables. double *ub = mxGetPr(UB_IN); if (ub==NULL) mexErrMsgTxt("glpkcc: invalid value of ub"); int *freeUB=(int *)mxCalloc(mrowsc,sizeof(int)); for (int i = 0; i < mrowsc; i++) { if (ub[i]==mxGetInf()) { freeUB[i] = 1; }else freeUB[i] = 0; } //-- 6th Input. A column array containing the sense of each constraint //-- in the constraint matrix. int size = mxGetNumberOfElements(CTYPE_IN) + 1; if (size==0) mexErrMsgTxt("glpkcc: invalid value of ctype"); /* Allocate enough memory to hold the converted string. */ char *ctype =(char *)mxCalloc(size, sizeof (char)); /* Copy the string data from string_array_ptr and place it into buf. */ if (mxGetString(CTYPE_IN, ctype, size) != 0) mexErrMsgTxt("Could not convert string data."); //-- 7th Input. A column array containing the types of the variables. size = mxGetNumberOfElements(VARTYPE_IN)+1; char *vtype = (char *)mxCalloc(size, sizeof (char)); int *vartype = (int *)mxCalloc(size, sizeof (int)); if (size==0) mexErrMsgTxt("glpkcc: invalid value of vartype"); // Copy the string data from string_array_ptr and place it into buf. if (mxGetString(VARTYPE_IN, vtype, size) != 0) mexErrMsgTxt("Could not convert string data."); int isMIP = 0; for (int i = 0; i < mrowsc ; i++) { switch (vtype[i]){ case 'I': vartype[i] = GLP_IV; isMIP = 1; break; case 'B': vartype[i] = GLP_BV; isMIP = 1; break; default: vartype[i] = GLP_CV; } } //-- 8th Input. Sense of optimization. int sense; double *tmp = mxGetPr(SENSE_IN); if (*tmp >= 0) sense = 1; else sense = -1; //-- 9th Input. A structure containing the control parameters. //-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //-- Integer parameters //-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //-- Level of messages output by the solver GLPK_GET_INT_PARAM (PARAM, "msglev", glpIntParam[0]); if (glpIntParam[0] < 0 || glpIntParam[0] > 3) { mexErrMsgTxt("glpkcc: param.msglev must be 0 (no output [default]) or 1 (error messages only) or 2 (normal output) or 3 (full output)"); } //-- scaling option GLPK_GET_INT_PARAM (PARAM, "scale", glpIntParam[1]); if (glpIntParam[1] < 0 || glpIntParam[1] > 2) { mexErrMsgTxt("glpkcc: param.scale must be 0 (no scaling) or 1 (equilibration scaling [default]) or 2 (geometric mean scaling)"); } //-- Dual dimplex option GLPK_GET_INT_PARAM (PARAM, "dual", glpIntParam[2]); if (glpIntParam[2] < 0 || glpIntParam[2] > 1) { mexErrMsgTxt("glpkcc: param.dual must be 0 (do NOT use dual simplex [default]) or 1 (use dual simplex)"); } //-- Pricing option GLPK_GET_INT_PARAM (PARAM, "price", glpIntParam[3]); if (glpIntParam[3] < 0 || glpIntParam[3] > 1) { mexErrMsgTxt("glpkcc: param.price must be 0 (textbook pricing) or 1 (steepest edge pricing [default])"); } //-- Solution rounding option GLPK_GET_INT_PARAM (PARAM, "round", glpIntParam[4]); if (glpIntParam[4] < 0 || glpIntParam[4] > 1) { mexErrMsgTxt("glpkcc: param.round must be 0 (report all primal and dual values [default]) or 1 (replace tiny primal and dual values by exact zero)"); } //-- Simplex iterations limit GLPK_GET_INT_PARAM (PARAM, "itlim", glpIntParam[5]); //-- Simplex iterations count GLPK_GET_INT_PARAM (PARAM, "itcnt", glpIntParam[6]); //-- Output frequency, in iterations GLPK_GET_INT_PARAM (PARAM, "outfrq", glpIntParam[7]); //-- Branching heuristic option GLPK_GET_INT_PARAM (PARAM, "branch", glpIntParam[14]); if (glpIntParam[14] < 0 || glpIntParam[14] > 2) { mexErrMsgTxt("glpkcc: param.branch must be (MIP only) 0 (branch on first variable) or 1 (branch on last variable) or 2 (branch using a heuristic by Driebeck and Tomlin [default]"); } //-- Backtracking heuristic option GLPK_GET_INT_PARAM (PARAM, "btrack", glpIntParam[15]); if (glpIntParam[15] < 0 || glpIntParam[15] > 2) { mexErrMsgTxt("glpkcc: param.btrack must be (MIP only) 0 (depth first search) or 1 (breadth first search) or 2 (backtrack using the best projection heuristic [default]"); } //-- Presolver option GLPK_GET_INT_PARAM (PARAM, "presol", glpIntParam[16]); if (glpIntParam[16] < 0 || glpIntParam[16] > 1) { mexErrMsgTxt("glpkcc: param.presol must be 0 (do NOT use LP presolver) or 1 (use LP presolver [default])"); } //-- Generating cuts GLPK_GET_INT_PARAM (PARAM, "usecuts", glpIntParam[17]); if (glpIntParam[17] < 0 || glpIntParam[17] > 1) { mexErrMsgTxt("glpkcc: param.usecuts must be 0 (do NOT generate cuts) or 1 (generate Gomory's cuts [default])"); } //-- LPsolver option int lpsolver = 1; GLPK_GET_INT_PARAM (PARAM, "lpsolver", lpsolver); if (lpsolver < 1 || lpsolver > 2) { mexErrMsgTxt("glpkcc: param.lpsolver must be 1 (simplex method) or 2 (interior point method)"); } //-- Save option int save_pb = 0; char *save_filename = NULL; char *filetype = NULL; GLPK_GET_INT_PARAM (PARAM, "save", save_pb); save_pb = (save_pb != 0); if (save_pb){ // -- Look for the name -- mxArray *mxtmp=mxGetField(PARAM,0,"savefilename"); if ( mxtmp != NULL ){ int nl=mxGetNumberOfElements(mxtmp)+1; nl=nl+4; // increase size to consider then extension .xxx save_filename=(char *)mxCalloc(nl,sizeof(char)); if (mxGetString(mxtmp, save_filename, nl) != 0) mexErrMsgTxt("glpkcc: Could not load file name to save."); }else{ // Default file name save_filename= (char *)mxCalloc(9, sizeof(char)); strcpy(save_filename,"outpb"); } // -- Look for the type -- char save_filetype[4]; mxArray *txtmp=mxGetField(PARAM,0,"savefiletype"); if ( txtmp != NULL ){ int nl=mxGetNumberOfElements(txtmp)+1; filetype=(char *)mxCalloc(nl,sizeof(char)); if (mxGetString(txtmp, filetype, nl) != 0) mexErrMsgTxt("glpkcc: Could not load file type."); if (!strcmp(filetype,"fixedmps") || !strcmp(filetype,"freemps")){ strcpy(save_filetype,".mps"); } else { if (!strcmp(filetype,"cplex")) strcpy(save_filetype,".lp"); else { if (!strcmp(filetype,"plain")) strcpy(save_filetype,".txt"); } } }else{ filetype= (char *)mxCalloc(5, sizeof(char)); strcpy(filetype,"cplex"); strcpy(save_filetype,".lp"); // Default file type } strcat(save_filename,save_filetype); // name.extension } // MPS parameters //-- mpsinfo GLPK_GET_INT_PARAM (PARAM, "mpsinfo", glpIntParam[8]); //-- mpsobj GLPK_GET_INT_PARAM (PARAM, "mpsobj", glpIntParam[9]); if (glpIntParam[9] < 0 || glpIntParam[9] > 2) { mexErrMsgTxt("glpkcc: param.mpsobj must be 0 (never output objective function row) or 1 (always output objective function row ) or 2 [default](output objective function row if the problem has no free rows)"); } //-- mpsorig GLPK_GET_INT_PARAM (PARAM, "mpsorig", glpIntParam[10]); //-- mpswide GLPK_GET_INT_PARAM (PARAM, "mpswide", glpIntParam[11]); //-- mpsfree GLPK_GET_INT_PARAM (PARAM, "mpsfree", glpIntParam[12]); //-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //-- Real parameters //-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //-- Ratio test option GLPK_GET_REAL_PARAM (PARAM, "relax", 0); //-- Relative tolerance used to check if the current basic solution //-- is primal feasible GLPK_GET_REAL_PARAM (PARAM, "tolbnd", 1); //-- Absolute tolerance used to check if the current basic solution //-- is dual feasible GLPK_GET_REAL_PARAM (PARAM, "toldj", 2); //-- Relative tolerance used to choose eligible pivotal elements of //-- the simplex table in the ratio test GLPK_GET_REAL_PARAM (PARAM, "tolpiv", 3); GLPK_GET_REAL_PARAM (PARAM, "objll", 4); GLPK_GET_REAL_PARAM (PARAM, "objul", 5); GLPK_GET_REAL_PARAM (PARAM, "tmlim", 6); GLPK_GET_REAL_PARAM (PARAM, "outdly", 7); GLPK_GET_REAL_PARAM (PARAM, "tolint", 8); GLPK_GET_REAL_PARAM (PARAM, "tolobj", 9); //-- Assign pointers to the output parameters const char **extranames=(const char **)mxCalloc(4,sizeof(*extranames)); extranames[0]="lambda"; extranames[1]="redcosts"; extranames[2]="time"; extranames[3]="memory"; XMIN_OUT = mxCreateDoubleMatrix(mrowsc, 1, mxREAL); FMIN_OUT = mxCreateDoubleMatrix(1, 1, mxREAL); STATUS_OUT = mxCreateDoubleMatrix(1, 1, mxREAL); double *xmin = mxGetPr(XMIN_OUT); double *fmin = mxGetPr(FMIN_OUT); double *status = mxGetPr(STATUS_OUT); EXTRA_OUT = mxCreateStructMatrix(1, 1, 4, extranames); mxArray *mxlambda = mxCreateDoubleMatrix(mrowsA, 1, mxREAL); mxArray *mxredcosts = mxCreateDoubleMatrix(mrowsc, 1, mxREAL); mxArray *mxtime = mxCreateDoubleMatrix(1, 1, mxREAL); mxArray *mxmem = mxCreateDoubleMatrix(1, 1, mxREAL); double *lambda = mxGetPr(mxlambda); double *redcosts= mxGetPr(mxredcosts); double *time = mxGetPr(mxtime); double *mem = mxGetPr(mxmem); int jmpret = setjmp (mark); if (jmpret == 0) glpk (sense, mrowsc, mrowsA, c, nz, rn, cn, a, b, ctype, freeLB, lb, freeUB, ub, vartype, isMIP, lpsolver, save_pb, save_filename, filetype, xmin, fmin, status, lambda, redcosts, time, mem); if (! isMIP) { mxSetField(EXTRA_OUT,0,extranames[0],mxlambda); mxSetField(EXTRA_OUT,0,extranames[1],mxredcosts); } mxSetField(EXTRA_OUT,0,extranames[2],mxtime); mxSetField(EXTRA_OUT,0,extranames[3],mxmem); mxFree(rn); mxFree(cn); mxFree(a); mxFree(freeLB); mxFree(freeUB); mxFree(ctype); mxFree(vartype); mxFree(vtype); mxFree(extranames); mxFree(save_filename); mxFree(filetype); return; }
/* * a l l o c a t e O u t p u t s */ returnValue allocateOutputs( int nlhs, mxArray* plhs[], int nV, int nC, int nP, int handle ) { /* Create output vectors and assign pointers to them. */ int curIdx = 0; /* handle */ if ( handle >= 0 ) plhs[curIdx++] = mxCreateDoubleMatrix( 1, 1, mxREAL ); /* x */ plhs[curIdx++] = mxCreateDoubleMatrix( nV, nP, mxREAL ); if ( nlhs > curIdx ) { /* fval */ plhs[curIdx++] = mxCreateDoubleMatrix( 1, nP, mxREAL ); if ( nlhs > curIdx ) { /* exitflag */ plhs[curIdx++] = mxCreateDoubleMatrix( 1, nP, mxREAL ); if ( nlhs > curIdx ) { /* iter */ plhs[curIdx++] = mxCreateDoubleMatrix( 1, nP, mxREAL ); if ( nlhs > curIdx ) { /* lambda */ plhs[curIdx++] = mxCreateDoubleMatrix( nV+nC, nP, mxREAL ); if ( nlhs > curIdx ) { /* setup auxiliary output struct */ mxArray* auxOutput = mxCreateStructMatrix( 1,1,0,0 ); int curFieldNum; /* working set */ curFieldNum = mxAddField( auxOutput,"workingSetB" ); if ( curFieldNum >= 0 ) mxSetFieldByNumber( auxOutput,0,curFieldNum,mxCreateDoubleMatrix( nV, nP, mxREAL ) ); curFieldNum = mxAddField( auxOutput,"workingSetC" ); if ( curFieldNum >= 0 ) mxSetFieldByNumber( auxOutput,0,curFieldNum,mxCreateDoubleMatrix( nC, nP, mxREAL ) ); curFieldNum = mxAddField( auxOutput,"cpuTime" ); if ( curFieldNum >= 0 ) mxSetFieldByNumber( auxOutput,0,curFieldNum,mxCreateDoubleMatrix( 1, nP, mxREAL ) ); plhs[curIdx] = auxOutput; } } } } } return SUCCESSFUL_RETURN; }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { params p; pwork *mywork; mxArray *xm; int i = 0; int j = 0; double *ptr; int numerr = 0; mxArray *outvar; mxArray *tinfos; /* change number of infofields according to profiling setting */ #if PROFILING > 0 #define NINFOFIELDS 15 #else #define NINFOFIELDS 14 #endif const char *infofields[NINFOFIELDS] = { "pcost", "dcost", "pres", "dres", "pinf", "dinf", "pinfres", "dinfres", "gap", "relgap", "r0", "numerr", "iter", "infostring" #if PROFILING > 0 ,"timing" #endif }; #if PROFILING == 1 #define NTFIELDS 3 const char *tinfo[NTFIELDS] = {"runtime", "tsolve", "tsetup"}; #endif #if PROFILING == 2 #define NTFIELDS 8 const char *tinfo[NTFIELDS] = {"runtime", "tsolve", "tsetup", "tkktcreate", "tkktfactor", "tkktsolve", "torder", "ttranspose"}; #endif #ifdef MEXARGMUENTCHECKS if( !(nrhs == 1) ) { mexErrMsgTxt("scooper only takes 1 argument: scooper(params)"); } if( nlhs > 2 ) mexErrMsgTxt("scooper has up to 2 output arguments only"); #endif xm = mxGetField(prhs[0], 0, "A"); if (xm == NULL) { mexErrMsgTxt("could not find params.A"); } else { if (!( (mxGetM(xm) == 1) && (mxGetN(xm) == 2) )) mexErrMsgTxt("A must be size (1, 2)\n"); if (mxIsComplex(xm)) mxErrMsgTxt("parameter A must be real\n"); if (!mxIsClass(xm, "double")) mxErrMsgTxt("parameter A must be full matrix of doubles"); if (mxIsSparse(xm)) mxErrMsgTxt("parameter A must be full matrix"); ptr = mxGetPr(xm); for(j = 0; j < 2; ++j) { for(i = 0; i < 1; ++i) { p.A[i][j] = *ptr++; } } } xm = mxGetField(prhs[0], 0, "b"); if (xm == NULL) { mexErrMsgTxt("could not find params.b"); } else { if (!( (mxGetM(xm) == 1) && (mxGetN(xm) == 1) )) mexErrMsgTxt("b must be size (1, 1)\n"); if (mxIsComplex(xm)) mxErrMsgTxt("parameter b must be real\n"); if (!mxIsClass(xm, "double")) mxErrMsgTxt("parameter b must be full vector of doubles"); if (mxIsSparse(xm)) mxErrMsgTxt("parameter b must be full vector"); p.b = *mxGetPr(xm); } xm = mxGetField(prhs[0], 0, "ct"); if (xm == NULL) { mexErrMsgTxt("could not find params.ct"); } else { if (!( (mxGetM(xm) == 1) && (mxGetN(xm) == 2) )) mexErrMsgTxt("ct must be size (1, 2)\n"); if (mxIsComplex(xm)) mxErrMsgTxt("parameter ct must be real\n"); if (!mxIsClass(xm, "double")) mxErrMsgTxt("parameter ct must be full matrix of doubles"); if (mxIsSparse(xm)) mxErrMsgTxt("parameter ct must be full matrix"); ptr = mxGetPr(xm); for(j = 0; j < 2; ++j) { for(i = 0; i < 1; ++i) { p.ct[i][j] = *ptr++; } } } mywork = setup(&p); if(mywork == NULL) { mexErrMsgTxt("Internal problem occurred in ECOS while setting up the problem.\nPlease send a bug report with data to Alexander Domahidi.\nEmail: [email protected]"); } int flag = 0; flag = solve(mywork, &v); const int num_var_names = 1; const char *var_names[] = {"x"}; plhs[0] = mxCreateStructMatrix(1, 1, num_var_names, var_names); xm = mxCreateDoubleMatrix(2, 1,mxREAL); mxSetField(plhs[0], 0, "x", xm); memcpy(mxGetPr(xm), v.x, sizeof(double)*2); if( nlhs == 2 ){ plhs[1] = mxCreateStructMatrix(1, 1, NINFOFIELDS, infofields); /* 1. primal objective */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = 1.0*((double)mywork->info->pcost); mxSetField(plhs[1], 0, "pcost", outvar); /* 2. dual objective */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->dcost; mxSetField(plhs[1], 0, "dcost", outvar); /* 3. primal residual */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->pres; mxSetField(plhs[1], 0, "pres", outvar); /* 4. dual residual */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->dres; mxSetField(plhs[1], 0, "dres", outvar); /* 5. primal infeasible? */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->pinf; mxSetField(plhs[1], 0, "pinf", outvar); /* 6. dual infeasible? */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->dinf; mxSetField(plhs[1], 0, "dinf", outvar); /* 7. primal infeasibility measure */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->pinfres; mxSetField(plhs[1], 0, "pinfres", outvar); /* 8. dual infeasibility measure */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->dinfres; mxSetField(plhs[1], 0, "dinfres", outvar); /* 9. duality gap */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->gap; mxSetField(plhs[1], 0, "gap", outvar); /* 10. relative duality gap */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->relgap; mxSetField(plhs[1], 0, "relgap", outvar); /* 11. feasibility tolerance??? */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->stgs->feastol; mxSetField(plhs[1], 0, "r0", outvar); /* 12. iterations */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->iter; mxSetField(plhs[1], 0, "iter", outvar); /* 13. infostring */ switch( flag ){ case ECOS_OPTIMAL: outvar = mxCreateString("Optimal solution found"); break; case ECOS_MAXIT: outvar = mxCreateString("Maximum number of iterations reached"); break; case ECOS_PINF: outvar = mxCreateString("Primal infeasible"); break; case ECOS_DINF: outvar = mxCreateString("Dual infeasible"); break; case ECOS_KKTZERO: outvar = mxCreateString("Element of D zero during KKT factorization"); break; case ECOS_OUTCONE: outvar = mxCreateString("PROBLEM: Mulitpliers leaving the cone"); break; default: outvar = mxCreateString("UNKNOWN PROBLEM IN SOLVER"); } mxSetField(plhs[1], 0, "infostring", outvar); #if PROFILING > 0 /* 14. timing information */ tinfos = mxCreateStructMatrix(1, 1, NTFIELDS, tinfo); /* 14.1 --> runtime */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->tsolve + (double)mywork->info->tsetup; mxSetField(tinfos, 0, "runtime", outvar); /* 14.2 --> setup time */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->tsetup; mxSetField(tinfos, 0, "tsetup", outvar); /* 14.3 --> solve time */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->tsolve; mxSetField(tinfos, 0, "tsolve", outvar); #if PROFILING > 1 /* 14.4 time to create KKT matrix */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->tkktcreate; mxSetField(tinfos, 0, "tkktcreate", outvar); /* 14.5 time for kkt solve */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->tkktsolve; mxSetField(tinfos, 0, "tkktsolve", outvar); /* 14.6 time for kkt factor */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->tfactor; mxSetField(tinfos, 0, "tkktfactor", outvar); /* 14.7 time for ordering */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->torder; mxSetField(tinfos, 0, "torder", outvar); /* 14.8 time for transposes */ outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)mywork->info->ttranspose; mxSetField(tinfos, 0, "ttranspose", outvar); #endif mxSetField(plhs[1], 0, "timing", tinfos); #endif /* 15. numerical error? */ if( (flag == ECOS_NUMERICS) || (flag == ECOS_OUTCONE) || (flag == ECOS_FATAL) ){ numerr = 1; } outvar = mxCreateDoubleMatrix(1, 1, mxREAL); *mxGetPr(outvar) = (double)numerr; mxSetField(plhs[1], 0, "numerr", outvar); } cleanup(mywork); }
mxArray *sf_c8_AllPurposeModel_TyreRelaxation_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals", "postCodegenInfo" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1, 1, sizeof (autoinheritanceFields)/sizeof(autoinheritanceFields[0]), autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("yymzPjWWJIO6bqgeXReD6"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,2,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(13)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(13)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } { mxArray* mxPostCodegenInfo = sf_c8_AllPurposeModel_TyreRelaxation_get_post_codegen_info(); mxSetField(mxAutoinheritanceInfo,0,"postCodegenInfo",mxPostCodegenInfo); } return(mxAutoinheritanceInfo); }
mxArray *sf_c2_car_model_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,4, autoinheritanceFields); { mxArray *mxChecksum = mxCreateDoubleMatrix(4,1,mxREAL); double *pr = mxGetPr(mxChecksum); pr[0] = (double)(2049816183U); pr[1] = (double)(1355668588U); pr[2] = (double)(1372235997U); pr[3] = (double)(1468908850U); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,4,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(4); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(2); pr[1] = (double)(1); mxSetField(mxData,2,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,2,"type",mxType); } mxSetField(mxData,2,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(2); pr[1] = (double)(1); mxSetField(mxData,3,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,3,"type",mxType); } mxSetField(mxData,3,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(4); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } return(mxAutoinheritanceInfo); }
const char *model_to_matlab_structure(mxArray *plhs[], int num_of_feature, struct model *model_) { int i; int nr_w; double *ptr; mxArray *return_model, **rhs; int out_id = 0; int n; rhs = (mxArray **)mxMalloc(sizeof(mxArray *)*NUM_OF_RETURN_FIELD); // Parameters // for now, only solver_type is needed rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model_->param.solver_type; out_id++; // nr_class rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model_->nr_class; out_id++; if(model_->nr_class==2 && model_->param.solver_type != MCSVM_CS) nr_w=1; else nr_w=model_->nr_class; // nr_feature rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model_->nr_feature; out_id++; // bias rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model_->bias; out_id++; if(model_->bias>=0) n=model_->nr_feature+1; else n=model_->nr_feature; // Label if(model_->label) { rhs[out_id] = mxCreateDoubleMatrix(model_->nr_class, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < model_->nr_class; i++) ptr[i] = model_->label[i]; } else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); out_id++; // w rhs[out_id] = mxCreateDoubleMatrix(nr_w, n, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < n*nr_w; i++) ptr[i]=model_->w[i]; out_id++; /* Create a struct matrix contains NUM_OF_RETURN_FIELD fields */ return_model = mxCreateStructMatrix(1, 1, NUM_OF_RETURN_FIELD, field_names); /* Fill struct matrix with input arguments */ for(i = 0; i < NUM_OF_RETURN_FIELD; i++) mxSetField(return_model,0,field_names[i],mxDuplicateArray(rhs[i])); /* return */ plhs[0] = return_model; mxFree(rhs); return NULL; }
/* Matlab Gateway routine */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { char *this, *fieldnames[6] = {"version", "full", "high", "intermediate", "low", "crude"}; char file[64]; char *GMTHOME = CNULL; char *GMT_HOMEDIR = CNULL; char *GMT_USERDIR = CNULL; char path[BUFSIZ]; mxArray *mxStr, *info_struct; if (nrhs == 1 && mxIsChar(prhs[0])) { char *envString; int status; envString = (char *)mxArrayToString(prhs[0]); if (status = putenv(envString)) mexPrintf("TEST_GMT: Failure to set the environmental variable\n %s\n", envString); if (nlhs == 0) return; } if (nlhs == 0 && nrhs == 0) { mexPrintf("Usage: info = test_gmt;\nReturns the info structure with information on GMT version and costlines\n"); mexPrintf("info = test_gmt('envstring');\nDo the same as above and set 'envstring' in the environment list\n"); mexPrintf(" test_gmt('envstring');\nJust set 'envstring' in the environment list and return.\n"); return; } /* Structure field names. If we have an official GMT installation, only full & high will be tested (4-6 will be empty). Otherwise, we'll check also for the lower costlines. */ info_struct = mxCreateStructMatrix (1, 1, 6, (const char **)fieldnames ); if ((this = getenv ("GMTHOME")) == CNULL) { /* No official GMT in sight */ mxStr = mxCreateString("0"); } else { GMTHOME = (char *) mxCalloc ((size_t)(strlen (this) + 1), (size_t)1); strcpy (GMTHOME, this); mxStr = mxCreateString("4"); } mxSetField(info_struct, 0, fieldnames[0], mxStr); if ((this = getenv ("HOME")) != CNULL) { /* HOME was set */ GMT_HOMEDIR = (char *) mxCalloc ((size_t)(strlen (this) + 1), (size_t)1); strcpy (GMT_HOMEDIR, this); } else { #ifdef WIN32 /* Set HOME to C:\ under Windows */ GMT_HOMEDIR = (char *) mxCalloc (4, (size_t)1); sprintf (GMT_HOMEDIR, "C:%c", DIR_DELIM); #else mexPrintf ("Warning: Could not determine home directory!\n"); #endif } if ((this = getenv ("GMT_USERDIR")) != CNULL) { /* GMT_USERDIR was set */ GMT_USERDIR = (char *) mxCalloc ((size_t)(strlen (this) + 1), (size_t)1); strcpy (GMT_USERDIR, this); } else if (GMT_HOMEDIR) { /* Use default pato for GMT_USERDIR (~/.gmt) */ GMT_USERDIR = (char *) mxCalloc ((size_t)(strlen (GMT_HOMEDIR) + 6), (size_t)1); sprintf (GMT_USERDIR, "%s%c%s", GMT_HOMEDIR, DIR_DELIM, ".gmt"); } if (access(GMT_USERDIR,R_OK)) GMT_USERDIR = CNULL; /* See if we have the Full definition files */ sprintf (file, "binned_GSHHS_%c.cdf", 'f'); if (getpathname (file, path, GMTHOME, GMT_HOMEDIR, GMT_USERDIR)) mxStr = mxCreateString("y"); else mxStr = mxCreateString("n"); mxSetField(info_struct, 0, fieldnames[1], mxStr); /* See if we have the High definition files */ sprintf (file, "binned_GSHHS_%c.cdf", 'h'); if (getpathname (file, path, GMTHOME, GMT_HOMEDIR, GMT_USERDIR)) mxStr = mxCreateString("y"); else mxStr = mxCreateString("n"); mxSetField(info_struct, 0, fieldnames[2], mxStr); if (!GMTHOME) { /* An official GMT installation does not exist. So check if we have the lower costlines */ sprintf (file, "binned_GSHHS_%c.cdf", 'i'); /* Intermediate */ if (getpathname (file, path, GMTHOME, GMT_HOMEDIR, GMT_USERDIR)) mxStr = mxCreateString("y"); else mxStr = mxCreateString("n"); mxSetField(info_struct, 0, fieldnames[3], mxStr); sprintf (file, "binned_GSHHS_%c.cdf", 'l'); /* Intermediate */ if (getpathname (file, path, GMTHOME, GMT_HOMEDIR, GMT_USERDIR)) mxStr = mxCreateString("y"); else mxStr = mxCreateString("n"); mxSetField(info_struct, 0, fieldnames[4], mxStr); sprintf (file, "binned_GSHHS_%c.cdf", 'c'); /* Intermediate */ if (getpathname (file, path, GMTHOME, GMT_HOMEDIR, GMT_USERDIR)) mxStr = mxCreateString("y"); else mxStr = mxCreateString("n"); mxSetField(info_struct, 0, fieldnames[5], mxStr); } plhs[0] = info_struct; }
const char *model_to_matlab_structure(mxArray *plhs[], int num_of_feature, struct svm_model *model) { int i, j, n; double *ptr; mxArray *return_model, **rhs; int out_id = 0; rhs = (mxArray **)mxMalloc(sizeof(mxArray *)*NUM_OF_RETURN_FIELD); // Parameters rhs[out_id] = mxCreateDoubleMatrix(5, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model->param.svm_type; ptr[1] = model->param.kernel_type; ptr[2] = model->param.degree; ptr[3] = model->param.gamma; ptr[4] = model->param.coef0; out_id++; // nr_class rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model->nr_class; out_id++; // total SV rhs[out_id] = mxCreateDoubleMatrix(1, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); ptr[0] = model->l; out_id++; // rho n = model->nr_class*(model->nr_class-1)/2; rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < n; i++) ptr[i] = model->rho[i]; out_id++; // Label if(model->label) { rhs[out_id] = mxCreateDoubleMatrix(model->nr_class, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < model->nr_class; i++) ptr[i] = model->label[i]; } else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); out_id++; // sv_indices if(model->sv_indices) { rhs[out_id] = mxCreateDoubleMatrix(model->l, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < model->l; i++) ptr[i] = model->sv_indices[i]; } else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); out_id++; // probA if(model->probA != NULL) { rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < n; i++) ptr[i] = model->probA[i]; } else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); out_id ++; // probB if(model->probB != NULL) { rhs[out_id] = mxCreateDoubleMatrix(n, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < n; i++) ptr[i] = model->probB[i]; } else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); out_id++; // nSV if(model->nSV) { rhs[out_id] = mxCreateDoubleMatrix(model->nr_class, 1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < model->nr_class; i++) ptr[i] = model->nSV[i]; } else rhs[out_id] = mxCreateDoubleMatrix(0, 0, mxREAL); out_id++; // sv_coef rhs[out_id] = mxCreateDoubleMatrix(model->l, model->nr_class-1, mxREAL); ptr = mxGetPr(rhs[out_id]); for(i = 0; i < model->nr_class-1; i++) for(j = 0; j < model->l; j++) ptr[(i*(model->l))+j] = model->sv_coef[i][j]; out_id++; // SVs { int ir_index, nonzero_element; mwIndex *ir, *jc; mxArray *pprhs[1], *pplhs[1]; if(model->param.kernel_type == PRECOMPUTED) { nonzero_element = model->l; num_of_feature = 1; } else { nonzero_element = 0; for(i = 0; i < model->l; i++) { j = 0; while(model->SV[i][j].index != -1) { nonzero_element++; j++; } } } // SV in column, easier accessing rhs[out_id] = mxCreateSparse(num_of_feature, model->l, nonzero_element, mxREAL); ir = mxGetIr(rhs[out_id]); jc = mxGetJc(rhs[out_id]); ptr = mxGetPr(rhs[out_id]); jc[0] = ir_index = 0; for(i = 0;i < model->l; i++) { if(model->param.kernel_type == PRECOMPUTED) { // make a (1 x model->l) matrix ir[ir_index] = 0; ptr[ir_index] = model->SV[i][0].value; ir_index++; jc[i+1] = jc[i] + 1; } else { int x_index = 0; while (model->SV[i][x_index].index != -1) { ir[ir_index] = model->SV[i][x_index].index - 1; ptr[ir_index] = model->SV[i][x_index].value; ir_index++, x_index++; } jc[i+1] = jc[i] + x_index; } } // transpose back to SV in row pprhs[0] = rhs[out_id]; if(mexCallMATLAB(1, pplhs, 1, pprhs, "transpose")) return "cannot transpose SV matrix"; rhs[out_id] = pplhs[0]; out_id++; } /* Create a struct matrix contains NUM_OF_RETURN_FIELD fields */ return_model = mxCreateStructMatrix(1, 1, NUM_OF_RETURN_FIELD, field_names); /* Fill struct matrix with input arguments */ for(i = 0; i < NUM_OF_RETURN_FIELD; i++) mxSetField(return_model,0,field_names[i],mxDuplicateArray(rhs[i])); /* return */ plhs[0] = return_model; plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL); double *tt = mxGetPr(plhs[1]); *tt = model->obj; plhs[2] = mxCreateDoubleMatrix(1,1,mxREAL); double *qq = mxGetPr(plhs[2]); *qq = model->initial_time; mxFree(rhs); return NULL; }
mxArray *sf_c24_DemoSmile_KS_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("897X58qC0FRf0Y4NliAPsB"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(1); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
mxArray *sf_c2_hapticsSimBlk_pd_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("Im5RbwVXS12JBrAPRIrR4E"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }
mxArray *sf_c26_HIL_model_experiments2_get_autoinheritance_info(void) { const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters", "outputs", "locals" }; mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5, autoinheritanceFields); { mxArray *mxChecksum = mxCreateString("kUQSkNUbM8KEn3yWViIVYE"); mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,2,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(1); mxSetField(mxData,1,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,1,"type",mxType); } mxSetField(mxData,1,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"inputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"parameters",mxCreateDoubleMatrix(0,0, mxREAL)); } { const char *dataFields[] = { "size", "type", "complexity" }; mxArray *mxData = mxCreateStructMatrix(1,1,3,dataFields); { mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL); double *pr = mxGetPr(mxSize); pr[0] = (double)(3); pr[1] = (double)(1); mxSetField(mxData,0,"size",mxSize); } { const char *typeFields[] = { "base", "fixpt" }; mxArray *mxType = mxCreateStructMatrix(1,1,2,typeFields); mxSetField(mxType,0,"base",mxCreateDoubleScalar(10)); mxSetField(mxType,0,"fixpt",mxCreateDoubleMatrix(0,0,mxREAL)); mxSetField(mxData,0,"type",mxType); } mxSetField(mxData,0,"complexity",mxCreateDoubleScalar(0)); mxSetField(mxAutoinheritanceInfo,0,"outputs",mxData); } { mxSetField(mxAutoinheritanceInfo,0,"locals",mxCreateDoubleMatrix(0,0,mxREAL)); } return(mxAutoinheritanceInfo); }