unsigned int sf_temp5_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1713015902U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1235666872U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1969811860U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1731324628U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2853210503U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3873541829U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1769915606U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3909096918U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_temp5_get_check_sum(mxArray *plhs[]); sf_c1_temp5_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3691397736U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2228706418U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(148782436U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(4073970181U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1187166047U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2340605884U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1318170360U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1009630803U); } return 1; #else return 0; #endif }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { double *matchs; /* The Result */ unsigned int dS, dP, dOptions; /* regex associated variables */ #define ERRBUF 128 #define PREG 1024 regex_t preg[PREG]; /* Pointer to pattern buffer */ char *regex; /* Pointer to the null-terminated string */ char *string; /* String to be searched */ char *options; /* Options for search (i,o) */ int cflags; /* Flags used to determine the type of compilation */ int errcode; /* Return code from regcomp */ int retcode; /* Return code from regexec */ char errbuf[ERRBUF]; size_t nmatch; regmatch_t pmatch; int eflags; int pindex=0; int offset=0; int buflenP, buflenS, buflenO; int start[PREG]; int end[PREG]; /* Check for proper number of arguments */ if (nrhs < 2) mexErrMsgTxt("grep_mex: Too few input arguments (min 2)."); if (nrhs > 3) mexErrMsgTxt("grep_mex: Too many input arguments (max 3)."); if (nlhs > 2) mexErrMsgTxt("grep_mex: Too many output arguments (max 2)."); /* Check the dimensions of Input par. */ dS = mxGetNumberOfDimensions(S); dP = mxGetNumberOfDimensions(P); if (dS > 2) mexErrMsgTxt("grep_mex: String must be a single char line."); if (dP > 2) mexErrMsgTxt("grep_mex: RegExp must be a single char line."); if (!mxIsChar(S)) mexErrMsgTxt("grep_mex: S should be a char array."); if (!mxIsChar(P)) mexErrMsgTxt("grep_mex: P should be a char array."); cflags = REG_EXTENDED | REG_NEWLINE; if (nrhs >= 3) { if (!mxIsChar(Options)) mexErrMsgTxt("grep_mex: Options should be a char array."); dOptions = mxGetNumberOfDimensions(Options); if (dOptions > 2) mexErrMsgTxt("grep_mex: Options must be a single char line."); buflenO = (mxGetM(Options) * mxGetN(Options) * sizeof(mxChar)) + 1; options = malloc(buflenO); if (!options) mexErrMsgTxt("grep_mex: can not allocate Options."); mxGetString(Options, options, buflenO); if (strchr(options, 'i')) cflags |= REG_ICASE; if (strchr(options, 'o')) pindex = 1; } /* Copy a string mxArray's data into a C-style string */ buflenS = (mxGetM(S) * mxGetN(S) * sizeof(mxChar)) + 1; buflenP = (mxGetM(P) * mxGetN(P) * sizeof(mxChar)) + 1; string = malloc(buflenS); regex = malloc(buflenP); mxGetString(S, string, buflenS); mxGetString(P, regex, buflenP); /* compile the pattern */ if (errcode = regcomp(preg, regex, cflags)) { regerror(errcode, preg, errbuf, ERRBUF); mexErrMsgTxt(errbuf); } /* main loop for searching pattern */ offset=0; nmatch=0; do { /* Do the pattern matching */ retcode = regexec(preg, string+offset, 1, &pmatch, eflags); if (retcode != REG_NOMATCH) { /* store start and end indexes */ if (pmatch.rm_so >= 0 && pmatch.rm_eo >= pmatch.rm_so) { start[nmatch] = offset+pmatch.rm_so+1; end[nmatch] = offset+pmatch.rm_eo; nmatch++; if (pmatch.rm_eo) offset+=pmatch.rm_eo; else offset++; } else retcode = REG_NOMATCH; } } while (!retcode && offset < strlen(string) && nmatch < PREG && !pindex); /* Free the memory allocated */ regfree(preg); free(regex); free(string); /* regexec returns zero for a successful match or REG_NOMATCH for failure. */ if (retcode && retcode != REG_NOMATCH) { mexErrMsgTxt("Internal error: Could not understand return argument from regexec"); } /* Create a matrix for the return argument */ M = mxCreateDoubleMatrix(1, nmatch, mxREAL); N = mxCreateDoubleMatrix(1, nmatch, mxREAL); /* Fill up return argument */ for (pindex=0; pindex < nmatch; pindex++) { mxGetPr(M)[pindex] = (double) (start[pindex]); mxGetPr(N)[pindex] = (double) (end[pindex]); } return; }
unsigned int sf_model_AllInOne_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2467685467U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3898529014U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1681454982U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(4114254287U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3945093606U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1830009997U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(378281319U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3848505347U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1764838350U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3410240878U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(118138738U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(243351119U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1197988836U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(903038529U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(417905079U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(706922450U); } return 1; #else return 0; #endif }
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; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /***********************INPUT DATA*******************************************/ //Weight matrices const mxArray *mWeights = prhs[0]; //Bias matrices const mxArray *mBiases = prhs[1]; //Activation functions const mxArray *mActivation = prhs[2]; //Name of file with training data char *trainingFileName; //Maximal number of epochs unsigned int epochs; //Desired error DATA_TYPE error; //Algorithm type unsigned int algorithm; //Report interval unsigned int report_interval; //Pointers to weights DATA_TYPE **weights; DATA_TYPE **biases; //Pointers to weight arrays mxArray **mAWeights; mxArray **mABiases; //Dimensions of weight arrays unsigned int *weightMDim; unsigned int *weightNDim; unsigned int *biasDim; //Number of layers unsigned int layers; //Activation type unsigned int *activation; //Output unsigned int *times;//Time passed DATA_TYPE *MSEs;//Mean squared errors unsigned int *entries;//Number of entries unsigned int mLogSize[2]; //Iterators int i; //Output data mxArray *mMSEs; mxArray *mTimes; //Maximal execution time unsigned int max_time; //Passing parameters train_params params; /*******************************BODY*****************************************/ nlhs = 0; if(nrhs != 9){ mexErrMsgTxt("Must be 8 input arguments!"); return; } trainingFileName = (char *)mxCalloc(mxGetN(prhs[3]) + 2, sizeof(char)); mxGetString(prhs[3], trainingFileName, mxGetN(prhs[3]) + 2); epochs = (unsigned int) mxGetScalar(prhs[6]); error = (DATA_TYPE) mxGetScalar(prhs[5]); algorithm = (unsigned int) mxGetScalar(prhs[4]); report_interval = (unsigned int) mxGetScalar(prhs[7]); max_time = (unsigned int) mxGetScalar(prhs[8]); layers = mxGetNumberOfFields(mWeights); weightNDim = (unsigned int*)mxCalloc(layers, sizeof(unsigned int)); weightMDim = (unsigned int*)mxCalloc(layers, sizeof(unsigned int)); biasDim = (unsigned int*)mxCalloc(layers, sizeof(unsigned int)); weights = (DATA_TYPE **)mxCalloc(layers, sizeof(DATA_TYPE *)); biases = (DATA_TYPE **)mxCalloc(layers, sizeof(DATA_TYPE *)); mAWeights = (mxArray **)mxCalloc(layers, sizeof(mxArray *)); mABiases = (mxArray **)mxCalloc(layers, sizeof(mxArray *)); activation = (unsigned int *)mxGetData(mActivation); for(i = 0; i < layers; i++){ mAWeights[i] = (mxArray *)mxGetFieldByNumber(mWeights, 0, i); mABiases[i] = (mxArray *)mxGetFieldByNumber(mBiases, 0, i); weights[i] = (DATA_TYPE *)mxGetData(mAWeights[i]); biases[i] = (DATA_TYPE *)mxGetData(mABiases[i]); weightMDim[i] = mxGetN(mAWeights[i]);//Convert dimensions column-line storage weightNDim[i] = mxGetM(mAWeights[i]); biasDim[i] = mxGetM(mABiases[i]); } MSEs = (DATA_TYPE *)mxCalloc(epochs, sizeof(DATA_TYPE)); times = (unsigned int *)mxCalloc(epochs, sizeof(unsigned int)); entries = (unsigned int *)mxCalloc(1, sizeof(unsigned int)); params.MSEs = MSEs; params.times = times; params.entries = entries; params.weights = weights; params.biases = biases; params.layers = layers; params.WMs = weightMDim; params.WNs = weightNDim; params.BNs = biasDim; params.activation = activation; params.trainingFileName = trainingFileName; params.algorithm = algorithm; params.error = error; params.epochs = epochs; params.report_interval = report_interval; params.max_time = max_time; fann_train_matlab(¶ms); /***********************OUTPUT DATA******************************************/ mLogSize[0] = *entries; mLogSize[1] = 1; mMSEs = mxCreateNumericArray(2, mLogSize, mxDOUBLE_CLASS, mxREAL); mTimes = mxCreateNumericArray(2, mLogSize, mxINT32_CLASS, mxREAL); mxSetData(mMSEs, MSEs); mxSetData(mTimes, times); nlhs = 2; plhs[0] = mMSEs; plhs[1] = mTimes; mxFree(trainingFileName); mxFree(weightMDim); mxFree(weightNDim); mxFree(biasDim); mxFree(weights); mxFree(biases); }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { int prob_estimate_flag = 0; struct model *model_; char cmd[CMD_LEN]; info = &mexPrintf; col_format_flag = 0; if(nlhs == 2 || nlhs > 3 || nrhs > 5 || nrhs < 3) { exit_with_help(); fake_answer(nlhs, plhs); return; } if(nrhs == 5) { mxGetString(prhs[4], cmd, mxGetN(prhs[4])+1); if(strcmp(cmd, "col") == 0) { col_format_flag = 1; } } if(!mxIsDouble(prhs[0]) || !mxIsDouble(prhs[1])) { mexPrintf("Error: label vector and instance matrix must be double\n"); fake_answer(nlhs, plhs); return; } if(mxIsStruct(prhs[2])) { const char *error_msg; // parse options if(nrhs>=4) { int i, argc = 1; char *argv[CMD_LEN/2]; // put options in argv[] mxGetString(prhs[3], cmd, mxGetN(prhs[3]) + 1); if((argv[argc] = strtok(cmd, " ")) != NULL) while((argv[++argc] = strtok(NULL, " ")) != NULL) ; for(i=1;i<argc;i++) { if(argv[i][0] != '-') break; ++i; if(i>=argc && argv[i-1][1] != 'q') { exit_with_help(); fake_answer(nlhs, plhs); return; } switch(argv[i-1][1]) { case 'b': prob_estimate_flag = atoi(argv[i]); break; case 'q': info = &print_null; i--; break; default: mexPrintf("unknown option\n"); exit_with_help(); fake_answer(nlhs, plhs); return; } } } model_ = Malloc(struct model, 1); error_msg = matlab_matrix_to_model(model_, prhs[2]); if(error_msg) { mexPrintf("Error: can't read model: %s\n", error_msg); free_and_destroy_model(&model_); fake_answer(nlhs, plhs); return; } if(prob_estimate_flag) { if(!check_probability_model(model_)) { mexPrintf("probability output is only supported for logistic regression\n"); prob_estimate_flag=0; } } if(mxIsSparse(prhs[1])) do_predict(nlhs, plhs, prhs, model_, prob_estimate_flag); else { mexPrintf("Testing_instance_matrix must be sparse; " "use sparse(Testing_instance_matrix) first\n"); fake_answer(nlhs, plhs); } // destroy model_ free_and_destroy_model(&model_); } else {
unsigned int sf_Pendulum_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if(strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if(nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if(!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1431062904U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1657165224U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2464160018U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3503652088U); }else if(!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); }else if(!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2092369889U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(151807565U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(4237017808U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1477988202U); }else if(nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch(chartFileNumber) { case 2: { extern void sf_c2_Pendulum_get_check_sum(mxArray *plhs[]); sf_c2_Pendulum_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } }else if(!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(256657037U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(491452467U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1530433343U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(4215106033U); }else { return 0; } } else{ ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(4118241242U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(691256092U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1197945047U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1186757417U); } return 1; #else return 0; #endif }
void mexFunction (int nout, mxArray ** out, int nin, mxArray const ** in) { SAMPLE sample; /* training sample */ LEARN_PARM learn_parm; KERNEL_PARM kernel_parm; STRUCT_LEARN_PARM struct_parm; STRUCTMODEL structmodel; int alg_type; enum {IN_ARGS=0, IN_SPARM} ; enum {OUT_W=0} ; char arg [1024 + 1] ; int argc ; char ** argv ; mxArray const * sparm_array; mxArray const * patterns_array ; mxArray const * labels_array ; mxArray const * kernelFn_array ; int numExamples, ei ; mxArray * model_array; /* SVM-light is not fully reentrant, so we need to run this patch first */ init_qp_solver() ; verbosity = 0 ; kernel_cache_statistic = 0 ; if (nin != 2) { mexErrMsgTxt("Two arguments required") ; } /* Parse ARGS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ if (! uIsString(in[IN_ARGS], -1)) { mexErrMsgTxt("ARGS must be a string") ; } mxGetString(in[IN_ARGS], arg, sizeof(arg) / sizeof(char)) ; arg_split (arg, &argc, &argv) ; svm_struct_learn_api_init(argc+1, argv-1) ; read_input_parameters (argc+1,argv-1, &verbosity, &struct_verbosity, &struct_parm, &learn_parm, &kernel_parm, &alg_type ) ; if (kernel_parm.kernel_type != LINEAR && kernel_parm.kernel_type != CUSTOM) { mexErrMsgTxt ("Only LINEAR or CUSTOM kerneles are supported") ; } /* Parse SPARM ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ sparm_array = in [IN_SPARM] ; /* jk remove */ if (! sparm_array) { mexErrMsgTxt("SPARM must be a structure") ; } struct_parm.mex = sparm_array ; patterns_array = mxGetField(sparm_array, 0, "patterns") ; if (! patterns_array || ! mxIsCell(patterns_array)) { mexErrMsgTxt("SPARM.PATTERNS must be a cell array") ; } numExamples = mxGetNumberOfElements(patterns_array) ; labels_array = mxGetField(sparm_array, 0, "labels") ; if (! labels_array || ! mxIsCell(labels_array) || ! mxGetNumberOfElements(labels_array) == numExamples) { mexErrMsgTxt("SPARM.LABELS must be a cell array " "with the same number of elements of " "SPARM.PATTERNS") ; } sample.n = numExamples ; sample.examples = (EXAMPLE *) my_malloc (sizeof(EXAMPLE) * numExamples) ; for (ei = 0 ; ei < numExamples ; ++ ei) { sample.examples[ei].x.mex = mxGetCell(patterns_array, ei) ; sample.examples[ei].y.mex = mxGetCell(labels_array, ei) ; sample.examples[ei].y.isOwner = 0 ; } if (struct_verbosity >= 1) { mexPrintf("There are %d training examples\n", numExamples) ; } kernelFn_array = mxGetField(sparm_array, 0, "kernelFn") ; if (! kernelFn_array && kernel_parm.kernel_type == CUSTOM) { mexErrMsgTxt("SPARM.KERNELFN must be defined for CUSTOM kernels") ; } if (kernelFn_array) { MexKernelInfo * info ; if (mxGetClassID(kernelFn_array) != mxFUNCTION_CLASS) { mexErrMsgTxt("SPARM.KERNELFN must be a valid function handle") ; } info = (MexKernelInfo*) kernel_parm.custom ; info -> structParm = sparm_array ; info -> kernelFn = kernelFn_array ; } /* Learning ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ switch (alg_type) { case 0: svm_learn_struct(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,NSLACK_ALG) ; break ; case 1: svm_learn_struct(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,NSLACK_SHRINK_ALG); break ; case 2: svm_learn_struct_joint(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,ONESLACK_PRIMAL_ALG); break ; case 3: svm_learn_struct_joint(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,ONESLACK_DUAL_ALG); break ; case 4: svm_learn_struct_joint(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel,ONESLACK_DUAL_CACHE_ALG); break ; case 9: svm_learn_struct_joint_custom(sample,&struct_parm,&learn_parm,&kernel_parm,&structmodel); break ; default: mexErrMsgTxt("Unknown algorithm type") ; } /* Write output ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ /* Warning: The model contains references to the original data 'docs'. If you want to free the original data, and only keep the model, you have to make a deep copy of 'model'. */ /* jk change */ model_array = newMxArrayEncapsulatingSmodel (&structmodel) ; out[OUT_W] = mxDuplicateArray (model_array) ; destroyMxArrayEncapsulatingSmodel (model_array) ; free_struct_sample (sample) ; free_struct_model (structmodel) ; svm_struct_learn_api_exit () ; free_qp_solver () ; }
/* 29-July-2009*/ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { char * filename; FILE * fid; int buflen; unsigned int packetSize; short *outw; short type, upperbyte,channel,unit,nwf, nwords,wf[64]; int header[64],freq,ndsp,nevents,nslow,timestamp,dim[2],j; unsigned int counter,SpikeCount; double *out,*wfs,*Achannels; int en,st; char Trodalness; char chl,chflag,DoAll, Dowf; /* Get filename */ buflen = mxGetM(prhs[0]) * mxGetN(prhs[0])+1; filename = mxCalloc(buflen, sizeof(char)); mxGetString(prhs[0], filename, buflen); Dowf = 0; if (nlhs == 2) Dowf = 1; DoAll = 0; if (nrhs<2) DoAll = 1; else { wfs = mxGetPr(prhs[1]); if (wfs[0] == 0) DoAll = 1; } if (nrhs <3) chl = 0; else { chl = mxGetM(prhs[2]) * mxGetN(prhs[2]); Achannels = mxGetPr(prhs[2]); } fid = fopen(filename,"rb"); if (fid == NULL) { mexPrintf("PLX File not found\n"); return; } fread(&header,4,64,fid); if (header[0] != 1480936528) { fclose(fid); mexPrintf("not a valid PLX File\n"); return; } freq = header[34]; ndsp = header[35]; nevents = header[36]; nslow = header[37]; packetSize = header[38]; fseek(fid,5200,SEEK_CUR); fseek(fid,0,SEEK_END); en = ftell(fid); fseek(fid,200,SEEK_SET); fread(&Trodalness,1,1,fid); fseek(fid,1020*ndsp + 296*nevents + 296*nslow+7504,SEEK_SET); st = ftell(fid); SpikeCount = 0; while (ftell(fid)!=en && !feof(fid)) { fread(&type,2,1,fid); fseek(fid,6,SEEK_CUR); fread(&channel,2,1,fid); fread(&unit,2,1,fid); fseek(fid,2,SEEK_CUR); if (feof(fid)) break; fread(&nwords,2,1,fid); if (nwords > 0) fseek(fid,2*nwords,SEEK_CUR); chflag = 0; if (chl==0) chflag = 1; else for (j=0;j<chl;j++) { if(channel == Achannels[j]) { chflag = 1; j = chl; } } if (type==1 && ((channel > 28) || (chflag == 1 && (unit != 0 || DoAll == 1)))) SpikeCount++; } fseek(fid,1020*ndsp + 296*nevents + 296*nslow+7504,SEEK_SET); plhs[0] = mxCreateDoubleMatrix(SpikeCount/Trodalness,3,mxREAL); out = mxGetPr(plhs[0]); dim[0] = SpikeCount/Trodalness; dim[1] = packetSize*Trodalness; if (Dowf == 1) { plhs[1] = mxCreateNumericArray(2, dim, mxINT16_CLASS, mxREAL); outw = mxGetData(plhs[1]); } counter = 0; while (ftell(fid)!=en && !feof(fid)) { fread(&type,2,1,fid); fread(&upperbyte,2,1,fid); fread(×tamp,4,1,fid); fread(&channel,2,1,fid); fread(&unit,2,1,fid); fread(&nwf,2,1,fid); if (feof(fid)) break; fread(&nwords,2,1,fid); if (nwords > 0) fread(&wf,2,nwords,fid); chflag = 0; if (chl==0) chflag = 1; else for (j=0;j<chl;j++) { if(channel == Achannels[j]) { chflag = 1; j = chl; } } if (type == 1 && ((channel > 28) || (chflag == 1 && (unit != 0 || DoAll == 1)))) { if (Trodalness==1) { out[counter ]=(double)channel; out[counter+ SpikeCount]=(double)unit; out[counter+2*SpikeCount]=(double)(timestamp)/freq; if ((Dowf == 1) && nwords > 0) { for (j=0;j<nwords;j++) outw[counter+j*SpikeCount] = wf[j]; } counter++; } else if(Trodalness==4) { if (counter%4==0) { if(channel!=29) out[counter/4 ]=(double)channel; else out[counter/4 ]=32.0; out[counter/4+ SpikeCount/4]=(double)unit; out[counter/4+2*SpikeCount/4]=(double)(timestamp)/freq; } if ((Dowf == 1) && nwords > 0) { for (j=0;j<nwords;j++) outw[counter/4+(j+packetSize*((channel-1)%4))*SpikeCount/4] = wf[j]; } counter++; } } } fclose(fid); }
unsigned int sf_NavigationObserver_6_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(491190385U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(4166917326U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(510882175U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3942453065U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1976441116U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2861677717U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2037129204U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2442956819U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 6: { extern void sf_c6_NavigationObserver_6_get_check_sum(mxArray *plhs[]); sf_c6_NavigationObserver_6_get_check_sum(plhs); break; } case 7: { extern void sf_c7_NavigationObserver_6_get_check_sum(mxArray *plhs[]); sf_c7_NavigationObserver_6_get_check_sum(plhs); break; } case 8: { extern void sf_c8_NavigationObserver_6_get_check_sum(mxArray *plhs[]); sf_c8_NavigationObserver_6_get_check_sum(plhs); break; } case 9: { extern void sf_c9_NavigationObserver_6_get_check_sum(mxArray *plhs[]); sf_c9_NavigationObserver_6_get_check_sum(plhs); break; } case 10: { extern void sf_c10_NavigationObserver_6_get_check_sum(mxArray *plhs[]); sf_c10_NavigationObserver_6_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2515920432U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3908508645U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2530489944U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2924353608U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2799453638U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(260264629U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2313035235U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(19922145U); } return 1; #else return 0; #endif }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { if (nlhs != 1 || nrhs != 7) { mexErrMsgTxt("Usage: [Error] = fndllSolidWorks(XY (2xN), Tilt (1xN), Rotation (1xN), Rad (1xN), strTemplate, strOutputFile, bShutdown)"); return; } const int *dim1 = mxGetDimensions(prhs[0]); int NumHoles = dim1[1]; const int *dim2 = mxGetDimensions(prhs[1]); const int *dim3 = mxGetDimensions(prhs[2]); if (dim1[0] != 2 || dim2[0] != 1 || dim1[1] != dim2[1] || dim3[1] != NumHoles) { mexErrMsgTxt("Usage: [Error] = fndllSolidWorks(XY (2xN), Tilt (1xN), Rotation (1xN), Rad (1xN), strTemplate, strOutputFile, bShutdown)"); return; } //static const double HOLE_RADIUS_M = .375*MM_TO_M; double *P = (double *)mxGetData(prhs[0]); double *Tilt = (double *)mxGetData(prhs[1]); double *Rot = (double *)mxGetData(prhs[2]); double *Rad = (double *)mxGetData(prhs[3]); char TemplateFile[1000], OutputFile[1000]; mxGetString(prhs[4], TemplateFile, 999); mxGetString(prhs[5], OutputFile, 999); bool bShutdown = (*(char *)mxGetData(prhs[6])) > 0; std::string saveFilename(OutputFile); std::string templateFileName(TemplateFile); vector<double> x_mm_list; vector<double> y_mm_list; vector<double> r_mm_list; vector<double > tilt_degrees_list; vector<double> rotation_degrees_list; for(int i = 0; i< NumHoles;i++) { double tilt_degrees = Tilt[i]; double rotation_degrees = Rot[i]; double x = P[2*i+0]; double y = P[2*i+1]; double r = Rad[i] ; x_mm_list.push_back(x); y_mm_list.push_back(y); r_mm_list.push_back(r); tilt_degrees_list.push_back(tilt_degrees); rotation_degrees_list.push_back(rotation_degrees); } int Err = createRecordingChamber(x_mm_list, y_mm_list, tilt_degrees_list, rotation_degrees_list, r_mm_list, saveFilename, templateFileName,bShutdown); int output_dim_array[2] = {1,1}; plhs[0] = mxCreateNumericArray(2, output_dim_array, mxDOUBLE_CLASS, mxREAL); double *Out = (double*) mxGetPr(plhs[0]); *Out = Err; }
void sf_NavigationObserver_6_get_post_codegen_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { unsigned int chartFileNumber = (unsigned int) mxGetScalar(prhs[0]); char tpChksum[64]; mxGetString(prhs[1], tpChksum,sizeof(tpChksum)/sizeof(char)); tpChksum[(sizeof(tpChksum)/sizeof(char)-1)] = '\0'; switch (chartFileNumber) { case 6: { if (strcmp(tpChksum, "vnEs7LRXbIedWmMIp4tpR") == 0) { extern mxArray *sf_c6_NavigationObserver_6_get_post_codegen_info(void); plhs[0] = sf_c6_NavigationObserver_6_get_post_codegen_info(); return; } } break; case 7: { if (strcmp(tpChksum, "AcVrBEaE20BETQJwFlxJQD") == 0) { extern mxArray *sf_c7_NavigationObserver_6_get_post_codegen_info(void); plhs[0] = sf_c7_NavigationObserver_6_get_post_codegen_info(); return; } } break; case 8: { if (strcmp(tpChksum, "efZOxuTcR8ug3zGUftxIIE") == 0) { extern mxArray *sf_c8_NavigationObserver_6_get_post_codegen_info(void); plhs[0] = sf_c8_NavigationObserver_6_get_post_codegen_info(); return; } } break; case 9: { if (strcmp(tpChksum, "VHYYEPQ91ZY0pBwDYlSIRE") == 0) { extern mxArray *sf_c9_NavigationObserver_6_get_post_codegen_info(void); plhs[0] = sf_c9_NavigationObserver_6_get_post_codegen_info(); return; } } break; case 10: { if (strcmp(tpChksum, "KswCQQD7LctUz1Pfax0OjD") == 0) { extern mxArray *sf_c10_NavigationObserver_6_get_post_codegen_info(void); plhs[0] = sf_c10_NavigationObserver_6_get_post_codegen_info(); return; } } break; default: break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); }
unsigned int sf_NavigationObserver_6_updateBuildInfo_args_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { char commandName[64]; char tpChksum[64]; if (nrhs<3 || !mxIsChar(prhs[0])) return 0; /* Possible call to get the updateBuildInfo_args_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; mxGetString(prhs[2], tpChksum,sizeof(tpChksum)/sizeof(char)); tpChksum[(sizeof(tpChksum)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_updateBuildInfo_args_info")) return 0; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 6: { if (strcmp(tpChksum, "vnEs7LRXbIedWmMIp4tpR") == 0) { extern mxArray *sf_c6_NavigationObserver_6_updateBuildInfo_args_info (void); plhs[0] = sf_c6_NavigationObserver_6_updateBuildInfo_args_info(); break; } } case 7: { if (strcmp(tpChksum, "AcVrBEaE20BETQJwFlxJQD") == 0) { extern mxArray *sf_c7_NavigationObserver_6_updateBuildInfo_args_info (void); plhs[0] = sf_c7_NavigationObserver_6_updateBuildInfo_args_info(); break; } } case 8: { if (strcmp(tpChksum, "efZOxuTcR8ug3zGUftxIIE") == 0) { extern mxArray *sf_c8_NavigationObserver_6_updateBuildInfo_args_info (void); plhs[0] = sf_c8_NavigationObserver_6_updateBuildInfo_args_info(); break; } } case 9: { if (strcmp(tpChksum, "VHYYEPQ91ZY0pBwDYlSIRE") == 0) { extern mxArray *sf_c9_NavigationObserver_6_updateBuildInfo_args_info (void); plhs[0] = sf_c9_NavigationObserver_6_updateBuildInfo_args_info(); break; } } case 10: { if (strcmp(tpChksum, "KswCQQD7LctUz1Pfax0OjD") == 0) { extern mxArray *sf_c10_NavigationObserver_6_updateBuildInfo_args_info (void); plhs[0] = sf_c10_NavigationObserver_6_updateBuildInfo_args_info(); break; } } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; }
unsigned int sf_NavigationObserver_6_autoinheritance_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[32]; char aiChksum[64]; if (nrhs<3 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the autoinheritance_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_autoinheritance_info")) return 0; mxGetString(prhs[2], aiChksum,sizeof(aiChksum)/sizeof(char)); aiChksum[(sizeof(aiChksum)/sizeof(char)-1)] = '\0'; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 6: { if (strcmp(aiChksum, "tt6gId1xzRohFyPwzlhdlE") == 0) { extern mxArray *sf_c6_NavigationObserver_6_get_autoinheritance_info (void); plhs[0] = sf_c6_NavigationObserver_6_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 7: { if (strcmp(aiChksum, "NDdxicNtkjWMlppygXT8jG") == 0) { extern mxArray *sf_c7_NavigationObserver_6_get_autoinheritance_info (void); plhs[0] = sf_c7_NavigationObserver_6_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 8: { if (strcmp(aiChksum, "g8tJJ3cru61IzuI1EvmU4D") == 0) { extern mxArray *sf_c8_NavigationObserver_6_get_autoinheritance_info (void); plhs[0] = sf_c8_NavigationObserver_6_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 9: { if (strcmp(aiChksum, "YnNB58XqpLVyjeF7jrp1TE") == 0) { extern mxArray *sf_c9_NavigationObserver_6_get_autoinheritance_info (void); plhs[0] = sf_c9_NavigationObserver_6_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 10: { if (strcmp(aiChksum, "Sj71DpXAQzVysTqAmw6U8F") == 0) { extern mxArray *sf_c10_NavigationObserver_6_get_autoinheritance_info (void); plhs[0] = sf_c10_NavigationObserver_6_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }
/** * \brief Build the list of parameters that configure the tres::Network * * The tres::Network class (or, more precisely, its underlying concrete * implementation) needs to be configured with a bunch of information, such * as the description of the message set, the network topology, initialization * informations and time resolution, to name only a few. This information is * stored inside the T-Res Network block as mask parameters. * * This function reads the mask parameters and returns a vector-of-string-based * description of the information needed by the tres::Network class. * Specifically, the information returned by this function has the following form: * - the number of messages in the message-set (#msgs) - std::string (1) <-- vector.begin() * - the message-set description - std::string (#msgs) * - "message_type;message_UID;" * - the number of items describing the network (#ndescr) - std::string (1) * - the network description - std::string (#ndescr) * - "description_type;description_file_paths" * - path to additional libraries for the simulation - std::string (1) * - the time resolution - std::string (1) * <-- vector.end() * * No err checking is performed when reading mask parameters since these are already * guaranteed to be valid at MATLAB level (err checking performed by mask callbacks). */ static std::vector<std::string> readMaskAndBuildConfVector(SimStruct *S) { char *bufMsgDescr, // MSG_DESCR_VARNAME *bufTimeRes, // TIME_RESOLUTION *bufNtwkDescr, // NTWK_DESCR_VARNAME *bufAddLibr; // OTHER_DEPS int bufMsgDescrLen, bufTimeResLen, bufNtwkDescrLen, bufAddLibrLen; std::vector<std::string> net_params; // The return list of parameters std::stringstream ss; // A convenience stringstream // Get the number of messages (it is equal to the size of output port) int_T num_msgs = ssGetOutputPortWidth(S,0); // Get the name of the workspace variable for the message set bufMsgDescrLen = mxGetN( ssGetSFcnParam(S,MSG_DESCR_VARNAME) )+1; bufMsgDescr = new char[bufMsgDescrLen]; mxGetString(ssGetSFcnParam(S,MSG_DESCR_VARNAME), bufMsgDescr, bufMsgDescrLen); // Get the actual message set description std::vector<std::string> msg_descr = cellArrayDescrToVectorOfStrings(mexGetVariablePtr("base", bufMsgDescr)); delete bufMsgDescr; // **Insert** the number of messages and // the message set description in the return list ss << num_msgs; net_params.push_back(ss.str()); ss.str(std::string()); // Flush the ss net_params.insert(net_params.end(), msg_descr.begin(), msg_descr.end()); // Get the name of the workspace variable for the Network description bufNtwkDescrLen = mxGetN( ssGetSFcnParam(S,NTWK_DESCR_VARNAME) )+1; bufNtwkDescr = new char[bufNtwkDescrLen]; mxGetString(ssGetSFcnParam(S,NTWK_DESCR_VARNAME), bufNtwkDescr, bufNtwkDescrLen); // Get the number of Network description entries and // the actual Network description int_T num_ndescr = mxGetM(mexGetVariablePtr("base", bufNtwkDescr)); std::vector<std::string> ntwk_descr = cellArrayDescrToVectorOfStrings(mexGetVariablePtr("base", bufNtwkDescr)); delete bufNtwkDescr; // **Insert** the number of Network description entries and // the Network description in the return list ss << num_ndescr; net_params.push_back(ss.str()); ss.str(std::string()); // Flush the ss net_params.insert(net_params.end(), ntwk_descr.begin(), ntwk_descr.end()); // Get the path to additional libraries bufAddLibrLen = mxGetN( ssGetSFcnParam(S,OTHER_DEPS) )+1; bufAddLibr = new char[bufAddLibrLen]; mxGetString(ssGetSFcnParam(S,OTHER_DEPS), bufAddLibr, bufAddLibrLen); // **Insert** the additional libraries in the return list std::string add_libs(bufAddLibr); net_params.push_back(add_libs); // And finally, get the time resolution bufTimeResLen = mxGetN( ssGetSFcnParam(S,TIME_RESOLUTION) )+1; bufTimeRes = new char[bufTimeResLen]; mxGetString(ssGetSFcnParam(S,TIME_RESOLUTION), bufTimeRes, bufTimeResLen); // Convert the time resolution to a double std::string time_resolution(bufTimeRes); delete bufTimeRes; if (time_resolution == "Seconds") ss << 1.0; else if (time_resolution == "Milli_Seconds") ss << 1.0e3; else if (time_resolution == "Micro_Seconds") ss << 1.0e6; else if (time_resolution == "Nano_Seconds") ss << 1.0e9; // **Insert** the time resolution in the return list net_params.push_back(ss.str()); ss.str(std::string()); // Flush the ss // Done, return to the caller return (net_params); }
unsigned int sf_DYNctl_ver4_etud_nonlineaire_autoinheritance_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[32]; char aiChksum[64]; if (nrhs<3 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the autoinheritance_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_autoinheritance_info")) return 0; mxGetString(prhs[2], aiChksum,sizeof(aiChksum)/sizeof(char)); aiChksum[(sizeof(aiChksum)/sizeof(char)-1)] = '\0'; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 1: { if (strcmp(aiChksum, "sERS3oCLq0hbTWa6GftcDD") == 0) { extern mxArray *sf_c1_DYNctl_ver4_etud_nonlineaire_get_autoinheritance_info(void); plhs[0] = sf_c1_DYNctl_ver4_etud_nonlineaire_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 2: { if (strcmp(aiChksum, "sERS3oCLq0hbTWa6GftcDD") == 0) { extern mxArray *sf_c2_DYNctl_ver4_etud_nonlineaire_get_autoinheritance_info(void); plhs[0] = sf_c2_DYNctl_ver4_etud_nonlineaire_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }
unsigned int sf_lib_affectiveChar_scenario_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>2 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"library")) { char machineName[100]; mxGetString(prhs[2], machineName,sizeof(machineName)/sizeof(char)); machineName[(sizeof(machineName)/sizeof(char)-1)] = '\0'; if (!strcmp(machineName,"lib_affectiveChar_scenario")) { if (nrhs==3) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(4147490751U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1617923134U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(70419111U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2846238799U); } else if (nrhs==4) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[3]); switch (chartFileNumber) { case 9: { extern void sf_c9_lib_affectiveChar_scenario_get_check_sum(mxArray *plhs[]); sf_c9_lib_affectiveChar_scenario_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else { return 0; } } else { return 0; } } else { return 0; } } else { return 0; } return 1; #else return 0; #endif }
unsigned int sf_DYNctl_ver4_etud_nonlineaire_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1731369677U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(4155131577U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2068093421U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1784502659U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3851314739U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(870980897U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1217608503U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1442897990U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_DYNctl_ver4_etud_nonlineaire_get_check_sum(mxArray *plhs[]); sf_c1_DYNctl_ver4_etud_nonlineaire_get_check_sum(plhs); break; } case 2: { extern void sf_c2_DYNctl_ver4_etud_nonlineaire_get_check_sum(mxArray *plhs[]); sf_c2_DYNctl_ver4_etud_nonlineaire_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3061339410U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1991824845U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3599338742U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2357874978U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2384080085U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1953346244U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2716181196U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(998868162U); } return 1; #else return 0; #endif }
//___________________________________________________________________________________ void mexFunction(int nOUT, mxArray *pOUT[], int nINP, const mxArray *pINP[]) { int i; double *records_to_get, *range_to_get,*t,*wv, *all_timestamps; int n_records_to_get = 0; int record_units = 0; int nSpikesInFile = 0; int length_records_to_get = 0; int start_idx=0; int end_idx = 0; int idx = 0; /* check number of arguments: expects 1 input */ if (nINP != 3 && nINP != 1) mexErrMsgTxt("Call with fn or fn and array of recs to load(vector), and 1(timestamp) or 2(record number ) as inputs."); if (nOUT > 2) mexErrMsgTxt("Requires two outputs (t, wv)."); /* read inputs */ int fnlen = (mxGetM(pINP[0]) * mxGetN(pINP[0])) + 1; char *fn = (char *) mxCalloc(fnlen, sizeof(char)); if (!fn) mexErrMsgTxt("Not enough heap space to hold converted string."); int errorstatus = mxGetString(pINP[0], fn,fnlen); if (errorstatus) mexErrMsgTxt("Could not convert string data."); nSpikesInFile = GetNumberOfSpikes(fn); //////////////////////////////////////////////////////// // If only one input is passed, assume the whole file is // to be loaded. If only one output is present, assume it is // only timestamps. //////////////////////////////////////////////////////// if(nINP == 1 && nOUT == 1) { /* Return the timestamps of all of the records */ // create outputs pOUT[0] = mxCreateDoubleMatrix(nSpikesInFile, 1, mxREAL); t = mxGetPr(pOUT[0]); // load tt file fn into t and wv arrays ReadTT_timestamps(fn,nSpikesInFile,t); // cleanup mxFree(fn); return; }else if(nINP == 1 && nOUT == 2) { //////////////////////////////////////////////////////// // create outputs //////////////////////////////////////////////////////// mexPrintf("Getting %i records.\n",nSpikesInFile); pOUT[0] = mxCreateDoubleMatrix(nSpikesInFile , 1, mxREAL); t = mxGetPr(pOUT[0]); int wvDims[] = {nSpikesInFile , 4, 32}; // wv = nSpikes x 4 x 32 FORTRAN (column major) array pOUT[1] = mxCreateNumericArray(3, wvDims, mxDOUBLE_CLASS, mxREAL); wv = mxGetPr(pOUT[1]); //////////////////////////////////////////////////////// // load tt file fn into t and wv arrays //////////////////////////////////////////////////////// ReadTT(fn,nSpikesInFile ,t,wv); //////////////////////////////////////////////////////// // cleanup //////////////////////////////////////////////////////// mxFree(fn); return; } //////////////////////////////////////////////////////// // unpack inputs //////////////////////////////////////////////////////// length_records_to_get = mxGetM(pINP[1]) * mxGetN(pINP[1]); records_to_get = mxGetPr(pINP[1]); record_units = (int) mxGetScalar(pINP[2]); switch(record_units) { case BY_TIMESTAMP: //////////////////////////////////////////////////////// // Convert the timestamps into record numbers. This will // make loading these records easy. //////////////////////////////////////////////////////// //////////////////////////////////////////////////////// // Create a very large array of all of the timestamps //////////////////////////////////////////////////////// n_records_to_get = length_records_to_get; all_timestamps = (double *)calloc( nSpikesInFile, sizeof( double ) ); if (all_timestamps == NULL) mexErrMsgTxt("NOT ENOUGH MEMORY"); range_to_get = (double *) calloc( n_records_to_get, sizeof( double ) ); if (range_to_get == NULL) mexErrMsgTxt("NOT ENOUGH MEMORY"); ReadTT_timestamps(fn,nSpikesInFile,all_timestamps); for (i = 0;i<n_records_to_get;i++) { idx = binsearch(nSpikesInFile, all_timestamps, &records_to_get[i]); range_to_get[i] = idx + 1; // Add one since records are assumed // to be from 1 to end. } free(all_timestamps); break; case BY_RECORD: //////////////////////////////////////////////////////// // Get records asked for. First, subract one since matlab // users typically think records as being ordered from // 1 to .... //////////////////////////////////////////////////////// n_records_to_get = length_records_to_get; range_to_get = records_to_get; break; case BY_TIMESTAMP_RANGE: //////////////////////////////////////////////////////// // Error checking //////////////////////////////////////////////////////// if(length_records_to_get != 2) { mexErrMsgTxt("Must pass in two arguements for parameter 2."); return; } //////////////////////////////////////////////////////// // Create a very large array of all of the timestamps //////////////////////////////////////////////////////// all_timestamps = (double *)calloc( nSpikesInFile, sizeof( double ) ); if (all_timestamps == NULL) mexErrMsgTxt("NOT ENOUGH MEMORY"); ReadTT_timestamps(fn,nSpikesInFile,all_timestamps); //////////////////////////////////////////////////////// // Find the index in all_timestamps of the start record. //////////////////////////////////////////////////////// start_idx = binsearch(nSpikesInFile, all_timestamps, &records_to_get[0]) + 1; // Add one since records are assumed // to be from 1 to end. //////////////////////////////////////////////////////// // Find the index in all_timestamps of the end record. //////////////////////////////////////////////////////// end_idx = binsearch(nSpikesInFile, all_timestamps, &records_to_get[1]) + 1; // Add one since records are assumed // to be from 1 to end. free(all_timestamps); n_records_to_get = end_idx - start_idx + 1; //////////////////////////////////////////////////////// // Allocate the space // Using ints would be much more efficient, but it would make it necessary // to rewrite the ReadTT program. I don't want to do that. //////////////////////////////////////////////////////// range_to_get = (double *) calloc( n_records_to_get, sizeof( double ) ); if (range_to_get == NULL) { mexErrMsgTxt("NOT ENOUGH MEMORY"); return; } for (i = 0; i<n_records_to_get;i++) range_to_get[i] = start_idx + i; break; case BY_RECORD_RANGE: //////////////////////////////////////////////////////// // This is easy. First check to make sure the user passed in // the proper number of arguements. //////////////////////////////////////////////////////// if(length_records_to_get != 2) { mexErrMsgTxt("Must pass in a start and end record number for argument 2."); return; } start_idx = (int) records_to_get[0] ; end_idx = (int) records_to_get[1] ; //////////////////////////////////////////////////////// n_records_to_get = end_idx - start_idx + 1; //////////////////////////////////////////////////////// // Allocate the space //////////////////////////////////////////////////////// range_to_get = (double *)calloc( n_records_to_get, sizeof( double ) ); if (range_to_get == NULL) { mexErrMsgTxt("NOT ENOUGH MEMORY"); return; } for (i = 0; i<n_records_to_get;i++) { range_to_get[i] = start_idx + i; } break; case COUNTSPIKES: // ADR/NCST printf("Counting spikes.\n"); pOUT[0] = mxCreateDoubleMatrix(1,1,mxREAL); t = mxGetPr(pOUT[0]); t[0] = nSpikesInFile; break; default: mexErrMsgTxt("Incorrect parameter 3."); } if (!(record_units==COUNTSPIKES)) { //////////////////////////////////////////////////////// // Allocate the space //////////////////////////////////////////////////////// printf("Getting %i records.\n",n_records_to_get); pOUT[0] = mxCreateDoubleMatrix(n_records_to_get, 1, mxREAL); t = mxGetPr(pOUT[0]); int wvDims[] = {n_records_to_get, 4, 32}; // wv = nSpikes x 4 x 32 FORTRAN (column major) array pOUT[1] = mxCreateNumericArray(3, wvDims, mxDOUBLE_CLASS, mxREAL); wv = mxGetPr(pOUT[1]); //////////////////////////////////////////////////////// // Get the data. Record_units will whether to get by // timestamp or by record number. //////////////////////////////////////////////////////// ReadTTByRecord(fn,range_to_get,n_records_to_get,t,wv); // Free this variable only if it was not a matlab variable. if (record_units == BY_TIMESTAMP_RANGE || record_units == BY_RECORD_RANGE ) free(range_to_get); } // cleanup mxFree(fn); }
unsigned int sf_APSA_autoinheritance_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[32]; char aiChksum[64]; if (nrhs<3 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the autoinheritance_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_autoinheritance_info")) return 0; mxGetString(prhs[2], aiChksum,sizeof(aiChksum)/sizeof(char)); aiChksum[(sizeof(aiChksum)/sizeof(char)-1)] = '\0'; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 1: { if (strcmp(aiChksum, "gfwgYAWE4u08pcS9RoID2F") == 0) { extern mxArray *sf_c1_APSA_get_autoinheritance_info(void); plhs[0] = sf_c1_APSA_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 2: { if (strcmp(aiChksum, "YDhojF6BUKMrUJuhmOO8AG") == 0) { extern mxArray *sf_c2_APSA_get_autoinheritance_info(void); plhs[0] = sf_c2_APSA_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 4: { if (strcmp(aiChksum, "rmTZBaeNTuyyuv976XplTE") == 0) { extern mxArray *sf_c4_APSA_get_autoinheritance_info(void); plhs[0] = sf_c4_APSA_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 5: { if (strcmp(aiChksum, "uL9jcKGA6838zxLgqZ1il") == 0) { extern mxArray *sf_c5_APSA_get_autoinheritance_info(void); plhs[0] = sf_c5_APSA_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 6: { if (strcmp(aiChksum, "uL9jcKGA6838zxLgqZ1il") == 0) { extern mxArray *sf_c6_APSA_get_autoinheritance_info(void); plhs[0] = sf_c6_APSA_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 7: { if (strcmp(aiChksum, "L2erPxXLmRXvh0K4hNeCLE") == 0) { extern mxArray *sf_c7_APSA_get_autoinheritance_info(void); plhs[0] = sf_c7_APSA_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 8: { if (strcmp(aiChksum, "uL9jcKGA6838zxLgqZ1il") == 0) { extern mxArray *sf_c8_APSA_get_autoinheritance_info(void); plhs[0] = sf_c8_APSA_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 9: { if (strcmp(aiChksum, "L2erPxXLmRXvh0K4hNeCLE") == 0) { extern mxArray *sf_c9_APSA_get_autoinheritance_info(void); plhs[0] = sf_c9_APSA_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }
//usage:feature = feaGen( training,depth,ndim); //state:finishing //version:v1 //notation: maximum size of buffer is 1024 void mexFunction(int nlhs, mxArray *plhs[], int nrhs, mxArray * prhs[]) { // check the input parameter if (nlhs != 1) mexErrMsgTxt(" error in using feaGen, one output is needed"); if (nrhs != 3) mexErrMsgTxt(" error in using feaGen, three input are needed"); if (!mxIsCell(prhs[0])) { mexErrMsgTxt(" input type error"); } mxArray * pp, *ptemp; mwSize M; mwSize depth, ndim; int i, j, k, m, n, intTemp; double *pointer; //get parameter depth = mxGetScalar(prhs[1]); ndim = mxGetScalar(prhs[2]); M = mxGetM(prhs[0]); //alloc the space char *buf = (char*) mxMalloc((unsigned int) (MAXSIZE) * sizeof(char)); char ** fea; fea = (char**) mxMalloc((unsigned int) ndim * sizeof(char*)); for (i = 0; i < ndim; i++) { fea[i] = (char*) mxMalloc((unsigned int) (MAXSIZE) * sizeof(char)); } feature fv(ndim, depth, M); for (i = 0; i < M; i++) { fv.addLine(); ptemp = mxGetCell(prhs[0], i); if (mxGetString(ptemp, buf, (unsigned int) MAXSIZE)) mexErrMsgTxt("error in the buffer of this function:line53"); #ifdef debug mexPrintf("%s",buf); #endif for (j = 0; buf[j] != '\0'; j++) { intTemp = char2num(buf[j]); for (int l = 0; l < ndim; l++) { fea[l][j] = (int)(intTemp & 0x1) + '0'; intTemp >>= 1; } } int len = j; #ifdef debug mexPrintf("%s",len); #endif char *temp; temp = (char*) mxMalloc((ndim * depth + 1) * sizeof(char)); for (j = 0; j <= len - depth; j++) { intTemp = 0; int mm, nn; for (nn = 0; nn < ndim; nn++) { for (mm = 0; mm < depth; mm++) { temp[intTemp++] = fea[nn][mm + j]; } } *(temp + ndim * depth) = '\0'; intTemp = ndim * depth; int index = to2num(temp, intTemp); if( index < 0 || index > power2(ndim,depth)) { mexErrMsgTxt("error in input format line:90"); } fv.store(index); } mxFree(temp); } mxFree(buf); for (i = 0; i < ndim; i++) { mxFree(fea[i]); } mxFree(fea); int lineSize = fv.getLineSize(); plhs[0] = mxCreateDoubleMatrix(fv.getLen(), lineSize, mxREAL); pointer = mxGetPr(plhs[0]); fv.transaction(pointer); }
unsigned int sf_APSA_get_eml_resolved_functions_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[64]; if (nrhs<2 || !mxIsChar(prhs[0])) return 0; /* Possible call to get the get_eml_resolved_functions_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_eml_resolved_functions_info")) return 0; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 1: { extern const mxArray *sf_c1_APSA_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c1_APSA_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 2: { extern const mxArray *sf_c2_APSA_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c2_APSA_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 4: { extern const mxArray *sf_c4_APSA_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c4_APSA_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 5: { extern const mxArray *sf_c5_APSA_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c5_APSA_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 6: { extern const mxArray *sf_c6_APSA_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c6_APSA_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 7: { extern const mxArray *sf_c7_APSA_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c7_APSA_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 8: { extern const mxArray *sf_c8_APSA_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c8_APSA_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 9: { extern const mxArray *sf_c9_APSA_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c9_APSA_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }
// nrhs should be 3 int parse_command_line(int nrhs, const mxArray *prhs[], char *model_file_name) { int i, argc = 1; char cmd[CMD_LEN]; char *argv[CMD_LEN/2]; // default values param.svm_type = C_SVC; param.kernel_type = RBF; param.degree = 3; param.gamma = 0; // 1/k param.coef0 = 0; param.nu = 0.5; param.cache_size = 100; param.C = 1; param.eps = 1e-3; param.p = 0.1; param.shrinking = 1; param.probability = 0; param.nr_weight = 0; param.weight_label = NULL; param.weight = NULL; cross_validation = 0; // svmtrain loaded only once under matlab if (svm_default_print_string == NULL) svm_default_print_string = svm_print_string; else svm_print_string = svm_default_print_string; if(nrhs <= 1) return 1; if(nrhs > 2) { // put options in argv[] mxGetString(prhs[2], cmd, mxGetN(prhs[2]) + 1); if((argv[argc] = strtok(cmd, " ")) != NULL) while((argv[++argc] = strtok(NULL, " ")) != NULL) ; } // parse options for(i=1;i<argc;i++) { if(argv[i][0] != '-') break; ++i; if(i>=argc && argv[i-1][1] != 'q') // since option -q has no parameter return 1; switch(argv[i-1][1]) { case 's': param.svm_type = atoi(argv[i]); break; case 't': param.kernel_type = atoi(argv[i]); break; case 'd': param.degree = atoi(argv[i]); break; case 'g': param.gamma = atof(argv[i]); break; case 'r': param.coef0 = atof(argv[i]); break; case 'n': param.nu = atof(argv[i]); break; case 'm': param.cache_size = atof(argv[i]); break; case 'c': param.C = atof(argv[i]); break; case 'e': param.eps = atof(argv[i]); break; case 'p': param.p = atof(argv[i]); break; case 'h': param.shrinking = atoi(argv[i]); break; case 'b': param.probability = atoi(argv[i]); break; case 'q': svm_print_string = &print_null; i--; break; case 'v': cross_validation = 1; nr_fold = atoi(argv[i]); if(nr_fold < 2) { mexPrintf("n-fold cross validation: n must >= 2\n"); return 1; } break; case 'w': ++param.nr_weight; param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight); param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight); param.weight_label[param.nr_weight-1] = atoi(&argv[i-1][2]); param.weight[param.nr_weight-1] = atof(argv[i]); break; default: mexPrintf("Unknown option -%c\n", argv[i-1][1]); return 1; } } return 0; }
unsigned int sf_APSA_updateBuildInfo_args_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { char commandName[64]; char tpChksum[64]; if (nrhs<3 || !mxIsChar(prhs[0])) return 0; /* Possible call to get the updateBuildInfo_args_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; mxGetString(prhs[2], tpChksum,sizeof(tpChksum)/sizeof(char)); tpChksum[(sizeof(tpChksum)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_updateBuildInfo_args_info")) return 0; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 1: { if (strcmp(tpChksum, "W1pLsl8VieHi7tv5i97oaH") == 0) { extern mxArray *sf_c1_APSA_updateBuildInfo_args_info(void); plhs[0] = sf_c1_APSA_updateBuildInfo_args_info(); break; } } case 2: { if (strcmp(tpChksum, "UCJxgYSedRXhsdcrMQVREB") == 0) { extern mxArray *sf_c2_APSA_updateBuildInfo_args_info(void); plhs[0] = sf_c2_APSA_updateBuildInfo_args_info(); break; } } case 4: { if (strcmp(tpChksum, "5fYFGqfubUbZ0SLVVG2H8B") == 0) { extern mxArray *sf_c4_APSA_updateBuildInfo_args_info(void); plhs[0] = sf_c4_APSA_updateBuildInfo_args_info(); break; } } case 5: { if (strcmp(tpChksum, "07vEVLLuwu0mXv45TNSB9F") == 0) { extern mxArray *sf_c5_APSA_updateBuildInfo_args_info(void); plhs[0] = sf_c5_APSA_updateBuildInfo_args_info(); break; } } case 6: { if (strcmp(tpChksum, "07vEVLLuwu0mXv45TNSB9F") == 0) { extern mxArray *sf_c6_APSA_updateBuildInfo_args_info(void); plhs[0] = sf_c6_APSA_updateBuildInfo_args_info(); break; } } case 7: { if (strcmp(tpChksum, "FGjORsjPTeG2GiCFeZybSH") == 0) { extern mxArray *sf_c7_APSA_updateBuildInfo_args_info(void); plhs[0] = sf_c7_APSA_updateBuildInfo_args_info(); break; } } case 8: { if (strcmp(tpChksum, "FTHj0kyYTTEcV00KXVem7C") == 0) { extern mxArray *sf_c8_APSA_updateBuildInfo_args_info(void); plhs[0] = sf_c8_APSA_updateBuildInfo_args_info(); break; } } case 9: { if (strcmp(tpChksum, "BuXj2XzgM05JehrXy2FrnC") == 0) { extern mxArray *sf_c9_APSA_updateBuildInfo_args_info(void); plhs[0] = sf_c9_APSA_updateBuildInfo_args_info(); break; } } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, CONSTmxArray *prhs[]) { static Boolean firstTime=1,deferAvailable; long priorityLevel=-1; double a; Stuff stuff; Boolean isString,oldMatlabBackgrounding; plhs; InitMEX(); isString=nrhs>0 && (mxIsChar(prhs[0]) || mxIsCell(prhs[0])); if(nlhs>1 || nrhs<1 || nrhs>2 || (isString && nlhs>0))PrintfExit("Usage:\n\n%s",useRush); switch(nrhs){ case 2: a=mxGetScalar(prhs[1]); if(a!=0 && a!=0.5 && a!=1 && a!=2 && a!=3 && a!=4 && a!=5 && a!=6 && a!=7) PrintfExit("Illegal priorityLevel %.1f. Must be 0, 0.5, 1, 2, 3, 4, 5, 6, or 7. Usage:\n%s",a,useRush); priorityLevel=a; if(a==0.5)priorityLevel=-1; case 1: if(!isString){ // special case: get an array of timings double s,s0; long j; stuff.getTimes=mxGetScalar(prhs[0]); if(stuff.getTimes<1) PrintfExit("The first argument must be either a string (or strings) or a number."); plhs[0]=mxCreateDoubleMatrix(1,stuff.getTimes,mxREAL); if(plhs[0]==NULL)PrintfExit("Couldn't allocate %ld element array.",stuff.getTimes); stuff.mxTimes=plhs[0]; stuff.iterations=10000; s=Seconds(); s=Seconds(); s0=Seconds()-s; s=Seconds(); for(j=0;j<stuff.iterations;j++) ; s=Seconds()-s-s0; stuff.iterations=(0.001-s0)*stuff.iterations/s; // That many iterations plus a call to Seconds() should take 1 ms. }else stuff.getTimes=0; break; } if(1){ // concatenate array or cell array of strings int error=0; mxArray *out,*in; in=(mxArray *)prhs[0]; error=mexCallMATLAB(1,&out,1,&in,"CatStr"); // Psychtoolbox:PsychOneliners:CatStr.m stuff.mxString=out; }else{ stuff.mxString=prhs[0]; } stuff.trapErrors=1; stuff.error=0; #if TARGET_OS_MAC if(CanControlMatlabBackgrounding()){ oldMatlabBackgrounding=MatlabBackgrounding(0); }else{ if(firstTime){ // Backgrounding is dangerous. Matlab would give time to another process while priority is raised. // Checking the enabled flag (on the disk) is slow, so we only do it once if backgrounding's off. But // if it's on, we give an error, and check again next time. if(IsMatlabBackgroundingEnabled()){ PrintfExit("Rush: please turn off Matlab's \"Backgrounding\" Preference, in the File menu.\n"); }else firstTime=0; } } #endif mexEvalString("lasterr('');"); Rush(priorityLevel,&fun,&stuff); if(CanControlMatlabBackgrounding())MatlabBackgrounding(oldMatlabBackgrounding); if(stuff.error)mexErrMsgTxt("mexCallMATLAB error during Rush"); // never happens { // if there's a message in LASTERR, print it as an error, with a preface int nlhs=1,nrhs=0,error=0; mxArray *plhs[1]={NULL},*prhs[1]={NULL}; char string[512]="Error during Rush: ",*errorMsg; errorMsg=string+strlen(string); error=mexCallMATLAB(nlhs,plhs,nrhs,prhs,"lasterr"); error=mxGetString(plhs[0],errorMsg,sizeof(string)-strlen(string)); if(strlen(errorMsg)>0)mexErrMsgTxt(string); } }
void sf_APSA_get_post_codegen_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { unsigned int chartFileNumber = (unsigned int) mxGetScalar(prhs[0]); char tpChksum[64]; mxGetString(prhs[1], tpChksum,sizeof(tpChksum)/sizeof(char)); tpChksum[(sizeof(tpChksum)/sizeof(char)-1)] = '\0'; switch (chartFileNumber) { case 1: { if (strcmp(tpChksum, "W1pLsl8VieHi7tv5i97oaH") == 0) { extern mxArray *sf_c1_APSA_get_post_codegen_info(void); plhs[0] = sf_c1_APSA_get_post_codegen_info(); return; } } break; case 2: { if (strcmp(tpChksum, "UCJxgYSedRXhsdcrMQVREB") == 0) { extern mxArray *sf_c2_APSA_get_post_codegen_info(void); plhs[0] = sf_c2_APSA_get_post_codegen_info(); return; } } break; case 4: { if (strcmp(tpChksum, "5fYFGqfubUbZ0SLVVG2H8B") == 0) { extern mxArray *sf_c4_APSA_get_post_codegen_info(void); plhs[0] = sf_c4_APSA_get_post_codegen_info(); return; } } break; case 5: { if (strcmp(tpChksum, "07vEVLLuwu0mXv45TNSB9F") == 0) { extern mxArray *sf_c5_APSA_get_post_codegen_info(void); plhs[0] = sf_c5_APSA_get_post_codegen_info(); return; } } break; case 6: { if (strcmp(tpChksum, "07vEVLLuwu0mXv45TNSB9F") == 0) { extern mxArray *sf_c6_APSA_get_post_codegen_info(void); plhs[0] = sf_c6_APSA_get_post_codegen_info(); return; } } break; case 7: { if (strcmp(tpChksum, "FGjORsjPTeG2GiCFeZybSH") == 0) { extern mxArray *sf_c7_APSA_get_post_codegen_info(void); plhs[0] = sf_c7_APSA_get_post_codegen_info(); return; } } break; case 8: { if (strcmp(tpChksum, "FTHj0kyYTTEcV00KXVem7C") == 0) { extern mxArray *sf_c8_APSA_get_post_codegen_info(void); plhs[0] = sf_c8_APSA_get_post_codegen_info(); return; } } break; case 9: { if (strcmp(tpChksum, "BuXj2XzgM05JehrXy2FrnC") == 0) { extern mxArray *sf_c9_APSA_get_post_codegen_info(void); plhs[0] = sf_c9_APSA_get_post_codegen_info(); return; } } break; default: break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* input: -[string] directory, output: -[double array] rms pop. -[double array] mean pop. -[double array[ total change in pop. -[double array] crowd lifetime. */ if (nrhs == 1) { std::uint32_t S(0), R(0); const mwSize *dims = mxGetDimensions(prhs[0]); size_t strlen = dims[1] + 1; char *dir = (char*)malloc(sizeof(char)*strlen); mxGetString(prhs[0], dir, strlen); std::string dirstr(dir); free(dir); mexPrintf("%s\n", dirstr.c_str()); std::string fnamev1 = dirstr + "/segment_pop.dat"; std::string fnamev2 = dirstr + "/segment_pop.v2.dat"; std::string fname; size_t vers = 0; if (fexists(fnamev1)) { vers = 1; fname = fnamev1; } else if (fexists(fnamev2)) { vers = 2; fname = fnamev2; } std::uint16_t L; std::vector<double> rmspops; std::vector<double> meanpops; std::vector<double> totcpops; std::vector<double> lifetimes; if (fexists(fname)) { mexPrintf("Loading..."); FILE *file = fopen(fname.c_str(), "rb"); if (vers == 1) { fread(&S, sizeof(std::uint32_t), 1, file); fread(&R, sizeof(std::uint32_t), 1, file); size_t ss = 0; for (size_t s = 0; s < S; s++) { if (rmspops.size() == rmspops.max_size() - 1) { break; } L = 0; fread(&L, sizeof(std::uint16_t), 1, file); std::uint16_t *data = new std::uint16_t[L](); fread(data, sizeof(std::uint16_t), L, file); bool useable = true; double rms = 0; double tot = 0; for (size_t lftm = 1; lftm < L; lftm++) { double sim = std::min(data[lftm], data[lftm - 1]) / sqrt(data[lftm] * data[lftm - 1]); rms += pow((double)(data[lftm] - data[lftm-1]), 2.); tot += (double) (data[lftm] - data[0]); if (sim < 0.7071){ useable = false; } } if (useable) { rms /= (double) L; tot /= (double)(L - 1); rmspops.push_back(sqrt(L)); meanpops.push_back(tot); totcpops.push_back((double)(data[L - 1] - data[0])); lifetimes.push_back(L); } delete[] data; } } else if (vers == 2) { fread(&R, sizeof(std::uint32_t), 1, file); for (size_t r = 0; r < R; r++) { fread(&S, sizeof(std::uint32_t), 1, file); for (size_t s = 0; s < S; s++) { if (rmspops.size() == rmspops.max_size() - 1) { break; } L = 0; fread(&L, sizeof(std::uint16_t), 1, file); std::uint16_t *data = new std::uint16_t[L](); fread(data, sizeof(std::uint16_t), L, file); bool useable = true; double rms = 0; double tot = 0; for (size_t lftm = 1; lftm < L; lftm++) { double sim = std::min(data[lftm], data[lftm - 1]) / sqrt(data[lftm] * data[lftm - 1]); rms += pow((double)(data[lftm] - data[0]), 2.); tot += (double)(data[lftm] - data[lftm-1]); if (sim < 0.7071){ useable = false; } } if (useable) { rms /= (double) L; tot /= (double)(L - 1); rmspops.push_back(sqrt(rms)); meanpops.push_back(tot); totcpops.push_back((double)(data[L - 1] - data[0])); lifetimes.push_back(L); } delete[] data; } } } fclose(file); plhs[0] = mxCreateNumericMatrix(1, rmspops.size(), mxDOUBLE_CLASS, mxREAL); double* popout = (double*)mxGetData(plhs[0]); memcpy(popout, &rmspops[0], sizeof(double)*rmspops.size()); plhs[1] = mxCreateNumericMatrix(1, meanpops.size(), mxDOUBLE_CLASS, mxREAL); double* mpopout = (double*)mxGetData(plhs[1]); memcpy(mpopout, &meanpops[0], sizeof(double)*meanpops.size()); plhs[2] = mxCreateNumericMatrix(1, totcpops.size(), mxDOUBLE_CLASS, mxREAL); double* tcpopout = (double*)mxGetData(plhs[2]); memcpy(tcpopout, &totcpops[0], sizeof(double)*totcpops.size()); plhs[3] = mxCreateNumericMatrix(1, lifetimes.size(), mxDOUBLE_CLASS, mxREAL); double* lftmout = (double*)mxGetData(plhs[3]); memcpy(lftmout, &lifetimes[0], sizeof(double)*lifetimes.size()); mexPrintf("Load Complete\n"); } else { plhs[0] = mxCreateLogicalScalar(0); mexPrintf("File Does Not Exists.\n"); } } else { mexPrintf("Wrong Number of Input Arguments.\n"); plhs[0] = mxCreateLogicalScalar(0); } }
unsigned int sf_APSA_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>1 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"machine")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2745568101U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(775529877U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3038078439U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2776302878U); } else if (!strcmp(commandName,"exportedFcn")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0U); } else if (!strcmp(commandName,"makefile")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(4023273488U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3023748103U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2578303454U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1292027650U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_APSA_get_check_sum(mxArray *plhs[]); sf_c1_APSA_get_check_sum(plhs); break; } case 2: { extern void sf_c2_APSA_get_check_sum(mxArray *plhs[]); sf_c2_APSA_get_check_sum(plhs); break; } case 4: { extern void sf_c4_APSA_get_check_sum(mxArray *plhs[]); sf_c4_APSA_get_check_sum(plhs); break; } case 5: { extern void sf_c5_APSA_get_check_sum(mxArray *plhs[]); sf_c5_APSA_get_check_sum(plhs); break; } case 6: { extern void sf_c6_APSA_get_check_sum(mxArray *plhs[]); sf_c6_APSA_get_check_sum(plhs); break; } case 7: { extern void sf_c7_APSA_get_check_sum(mxArray *plhs[]); sf_c7_APSA_get_check_sum(plhs); break; } case 8: { extern void sf_c8_APSA_get_check_sum(mxArray *plhs[]); sf_c8_APSA_get_check_sum(plhs); break; } case 9: { extern void sf_c9_APSA_get_check_sum(mxArray *plhs[]); sf_c9_APSA_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else if (!strcmp(commandName,"target")) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1213122363U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2499509803U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(959266273U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3790816109U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(1795126090U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1303769368U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(397491954U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3854730674U); } return 1; #else return 0; #endif }
unsigned int sf_Demo_Glove_updateBuildInfo_args_info( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { char commandName[64]; char tpChksum[64]; if (nrhs<3 || !mxIsChar(prhs[0])) return 0; /* Possible call to get the updateBuildInfo_args_info */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; mxGetString(prhs[2], tpChksum,sizeof(tpChksum)/sizeof(char)); tpChksum[(sizeof(tpChksum)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"get_updateBuildInfo_args_info")) return 0; { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[1]); switch (chartFileNumber) { case 1: { if (strcmp(tpChksum, "5hsaBGstoRErN0A6ioSssF") == 0) { extern mxArray *sf_c1_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c1_Demo_Glove_updateBuildInfo_args_info(); break; } } case 2: { if (strcmp(tpChksum, "NSK499r8cFPIhmkqjLQ4b") == 0) { extern mxArray *sf_c2_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c2_Demo_Glove_updateBuildInfo_args_info(); break; } } case 3: { if (strcmp(tpChksum, "OOW2Tl6JPQYbKDKv7yiUm") == 0) { extern mxArray *sf_c3_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c3_Demo_Glove_updateBuildInfo_args_info(); break; } } case 4: { if (strcmp(tpChksum, "dR0ftyhUCxvNZVzas333IC") == 0) { extern mxArray *sf_c4_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c4_Demo_Glove_updateBuildInfo_args_info(); break; } } case 5: { if (strcmp(tpChksum, "vm6zwHJItv0zktyil35psE") == 0) { extern mxArray *sf_c5_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c5_Demo_Glove_updateBuildInfo_args_info(); break; } } case 8: { if (strcmp(tpChksum, "r1oBQlcwAu6P5EDjTzX8hC") == 0) { extern mxArray *sf_c8_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c8_Demo_Glove_updateBuildInfo_args_info(); break; } } case 10: { if (strcmp(tpChksum, "a9oTrvWOrOFZTRixUhix2D") == 0) { extern mxArray *sf_c10_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c10_Demo_Glove_updateBuildInfo_args_info(); break; } } case 11: { if (strcmp(tpChksum, "houlKpqrjMrdL6VnPS8KuB") == 0) { extern mxArray *sf_c11_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c11_Demo_Glove_updateBuildInfo_args_info(); break; } } case 12: { if (strcmp(tpChksum, "yxLFsPfYw4vYDLUXD0ZBgG") == 0) { extern mxArray *sf_c12_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c12_Demo_Glove_updateBuildInfo_args_info(); break; } } case 13: { if (strcmp(tpChksum, "uUjGZN8cnr2Fra5Vn4RGsG") == 0) { extern mxArray *sf_c13_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c13_Demo_Glove_updateBuildInfo_args_info(); break; } } case 14: { if (strcmp(tpChksum, "PoCaGBz2iEJtnTPkxyiukF") == 0) { extern mxArray *sf_c14_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c14_Demo_Glove_updateBuildInfo_args_info(); break; } } case 15: { if (strcmp(tpChksum, "qwIbBC2oblP3Re0wu76IvF") == 0) { extern mxArray *sf_c15_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c15_Demo_Glove_updateBuildInfo_args_info(); break; } } case 16: { if (strcmp(tpChksum, "QvGt3tBWcy7cZIQEwILXMG") == 0) { extern mxArray *sf_c16_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c16_Demo_Glove_updateBuildInfo_args_info(); break; } } case 17: { if (strcmp(tpChksum, "5eBYl8Ef1qpoEitlDh9wl") == 0) { extern mxArray *sf_c17_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c17_Demo_Glove_updateBuildInfo_args_info(); break; } } case 20: { if (strcmp(tpChksum, "6OMVqaV91894wFHVDApi3E") == 0) { extern mxArray *sf_c20_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c20_Demo_Glove_updateBuildInfo_args_info(); break; } } case 21: { if (strcmp(tpChksum, "XYEmHzzCV7F5PmY21Ga2VF") == 0) { extern mxArray *sf_c21_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c21_Demo_Glove_updateBuildInfo_args_info(); break; } } case 35: { if (strcmp(tpChksum, "tJuDfgpll5BrF182OjlB8E") == 0) { extern mxArray *sf_c35_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c35_Demo_Glove_updateBuildInfo_args_info(); break; } } case 37: { if (strcmp(tpChksum, "mgNqmw8cvZcbuXmBbTrp9") == 0) { extern mxArray *sf_c37_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c37_Demo_Glove_updateBuildInfo_args_info(); break; } } case 38: { if (strcmp(tpChksum, "yxLFsPfYw4vYDLUXD0ZBgG") == 0) { extern mxArray *sf_c38_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c38_Demo_Glove_updateBuildInfo_args_info(); break; } } case 39: { if (strcmp(tpChksum, "xTMlZ5mBpyfqtyxaTKwSTD") == 0) { extern mxArray *sf_c39_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c39_Demo_Glove_updateBuildInfo_args_info(); break; } } case 40: { if (strcmp(tpChksum, "7M3xs6TX5bpbbfWKpdDrXE") == 0) { extern mxArray *sf_c40_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c40_Demo_Glove_updateBuildInfo_args_info(); break; } } case 41: { if (strcmp(tpChksum, "xTMlZ5mBpyfqtyxaTKwSTD") == 0) { extern mxArray *sf_c41_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c41_Demo_Glove_updateBuildInfo_args_info(); break; } } case 42: { if (strcmp(tpChksum, "UHJhXlK7BvMzCIabbWrv8D") == 0) { extern mxArray *sf_c42_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c42_Demo_Glove_updateBuildInfo_args_info(); break; } } case 43: { if (strcmp(tpChksum, "py27Enma4o6YIZYys2hZ8G") == 0) { extern mxArray *sf_c43_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c43_Demo_Glove_updateBuildInfo_args_info(); break; } } case 44: { if (strcmp(tpChksum, "l8Gl1A5I5zrcHAQ64AY4lB") == 0) { extern mxArray *sf_c44_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c44_Demo_Glove_updateBuildInfo_args_info(); break; } } case 45: { if (strcmp(tpChksum, "TYRfK1GKG3nJxBPOVXmiwG") == 0) { extern mxArray *sf_c45_Demo_Glove_updateBuildInfo_args_info(void); plhs[0] = sf_c45_Demo_Glove_updateBuildInfo_args_info(); break; } } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; }
unsigned int sf_SyncGenLib_process_check_sum_call( int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[] ) { #ifdef MATLAB_MEX_FILE char commandName[20]; if (nrhs<1 || !mxIsChar(prhs[0]) ) return 0; /* Possible call to get the checksum */ mxGetString(prhs[0], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (strcmp(commandName,"sf_get_check_sum")) return 0; plhs[0] = mxCreateDoubleMatrix( 1,4,mxREAL); if (nrhs>2 && mxIsChar(prhs[1])) { mxGetString(prhs[1], commandName,sizeof(commandName)/sizeof(char)); commandName[(sizeof(commandName)/sizeof(char)-1)] = '\0'; if (!strcmp(commandName,"library")) { char machineName[100]; mxGetString(prhs[2], machineName,sizeof(machineName)/sizeof(char)); machineName[(sizeof(machineName)/sizeof(char)-1)] = '\0'; if (!strcmp(machineName,"SyncGenLib")) { if (nrhs==3) { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2612098777U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3692022954U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2429196680U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(677229810U); } else if (nrhs==4) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[3]); switch (chartFileNumber) { case 3: { extern void sf_c3_SyncGenLib_get_check_sum(mxArray *plhs[]); sf_c3_SyncGenLib_get_check_sum(plhs); break; } case 4: { extern void sf_c4_SyncGenLib_get_check_sum(mxArray *plhs[]); sf_c4_SyncGenLib_get_check_sum(plhs); break; } default: ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(0.0); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(0.0); } } else { return 0; } } else { return 0; } } else { return 0; } } else { return 0; } return 1; #else return 0; #endif }