コード例 #1
0
ファイル: temp5_sfun.c プロジェクト: katsikas/katsikas-repo
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

}
コード例 #2
0
ファイル: grep_mex.c プロジェクト: simonward86/Spectra
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;
}
コード例 #3
0
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

}
コード例 #4
0
ファイル: glpkcc.cpp プロジェクト: lenhattan86/EPLT
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;
}
コード例 #5
0
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(&params);
	/***********************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);
}
コード例 #6
0
ファイル: predict.c プロジェクト: palexang/food-101
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
	{
コード例 #7
0
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
}
コード例 #8
0
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 () ;
}
コード例 #9
0
ファイル: plx_reader.c プロジェクト: mobeets/V4SaccadeRFs
/* 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(&timestamp,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);
    
}
コード例 #10
0
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

}
コード例 #11
0
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;

}
コード例 #12
0
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);
}
コード例 #13
0
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;
}
コード例 #14
0
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

}
コード例 #15
0
/**
 * \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);
}
コード例 #16
0
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

}
コード例 #17
0
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

}
コード例 #18
0
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

}
コード例 #19
0
ファイル: Load_Nelsonlab.cpp プロジェクト: heimel/InVivoTools
//___________________________________________________________________________________
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);

}
コード例 #20
0
ファイル: APSA_sfun.c プロジェクト: mmastrodonato/ptfc_tools
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

}
コード例 #21
0
//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);

}
コード例 #22
0
ファイル: APSA_sfun.c プロジェクト: mmastrodonato/ptfc_tools
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

}
コード例 #23
0
ファイル: svmtrain.c プロジェクト: contaconta/neurons
// 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;
}
コード例 #24
0
ファイル: APSA_sfun.c プロジェクト: mmastrodonato/ptfc_tools
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;
}
コード例 #25
0
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);
	}
}
コード例 #26
0
ファイル: APSA_sfun.c プロジェクト: mmastrodonato/ptfc_tools
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);
}
コード例 #27
0
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);
	}
}
コード例 #28
0
ファイル: APSA_sfun.c プロジェクト: mmastrodonato/ptfc_tools
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

}
コード例 #29
0
ファイル: Demo_Glove_sfun.c プロジェクト: maryamsab/realact
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;
}
コード例 #30
0
ファイル: SyncGenLib_sfun.c プロジェクト: eladven/thesis
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

}