unsigned int sf_MiL_BMS_Bat_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)(3500182269U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3037548500U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(710497643U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3153867797U); } 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)(2802859475U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1055069044U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2345976775U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(4233881349U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_MiL_BMS_Bat_get_check_sum(mxArray *plhs[]); sf_c1_MiL_BMS_Bat_get_check_sum(plhs); break; } case 2: { extern void sf_c2_MiL_BMS_Bat_get_check_sum(mxArray *plhs[]); sf_c2_MiL_BMS_Bat_get_check_sum(plhs); break; } case 4: { extern void sf_c4_MiL_BMS_Bat_get_check_sum(mxArray *plhs[]); sf_c4_MiL_BMS_Bat_get_check_sum(plhs); break; } case 12: { extern void sf_c12_MiL_BMS_Bat_get_check_sum(mxArray *plhs[]); sf_c12_MiL_BMS_Bat_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)(3564696471U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(678668628U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1090454852U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3896867807U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(27006558U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3627219509U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2206236686U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(30914698U); } return 1; #else return 0; #endif }
unsigned int sf_BoatDynamic_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, "m1LCUJKGDY65NnIe4NLJlF") == 0) { extern mxArray *sf_c1_BoatDynamic_get_autoinheritance_info(void); plhs[0] = sf_c1_BoatDynamic_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 2: { if (strcmp(aiChksum, "j70NnJ9afNTK58HSep1njE") == 0) { extern mxArray *sf_c2_BoatDynamic_get_autoinheritance_info(void); plhs[0] = sf_c2_BoatDynamic_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }
static int get_option ( // inputs: const mxArray *mxopts, // the MATLAB struct const char *field, // the field to get from the MATLAB struct // outputs: double *x, // double value of the field, if present Long *x_present, // true if x is present char **s, // char value of the field, if present; // must be mxFree'd by caller when done // workspace and parameters cholmod_common *cc ) { Long f ; mxArray *p ; if (cc == NULL) return (FALSE) ; // find the field number if (mxopts == NULL || mxIsEmpty (mxopts) || !mxIsStruct (mxopts)) { // mxopts is not present, or [ ], or not a struct f = EMPTY ; } else { // f will be EMPTY (-1) if the field is not present f = mxGetFieldNumber (mxopts, field) ; } // get the field, or NULL if not present if (f == EMPTY) { p = NULL ; } else { p = mxGetFieldByNumber (mxopts, 0, f) ; } *x_present = FALSE ; if (s != NULL) { *s = NULL ; } if (p == NULL) { // option not present return (TRUE) ; } if (mxIsNumeric (p)) { // option is numeric if (x == NULL) { mexPrintf ("opts.%s field must be a string\n", field) ; mexErrMsgIdAndTxt ("QR:invalidInput", "invalid option") ; } *x = mxGetScalar (p) ; *x_present = TRUE ; } else if (mxIsChar (p)) { // option is a MATLAB string; convert it to a C-style string if (s == NULL) { mexPrintf ("opts.%s field must be a numeric value\n", field) ; mexErrMsgIdAndTxt ("QR:invalidInput", "invalid option") ; } *s = mxArrayToString (p) ; } return (TRUE) ; }
//-------------------------------------------------------------- // funciton: MatlabCStruct() - Traverse the structure tree // to determine the storage requirements when converted to a // C structure. // INPUTS: // pArray - Pointer to Matlab array to be analyzed // MemoryAlignment - 1, 2, 4, or 8, indicating desired (maximum) element // alignment in the C structure. // NestLevel - For recursing strucutres containing structures. // pDataDest - NULL, or a pointer to the beginning of a C structure/ // memory area to which to move Matlab array data. // pDataSource - NULL, or a pointer to the beginning of a C structure/ // memory area from which to move Matlab array data. // RETURNS: // ELEMENT_ATTRIBUTES structure, containing information about the // Matlab array being analyzed. // NOTES: // Call with both pDataDest and pDataSource equal to NULL to simply // determine how much C storage is required for a given Matlab // array. That amount can then be allocated, or compared to // expected. //-------------------------------------------------------------- ELEMENT_ATTRIBUTES MatlabCStruct(const mxArray *pArray, int MemoryAlignment, int NestLevel, unsigned char *pDataDest, unsigned char *pDataSource, int SwapFlag) { #define SPACES {int k;for (k=0; k<NestLevel; k++) printf(" "); } ELEMENT_ATTRIBUTES Attributes; int i, j; // Initialize attributes Attributes.ElementCount; Attributes.StorageSize = 0; Attributes.Alignment = 0; Attributes.ElementSize = 0; // This field meaningless for a structure if (pArray == NULL) return Attributes; // Uninitialized array Attributes.ElementCount = mxGetNumberOfElements(pArray); switch(mxGetClassID(pArray)) { case mxUNKNOWN_CLASS : case mxFUNCTION_CLASS: //case mxOBJECT_CLASS : Attributes.StorageSize = 0; Attributes.Alignment = 1; return Attributes; case mxCELL_CLASS : break; // Fall down to code below case mxSTRUCT_CLASS : break; // Fall down to code below case mxCHAR_CLASS : Attributes.ElementSize = sizeof(mxChar); break; case mxLOGICAL_CLASS : Attributes.ElementSize = sizeof(mxLogical); break; case mxDOUBLE_CLASS : Attributes.ElementSize = sizeof(double); break; case mxSINGLE_CLASS : Attributes.ElementSize = sizeof(float); break; case mxINT8_CLASS : Attributes.ElementSize = sizeof(char); break; case mxUINT8_CLASS : Attributes.ElementSize = sizeof(unsigned char); break; case mxINT16_CLASS : Attributes.ElementSize = sizeof(short); break; case mxUINT16_CLASS : Attributes.ElementSize = sizeof(unsigned short); break; case mxINT32_CLASS : Attributes.ElementSize = sizeof(long); break; case mxUINT32_CLASS : Attributes.ElementSize = sizeof(unsigned long); break; // case mxINT64_CLASS : Attributes.ElementSize = sizeof(__int64); break; case mxINT64_CLASS : Attributes.ElementSize = sizeof(INT64_T); break; // jaj 05/24/2004 default: mexErrMsgTxt("Unknown MX class"); } if (mxIsCell(pArray)) // Array is a cell array { int nElem; mxArray *pCell; // One field in the structure nElem = mxGetNumberOfElements(pArray); for (i=0; i<nElem; i++) { ELEMENT_ATTRIBUTES CellAttributes; pCell = mxGetCell(pArray, i); CellAttributes = MatlabCStruct(pCell, MemoryAlignment, NestLevel+1, NULL, NULL, SwapFlag); // See if padding needs to be added before the element if (Attributes.StorageSize % CellAttributes.Alignment > 0) { int Padding; Padding = CellAttributes.Alignment - (Attributes.StorageSize % CellAttributes.Alignment); if (MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [%d bytes of padding]\n", Attributes.StorageSize, Padding); } Attributes.StorageSize += Padding; } if (MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [cell %d of %d]: %dx%d bytes of %s data\n", Attributes.StorageSize, i, nElem, CellAttributes.StorageSize, CellAttributes.ElementCount, ClassIDText(pCell)); } if (pDataDest) if ((long)pDataDest == -1) CellAttributes = MatlabCStruct(pCell, MemoryAlignment, NestLevel+1, pDataDest, NULL, SwapFlag); else CellAttributes = MatlabCStruct(pCell, MemoryAlignment, NestLevel+1, pDataDest+Attributes.StorageSize, NULL, SwapFlag); if (pDataSource) if ((long)pDataSource == -1) CellAttributes = MatlabCStruct(pCell, MemoryAlignment, NestLevel+1, NULL, pDataSource, SwapFlag); else CellAttributes = MatlabCStruct(pCell, MemoryAlignment, NestLevel+1, NULL, pDataSource+Attributes.StorageSize, SwapFlag); Attributes.StorageSize += CellAttributes.StorageSize * CellAttributes.ElementCount; Attributes.Alignment = MAX(Attributes.Alignment, CellAttributes.Alignment); } // See if padding needs to be added at the end of the structure if (Attributes.StorageSize % Attributes.Alignment > 0) { int Padding; Padding = Attributes.Alignment - (Attributes.StorageSize % Attributes.Alignment); if (MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [%d bytes of padding]\n", Attributes.StorageSize, Padding); } Attributes.StorageSize += Padding; } if (MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [end of cell array]\n", Attributes.StorageSize); } // 08/14/03 jaj Make the element count 1 for cell arrays Attributes.ElementCount = 1; } // end array is Cell array else if (mxIsChar(pArray)) { mxChar *pChar; Attributes.StorageSize = sizeof(char); // special case Attributes.Alignment = MIN(Attributes.StorageSize, MemoryAlignment); if (pDataDest && (long)pDataDest != -1) { pChar = (mxChar *)mxGetData(pArray); for (i=0; i<Attributes.ElementCount; i++) pDataDest[i] = (unsigned char)pChar[i]; } if (pDataSource && (long)pDataSource != -1) { pChar = (mxChar *)mxGetData(pArray); for (i=0; i<Attributes.ElementCount; i++) pChar[i] = (mxChar)pDataSource[i]; } } else if (mxIsStruct(pArray)) // Array is a Structure { int nElem; // 08/14/03 jaj int nField; mxArray *pField; // One field in the structure // Initialize attributes (ElementCount has already been assigned) Attributes.StorageSize = 0; Attributes.Alignment = 0; Attributes.ElementSize = 0; // This field meaningless for a structure nField = mxGetNumberOfFields(pArray); nElem = mxGetNumberOfElements(pArray); for (j=0; j<nElem; j++) // 08/14/03 jaj { ELEMENT_ATTRIBUTES LocalAttributes; LocalAttributes.StorageSize = 0; LocalAttributes.Alignment = 0; LocalAttributes.ElementSize = 0; // This field meaningless for a structure if (nElem > 1 && MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [index %d of %d]\n", Attributes.StorageSize, j, nElem); NestLevel++; } for (i=0; i<nField; i++) { const char *FieldName; // For debug purposes ELEMENT_ATTRIBUTES FieldAttributes; FieldName = mxGetFieldNameByNumber(pArray, i); pField = mxGetFieldByNumber(pArray, j, i); FieldAttributes = MatlabCStruct(pField, MemoryAlignment, NestLevel+1, NULL, NULL, SwapFlag); // See if padding needs to be added before the element if (LocalAttributes.StorageSize % FieldAttributes.Alignment > 0) { int Padding; Padding = FieldAttributes.Alignment - (LocalAttributes.StorageSize % FieldAttributes.Alignment); if (MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [%d bytes of padding]\n", LocalAttributes.StorageSize, Padding); } LocalAttributes.StorageSize += Padding; } if (MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [%s] %dx%d bytes of %s data\n", LocalAttributes.StorageSize, FieldName, FieldAttributes.StorageSize, FieldAttributes.ElementCount, ClassIDText(pField)); } if (pDataDest) { if ((long)pDataDest == -1) FieldAttributes = MatlabCStruct(pField, MemoryAlignment, NestLevel+1, pDataDest, NULL, SwapFlag); else FieldAttributes = MatlabCStruct(pField, MemoryAlignment, NestLevel+1, pDataDest+LocalAttributes.StorageSize+Attributes.StorageSize, NULL, SwapFlag); } if (pDataSource) { if ((long)pDataSource == -1) FieldAttributes = MatlabCStruct(pField, MemoryAlignment, NestLevel+1, NULL, pDataSource, SwapFlag); else FieldAttributes = MatlabCStruct(pField, MemoryAlignment, NestLevel+1, NULL, pDataSource+LocalAttributes.StorageSize+Attributes.StorageSize, SwapFlag); } LocalAttributes.StorageSize += FieldAttributes.StorageSize * FieldAttributes.ElementCount; LocalAttributes.Alignment = MAX(LocalAttributes.Alignment, FieldAttributes.Alignment); LocalAttributes.ElementCount = 1; } // See if padding needs to be added at the end of the structure if (LocalAttributes.StorageSize % LocalAttributes.Alignment > 0) { int Padding; Padding = LocalAttributes.Alignment - (LocalAttributes.StorageSize % LocalAttributes.Alignment); if (MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [%d bytes of padding]\n", LocalAttributes.StorageSize, Padding); } LocalAttributes.StorageSize += Padding; } Attributes.StorageSize += LocalAttributes.StorageSize * LocalAttributes.ElementCount; Attributes.Alignment = MAX(Attributes.Alignment, LocalAttributes.Alignment); if (nElem > 1 && MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { NestLevel--; } } // end for(j) // See if padding needs to be added at the end of the structure if (Attributes.StorageSize % Attributes.Alignment > 0) { int Padding; Padding = Attributes.Alignment - (Attributes.StorageSize % Attributes.Alignment); if (MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [%d bytes of padding]\n", Attributes.StorageSize, Padding); } Attributes.StorageSize += Padding; } if (MatlabCStruct_DebugFlag && (pDataDest || pDataSource)) { SPACES printf("%3d: [end of structure]\n", Attributes.StorageSize); } // 08/14/03 jaj Make the element count 1 for structure arrays Attributes.ElementCount = 1; } // end array is Structure else { // Array is any of the basic, non-aggregate types, except mxChar // Handle byte-swapping on Windows WIN32 platform Attributes.StorageSize = Attributes.ElementSize; Attributes.Alignment = MIN(Attributes.StorageSize, MemoryAlignment); if (pDataDest && (long)pDataDest != -1) { memcpy(pDataDest, mxGetData(pArray), Attributes.ElementSize * Attributes.ElementCount); if (SwapFlag) SwapBytes((char *)pDataDest, Attributes.ElementSize, Attributes.ElementCount); } if (pDataSource && (long)pDataSource != -1) { if (SwapFlag) SwapBytes((char *)pDataSource, Attributes.ElementSize, Attributes.ElementCount); memcpy(mxGetData(pArray), pDataSource, Attributes.ElementSize * Attributes.ElementCount); // and un-swap if (SwapFlag) SwapBytes((char *)pDataSource, Attributes.ElementSize, Attributes.ElementCount); } } // end basic type (except mxChar) return Attributes; } // end MatlabCStruct()
/// get type of current argument (does not increment argument counter) IFType CMatlabInterface::get_argument_type() { const mxArray* arg=m_rhs[m_rhs_counter]; ASSERT(arg); if (mxIsSparse(arg)) { if (mxIsUint8(arg)) return SPARSE_BYTE; if (mxIsChar(arg)) return SPARSE_CHAR; if (mxIsInt32(arg)) return SPARSE_INT; if (mxIsDouble(arg)) return SPARSE_REAL; if (mxIsInt16(arg)) return SPARSE_SHORT; if (mxIsSingle(arg)) return SPARSE_SHORTREAL; if (mxIsUint16(arg)) return SPARSE_WORD; return UNDEFINED; } if (mxIsInt32(arg)) return DENSE_INT; if (mxIsDouble(arg)) return DENSE_REAL; if (mxIsInt16(arg)) return DENSE_SHORT; if (mxIsSingle(arg)) return DENSE_SHORTREAL; if (mxIsUint16(arg)) return DENSE_WORD; if (mxIsChar(arg)) return STRING_CHAR; if (mxIsUint8(arg)) return STRING_BYTE; if (mxIsCell(arg)) { const mxArray* cell=mxGetCell(arg, 0); if (cell && mxGetM(cell)==1) { if (mxIsUint8(cell)) return STRING_BYTE; if (mxIsChar(cell)) return STRING_CHAR; if (mxIsInt32(cell)) return STRING_INT; if (mxIsInt16(cell)) return STRING_SHORT; if (mxIsUint16(cell)) return STRING_WORD; } } return UNDEFINED; }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { size_t mrows, ncols; char buf[100]; FILE * fp; int magic_number; #define DATA_OUT plhs[0] #define TRAIN_DATA prhs[0] #define TRAIN_DATA_LABELS prhs[1] #define TEST_DATA prhs[2] #define TEST_DATA_LABELS prhs[3] if (nrhs > 0 && !mxIsChar(TRAIN_DATA)){ mexErrMsgIdAndTxt( "MATLAB:load_data:inputNotChar", "First input must be a char vector."); } /* The input must be a noncomplex scalar double.*/ mrows = mxGetM(prhs[0]); ncols = mxGetN(prhs[0]); mxGetString(TRAIN_DATA, buf, ncols+1); mexPrintf(buf); mexPrintf("\n"); fp = fopen(buf, "r+b"); if (NULL == fp) mexPrintf("ERROR"); else { int n = fread((void*)&magic_number, sizeof(int), 1, fp); mexPrintf("%d %d\n",n,magic_number); //should be 1 2051 n = fread((void*)&magic_number, sizeof(int), 1, fp); mexPrintf("%d %d\n",n,magic_number); //should be 1 2051 fclose(fp); } // /* Check for proper number of arguments. */ // if(nrhs!=1) { // // } else if(nlhs>1) { // mexErrMsgIdAndTxt( "MATLAB:timestwo:maxlhs", // "Too many output arguments."); // } // // // double *x,*y; // // // // // // // //B OUT = mxCreateDoubleMatrix(M, N, mxREAL); /* Create the output matrix */ // //B = mxGetPr(B OUT); /* Get the pointer to the data of B */ // if( !mxIsChar(prhs[0]) ) // mexErrMsgIdAndTxt( "MATLAB:timestwo:inputNotRealScalarDouble", // "Input must be a string"); // // if( !mxIsDouble(prhs[0]) || mxIsComplex(prhs[0]) || // !(mrows==1 && ncols==1) ) { // mexErrMsgIdAndTxt( "MATLAB:timestwo:inputNotRealScalarDouble", // "Input must be a noncomplex scalar double."); // } // // /* Create matrix for the return argument. */ // plhs[0] = mxCreateDoubleMatrix((mwSize)mrows, (mwSize)ncols, mxREAL); // // /* Assign pointers to each input and output. */ // x = mxGetPr(prhs[0]); // y = mxGetPr(plhs[0]); // // /* Call the timestwo subroutine. */ // timestwo(y,x); }
void json_encode_item(const mxArray *obj) { mxArray *item; mxChar *chars; unsigned int field, nfields; const char *fieldname; mxLogical *logical_ptr; double *double_ptr; float *single_ptr; uint8_t *uint8_ptr; int8_t *int8_ptr; uint16_t *uint16_ptr; int16_t *int16_ptr; uint32_t *uint32_ptr; int32_t *int32_ptr; uint64_t *uint64_ptr; int64_t *int64_ptr; unsigned int i, n; n = mxGetNumberOfElements(obj); if (mxIsChar(obj)) { json_append_char('"'); chars = mxGetChars(obj); for (i=0; i<n; i++) { switch (chars[i]) { case '"': case '\\': case '/': json_append_char('\\'); json_append_char(*(char*)&chars[i]); break; case '\b': json_append_string("\\b"); break; case '\f': json_append_string("\\f"); break; case '\n': json_append_string("\\n"); break; case '\r': json_append_string("\\r"); break; case '\t': json_append_string("\\t"); break; default: if ((chars[i] < 32) || (chars[i] > 126)) json_append_string("\\u%04hx",chars[i]); else json_append_char(*(char*)&chars[i]); } } json_append_char('"'); } else if (n == 0) { json_append_string("[]"); } else { if (n > 1) json_append_char('['); switch (mxGetClassID(obj)) { case mxSTRUCT_CLASS: nfields = mxGetNumberOfFields(obj); for (i=0; i<n; i++) { json_append_char('{'); for (field=0; field<nfields; field++) { fieldname = mxGetFieldNameByNumber(obj,field); item = mxGetFieldByNumber(obj,i,field); if (item != NULL) { json_append_string("\"%s\":",fieldname); json_encode_item(item); json_append_char(','); } } if (nfields > 0) json_strpos--; json_append_string("},"); } break; case mxCELL_CLASS: for (i=0; i<n; i++) { json_encode_item(mxGetCell(obj,i)); json_append_char(','); } break; case mxLOGICAL_CLASS: logical_ptr = mxGetData(obj); for (i=0; i<n; i++) { if (logical_ptr[i]) { json_append_string("true,"); } else { json_append_string("false,"); } } break; case mxDOUBLE_CLASS: double_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_float(double_ptr[i]); break; case mxSINGLE_CLASS: single_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_float(single_ptr[i]); break; case mxINT8_CLASS: int8_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_string("%i,",int8_ptr[i]); break; case mxUINT8_CLASS: uint8_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_string("%u,",uint8_ptr[i]); break; case mxINT16_CLASS: int16_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_string("%i,",int16_ptr[i]); break; case mxUINT16_CLASS: uint16_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_string("%u,",uint16_ptr[i]); break; case mxINT32_CLASS: int32_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_string("%i,",int32_ptr[i]); break; case mxUINT32_CLASS: uint32_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_string("%u,",uint32_ptr[i]); break; case mxINT64_CLASS: int64_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_string("%lli,",int64_ptr[i]); break; case mxUINT64_CLASS: uint64_ptr = mxGetData(obj); for (i=0; i<n; i++) json_append_string("%llu,",uint64_ptr[i]); break; default: error_unsupported_class(obj); } if (json_strpos) json_strpos--; if (n > 1) json_append_char(']'); } }
/* The main mex function */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { char *action; /* Check for an input */ if (nrhs == 0) mexErrMsgIdAndTxt("libusb:libusb", "No input! What shall I do?!"); /* Check for a string */ if (!mxIsChar(prhs[0])) mexErrMsgIdAndTxt("libusb:libusb", "Expected a string as the first argument"); /* Find out what the action required is */ action = mxArrayToString(prhs[0]); /* Initialise the USB interface */ if (strcmp(action, "init") == 0) { /* Check inputs/outputs */ if (nrhs != 1) mexErrMsgIdAndTxt("libusb:init", "Expected no inputs to init"); if (nlhs != 0) mexErrMsgIdAndTxt("libusb:init", "Expected no outputs for init"); /* Clear-up as necessary and (re)initialise the library */ clearup(); libusb_init(NULL); /* Open the USB device */ device = libusb_open_device_with_vid_pid(NULL, 0x0123, 0x4567); if (device == NULL) { libusb_exit(NULL); mexErrMsgIdAndTxt("libusb:init", "Unable to open USB device - is it plugged in?"); } else { /* Claim the USB interface */ if (libusb_claim_interface(device, 0) < 0) { libusb_close(device); libusb_exit(NULL); device = NULL; mexErrMsgIdAndTxt("libusb:init", "Failed to claim the USB device - is something else using it?"); } else mexAtExit(clearup); } } /* Write to the USB interface */ else if (strcmp(action, "write") == 0) { int sent, ret; /* Check inputs/outputs */ if (nrhs != 2) mexErrMsgIdAndTxt("libusb:write", "Expected one input to write (the data)"); if (nlhs > 1) mexErrMsgIdAndTxt("libusb:write", "Expected one output for write (the size of the data written)"); if (!mxIsUint8(prhs[1])) mexErrMsgIdAndTxt("libusb:write", "Expected the input data to be a uint8 array"); /* Check that device isn't NULL */ if (device == NULL) mexErrMsgIdAndTxt("libusb:write", "libusb must be initialised first!"); /* Do the data transfer */ ret = libusb_bulk_transfer(device, 1, (unsigned char *)mxGetData(prhs[1]), (int)mxGetNumberOfElements(prhs[1]), &sent, timeout); if (ret != 0) mexErrMsgIdAndTxt("libusb:write", "Error in bulk transfer - %d", ret); /* Return the number of bytes sent */ plhs[0] = mxCreateDoubleScalar(sent); } else if (strcmp(action, "read") == 0) { int received, ret; /* Check inputs/outputs */ if (nrhs != 2) mexErrMsgIdAndTxt("libusb:read", "Expected one input to read (the data size)"); if (nlhs > 1) mexErrMsgIdAndTxt("libusb:read", "Expected one output for read (the data read)"); if (mxGetNumberOfElements(prhs[1]) != 1) mexErrMsgIdAndTxt("libusb:read", "Expected the input data to be a scalar"); /* Check that device isn't NULL */ if (device == NULL) mexErrMsgIdAndTxt("libusb:read", "libusb must be initialised first!"); /* Create the return data structure */ plhs[0] = mxCreateNumericMatrix(1, (int)mxGetScalar(prhs[1]), mxUINT8_CLASS, mxREAL); /* Do the data transfer */ ret = libusb_bulk_transfer(device, 129, (unsigned char *)mxGetData(plhs[0]), (int)mxGetNumberOfElements(plhs[0]), &received, timeout); if (ret != 0) mexErrMsgIdAndTxt("libusb:read", "Error in bulk transfer - %d", ret); /* Update the size of the return data structure */ mxSetN(plhs[0], received); } else if (strcmp(action, "exit") == 0) { /* Check inputs/outputs */ if (nrhs != 1) mexErrMsgIdAndTxt("libusb:exit", "Expected no inputs to exit"); if (nlhs != 0) mexErrMsgIdAndTxt("libusb:exit", "Expected no outputs for exit"); /* Clear-up */ clearup(); } else { mexErrMsgIdAndTxt("libusb:libusb", "Unknown command; available commands are: init, write, read and exit"); } }
/* ------------------------------------------------------------------- Main MEX function - interface to Matlab. -------------------------------------------------------------------- */ void mexFunction( int nlhs, mxArray *plhs[],int nrhs, const mxArray*prhs[] ) { char solver[20]; /* solver identifier */ int exitflag; /* output arg */ int buf_len; /* real length of the solver identifier */ int verb; /* input argument -- verbosity */ long i ; /* loop variable */ long tmax; /* input arg - max number of iteration */ long t; /* output arg - number of iterations */ double tolrel; /* input arg */ double tolabs; /* input arg */ double tolKKT; /* input arg */ double *tmp_ptr; double *x; /* output arg -- solution*/ double *History; /* output arg */ double *diag_H; /* diagonal of matrix H */ double *f; /* vector f */ /*------------------------------------------------------------------- */ /* Take input arguments */ /*------------------------------------------------------------------- */ if( nrhs != 8) mexErrMsgTxt("Incorrect number of input arguments."); /* matrix H */ matrix_H = mxGetPr(prhs[0]); dim = mxGetM(prhs[0]); if(dim != mxGetN(prhs[0])) mexErrMsgTxt("Matrix H mast be squared."); /* vector f */ f = mxGetPr(prhs[1]); if((MAX(mxGetM(prhs[1]),mxGetN(prhs[1])) != dim) || (MIN(mxGetM(prhs[1]),mxGetN(prhs[1])) != 1)) mexErrMsgTxt("Vector f is of wrong size."); /* string identifier of QP solver to be used */ if( mxIsChar( prhs[2] ) != 1) mexErrMsgTxt("Solver must be a string."); buf_len = (mxGetM(prhs[2]) * mxGetN(prhs[2])) + 1; buf_len = (buf_len > 20) ? 20 : buf_len; mxGetString( prhs[2], solver, buf_len ); /* maximal allowed number of iterations */ tmax = mxIsInf( mxGetScalar(prhs[3])) ? INT_MAX : (long)mxGetScalar(prhs[3]); tolabs = mxGetScalar(prhs[4]); /* abs. precision defining stopping cond*/ tolrel = mxGetScalar(prhs[5]); /* rel. precision defining stopping cond*/ /* KKT cond. tolerance */ tolKKT = (double)mxGetScalar(prhs[6]); verb = (int)mxGetScalar(prhs[7]); /* verbosity on/off */ if( verb > 0 ) { mexPrintf("Settings of QP solver\n"); mexPrintf("solver : %s\n", solver ); mexPrintf("tmax : %d\n", tmax ); mexPrintf("tolabs : %f\n", tolabs ); mexPrintf("tolrel : %f\n", tolrel ); mexPrintf("tolKKT : %f\n", tolKKT ); mexPrintf("dim : %d\n", dim ); mexPrintf("verb : %d\n", verb ); } /*------------------------------------------------------------------- */ /* Inicialization */ /*------------------------------------------------------------------- */ /* output "solution" vector alpha [dim x 1] */ plhs[0] = mxCreateDoubleMatrix(dim,1,mxREAL); x = mxGetPr(plhs[0]); /* allocattes and precomputes diagonal of virtual K matrix */ diag_H = mxCalloc(dim, sizeof(double)); if( diag_H == NULL ) mexErrMsgTxt("Not enough memory."); for(i = 0; i < dim; i++ ) { diag_H[i] = matrix_H[dim*i+i]; } /* counter of access to matrix H */ access = dim; /*------------------------------------------------------------------- */ /* Call QP solver */ /*------------------------------------------------------------------- */ if ( strcmp( solver, "sca" ) == 0 ) { exitflag = gnnls_sca( &get_col, diag_H, f, dim, tmax, tolabs, tolrel, tolKKT, x, &t, &History, verb ); } else if ( strcmp( solver, "scas" ) == 0 ) { exitflag = gnnls_scas( &get_col, diag_H, f, dim, tmax, tolabs, tolrel, tolKKT, x, &t, &History, verb ); } else { mexErrMsgTxt("Unknown QP solver identifier!"); } /*------------------------------------------------------------------- */ /* Generate outputs */ /*------------------------------------------------------------------- */ /* exitflag [1x1] */ plhs[1] = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(plhs[1])) = (double)exitflag; /* t [1x1] */ plhs[2] = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(plhs[2])) = (double)t; /* access [1x1] */ plhs[3] = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(plhs[3])) = (double)access; /* History [2 x (t+1)] */ plhs[4] = mxCreateDoubleMatrix(2,t+1,mxREAL); tmp_ptr = mxGetPr( plhs[4] ); for( i = 0; i <= t; i++ ) { tmp_ptr[INDEX(0,i,2)] = History[INDEX(0,i,2)]; tmp_ptr[INDEX(1,i,2)] = History[INDEX(1,i,2)]; } /*------------------------------------------------------------------- */ /* Free used memory */ /*------------------------------------------------------------------- */ mxFree( History ); mxFree( diag_H ); }
unsigned int sf_DVM_Nikola_test_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)(3803020634U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3539684768U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2352755584U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(702112301U); } 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)(2947537997U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3781689519U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2521394305U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(834272931U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_DVM_Nikola_test_get_check_sum(mxArray *plhs[]); sf_c1_DVM_Nikola_test_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)(3176360410U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1862911626U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(659157607U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1884031890U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2743943101U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3528253370U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1527475681U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3912416570U); } return 1; #else return 0; #endif }
unsigned int sf_timeDelayedEKF_OOSM_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)(1600088023U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3156096357U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1386390350U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(66270203U); } 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 (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 3: { extern void sf_c3_timeDelayedEKF_OOSM_get_check_sum(mxArray *plhs[]); sf_c3_timeDelayedEKF_OOSM_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)(3267489760U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3330274261U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2714568270U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(344490432U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(3945893720U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2256874195U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(392621584U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3665666826U); } return 1; #else return 0; #endif }
void mexFunction(int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[]) { char s[BUFLEN]; mxArray *r; mxArray *im; int width, height; int histbins = HISTBINS; /* * * IMM = IRANK(IM, ORDER, SE [,HISTOBINS] [, EDGE]) * 0 1 2 3 4 */ /* parse out the edge method */ switch (nrhs) { case 5: if (!mxIsChar(EDGE_IN)) mexErrMsgTxt("edge arg must be string"); mxGetString(EDGE_IN, s, BUFLEN); /* EDGE handling flags */ if (strcmp(s, "replicate") == 0) pad_method = PadBorder; else if (strcmp(s, "none") == 0) pad_method = PadNone; else if (strcmp(s, "wrap") == 0) pad_method = PadWrap; else if (strcmp(s, "valid") == 0) pad_method = PadTrim; /* fall through */ case 4: if (!mxIsNumeric(HISTBINS_IN)) mexErrMsgTxt("histbins arg must be numeric"); histbins = (int) * mxGetPr(HISTBINS_IN); /* fall through */ case 3: break; default: mexErrMsgTxt("IRANK requires three input arguments."); } if ((!mxIsNumeric(ORDER_IN)) || (!mxIsNumeric(SE_IN))) mexErrMsgTxt("first 3 args must be numeric"); if (mxIsComplex(IM_IN)) mexErrMsgTxt("IRANK requires a real matrix."); if (mxGetNumberOfDimensions(IM_IN) > 2) mexErrMsgTxt("Only greylevel images allowed."); height = mxGetM(IM_IN); width = mxGetN(IM_IN); switch (mxGetClassID(IM_IN)) { case mxLOGICAL_CLASS: { double *p; mxLogical *q = (mxLogical *)mxGetPr(IM_IN); int i; im = mxCreateDoubleMatrix(height, width, mxREAL); p = mxGetPr(im); for (i=0; i<width*height; i++) *p++ = *q++; break; } case mxUINT8_CLASS: { double *p; unsigned char *q = (unsigned char *)mxGetPr(IM_IN); int i; im = mxCreateDoubleMatrix(height, width, mxREAL); p = mxGetPr(im); for (i=0; i<width*height; i++) *p++ = *q++; break; } case mxUINT16_CLASS: { double *p; unsigned short *q = (unsigned short *)mxGetPr(IM_IN); int i; im = mxCreateDoubleMatrix(height, width, mxREAL); p = mxGetPr(im); for (i=0; i<width*height; i++) *p++ = *q++; break; } case mxDOUBLE_CLASS: { im = (mxArray *)IM_IN; break; } default: mexErrMsgTxt("Only logical, uint8, uint16 or double images allowed"); } /* Do the actual computations in a subroutine */ r = irank(im, SE_IN, ORDER_IN, histbins); if (nlhs == 1) plhs[0] = r; /* free tempory storage if we created it */ if (im != IM_IN) mxDestroyArray(im); return; }
unsigned int sf_minimalist_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)(532953337U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3222539217U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2181727062U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3148281474U); } 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)(942496195U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2493716106U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(4093609393U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3194695841U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 2: { extern void sf_c2_minimalist_get_check_sum(mxArray *plhs[]); sf_c2_minimalist_get_check_sum(plhs); break; } case 3: { extern void sf_c3_minimalist_get_check_sum(mxArray *plhs[]); sf_c3_minimalist_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)(1202817889U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2707286010U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(801213713U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(289536825U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2852924160U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3390588424U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1384938559U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(956306277U); } return 1; #else return 0; #endif }
/** the gateway function */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* [g1, g2] = ddm_fpt_full(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t, t_max, [leak]) */ /* Check argument number */ if (nlhs != 2) { mexErrMsgIdAndTxt("ddm_fpt_full:WrongOutputs", "Wrong number of output arguments"); } if (nrhs < 8) { mexErrMsgIdAndTxt("ddm_fpt_full:WrongInputs", "Too few input arguments"); } /* Process first 8 arguments */ if (!MEX_ARGIN_IS_REAL_VECTOR(0)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "First input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(1)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Second input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(2)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Third input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(3)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Fourth input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(4)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Fifth input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_VECTOR(5)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Sixth input argument expected to be a vector"); if (!MEX_ARGIN_IS_REAL_DOUBLE(6)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Seventh input argument expected to be a double"); if (!MEX_ARGIN_IS_REAL_DOUBLE(7)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Eight input argument expected to be a double"); int mu_size = std::max(mxGetN(prhs[0]), mxGetM(prhs[0])); int sig2_size = std::max(mxGetN(prhs[1]), mxGetM(prhs[1])); int b_lo_size = std::max(mxGetN(prhs[2]), mxGetM(prhs[2])); int b_up_size = std::max(mxGetN(prhs[3]), mxGetM(prhs[3])); int b_lo_deriv_size = std::max(mxGetN(prhs[4]), mxGetM(prhs[4])); int b_up_deriv_size = std::max(mxGetN(prhs[5]), mxGetM(prhs[5])); ExtArray mu(ExtArray::shared_noowner(mxGetPr(prhs[0])), mu_size); ExtArray sig2(ExtArray::shared_noowner(mxGetPr(prhs[1])), sig2_size); ExtArray b_lo(ExtArray::shared_noowner(mxGetPr(prhs[2])), b_lo_size); ExtArray b_up(ExtArray::shared_noowner(mxGetPr(prhs[3])), b_up_size); ExtArray b_lo_deriv(ExtArray::shared_noowner(mxGetPr(prhs[4])), 0.0, b_lo_deriv_size); ExtArray b_up_deriv(ExtArray::shared_noowner(mxGetPr(prhs[5])), 0.0, b_up_deriv_size); double delta_t = mxGetScalar(prhs[6]); double t_max = mxGetScalar(prhs[7]); if (delta_t <= 0.0) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "delta_t needs to be larger than 0.0"); if (t_max <= delta_t) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "t_max needs to be at least as large as delta_t"); /* Process possible 9th non-string argument */ int cur_argin = 8; bool has_leak = false; double inv_leak = 0.0; if (nrhs > cur_argin && !mxIsChar(prhs[cur_argin])) { if (!MEX_ARGIN_IS_REAL_DOUBLE(cur_argin)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "Ninth input argument expected to be a double"); inv_leak = mxGetScalar(prhs[cur_argin]); if (inv_leak < 0.0) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "inv_leak needs to be non-negative"); has_leak = (inv_leak != 0.0); ++cur_argin; } /* Process string arguments */ bool normalise_mass = false; if (nrhs > cur_argin) { char str_arg[6]; /* current only accept 'mnorm' string argument */ if (!mxIsChar(prhs[cur_argin])) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "String argument expected but not found"); if (mxGetString(prhs[cur_argin], str_arg, sizeof(str_arg)) == 1 || strcmp(str_arg, "mnorm") != 0) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "\"mnorm\" string argument expected"); /* this needs to be followed by "yes" or "no" */ if (nrhs <= cur_argin + 1 || !mxIsChar(prhs[cur_argin + 1])) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "String expected after \"mnorm\""); if (mxGetString(prhs[cur_argin + 1], str_arg, sizeof(str_arg)) == 1 || (strcmp(str_arg, "yes") != 0 && strcmp(str_arg, "no") != 0)) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInput", "\"yes\" or \"no\" expected after \"mnorm\""); normalise_mass = (strcmp(str_arg, "yes") == 0); /* no arguments allowed after that */ if (nrhs > cur_argin + 2) mexErrMsgIdAndTxt("ddm_fpt_full:WrongInputs", "Too many input arguments"); } /* reserve space for output */ int n = (int) ceil(t_max / delta_t); plhs[0] = mxCreateDoubleMatrix(1, n, mxREAL); plhs[1] = mxCreateDoubleMatrix(1, n, mxREAL); ExtArray g1(ExtArray::shared_noowner(mxGetPr(plhs[0])), n); ExtArray g2(ExtArray::shared_noowner(mxGetPr(plhs[1])), n); /* compute the pdf's */ DMBase* dm = nullptr; if (has_leak) dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t, inv_leak); else dm = DMBase::create(mu, sig2, b_lo, b_up, b_lo_deriv, b_up_deriv, delta_t); dm->pdfseq(n, g1, g2); if (normalise_mass) dm->mnorm(g1, g2); delete dm; }
// btkAppendMetaData(h, label) // btkAppendMetaData(h, label, sublabel, ..., btkMetaDataInfo((CHAR|BYTE|INTEGER|REAL), values, numdims)) void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { if (nrhs < 2) mexErrMsgTxt("Minimum of two inputs required."); if (nlhs > 1) mexErrMsgTxt("Too many output arguments."); int level = nrhs; size_t numberOfValues = 0; size_t maxDimSize = 7; btk::MetaDataInfo::Format f = btk::MetaDataInfo::Char; std::vector<uint8_t> dims; mxArray* mxValues; if (mxIsStruct(prhs[nrhs-1])) { // Check the number of elements (must be one element) if (mxGetNumberOfElements(prhs[nrhs-1]) != 1) mexErrMsgTxt("Only accept structure with one element."); mxArray* temp; // Check for the field 'format' if ((temp = mxGetField(prhs[nrhs-1], 0, "format")) != NULL) { if (!mxIsChar(temp) || mxIsEmpty(temp)) mexErrMsgTxt("The field 'format' must be set by a non-empty string."); size_t strlen_ = (mxGetM(temp) * mxGetN(temp) * sizeof(mxChar)) + 1; char* format = (char*)mxMalloc(strlen_); mxGetString(temp, format, strlen_); std::string uppercase = std::string(format); mxFree(format); std::transform(uppercase.begin(), uppercase.end(), uppercase.begin(), toupper); if (uppercase.compare("CHAR") == 0) { f = btk::MetaDataInfo::Char; maxDimSize = 6; } else if(uppercase.compare("BYTE") == 0) f = btk::MetaDataInfo::Byte; else if(uppercase.compare("INTEGER") == 0) f = btk::MetaDataInfo::Integer; else if(uppercase.compare("REAL") == 0) f = btk::MetaDataInfo::Real; else mexErrMsgTxt("The field 'format' must be set by one of the following format: Char, Byte, Integer or Real"); } else mexErrMsgTxt("The structure doesn't contain the field 'format' to determine the type of data."); // Check for the field 'Values' if ((mxValues = mxGetField(prhs[nrhs-1], 0, "values")) != NULL) { if (!mxIsCell(mxValues) && ((mxGetClassID(mxValues) != mxDOUBLE_CLASS) || mxIsComplex(mxValues))) mexErrMsgTxt("The field 'format' must be set by cell of strings or an array of numerical (double) values."); numberOfValues = mxGetNumberOfElements(mxValues); if ((f != btk::MetaDataInfo::Char) && (numberOfValues > 65535)) mexErrMsgTxt("Number of values exceeds the maximum number (65535) available for each metadata."); mwSize dimsSize = mxGetNumberOfDimensions(mxValues); if (static_cast<size_t>(dimsSize) > maxDimSize) mexErrMsgTxt("Number of dimensions exceeds the maximum number (7) available for each metadata."); const mwSize* dimsValues = mxGetDimensions(mxValues); std::vector<uint8_t> _dims; for (int i = static_cast<int>(dimsSize - 1) ; i >= 0 ; --i) { int dim = static_cast<int>(dimsValues[i]); if (dim > 255) mexErrMsgTxt("The dimension's value exceeds the maximum number (255) available for each dimension."); if (dim != 1) _dims.push_back(static_cast<uint8_t>(dim)); } if (f == btk::MetaDataInfo::Char) _dims.push_back(0); dims.assign(_dims.rbegin(), _dims.rend()); } else mexErrMsgTxt("The structure doesn't contain the field 'values'."); // Check for the field 'numdims' if ((temp = mxGetField(prhs[nrhs-1], 0, "numdims")) != NULL) { if ((mxGetClassID(temp) != mxDOUBLE_CLASS) || mxIsEmpty(temp) || mxIsComplex(temp) || (mxGetNumberOfElements(temp) != 1)) mexErrMsgTxt("The field 'numdims' must be set by a single double representing an integer value."); size_t numDims = static_cast<size_t>(mxGetScalar(temp)); if (numDims < dims.size()) mexErrMsgTxt("The given number of dimensions is lower than the number of dimensions for the given values."); else if (numDims > maxDimSize) mexErrMsgTxt("The given number of dimensions exceeds the maximum number (7) available for each metadata."); dims.resize(numDims, 1); } level -= 1; } for (int i = 1 ; i < level ; ++i) { if (!mxIsChar(prhs[i]) || mxIsEmpty(prhs[i])) mexErrMsgTxt("Metadata's label must be set by a non-empty string."); } btk::Acquisition::Pointer acq = btk_MOH_get_object<btk::Acquisition>(prhs[0]); btk::MetaData::Pointer md = acq->GetMetaData(); for (int i = 1 ; i < level ; ++i) { size_t strlen_ = (mxGetM(prhs[i]) * mxGetN(prhs[i]) * sizeof(mxChar)) + 1; char* label = (char*)mxMalloc(strlen_); mxGetString(prhs[i], label, strlen_); btk::MetaData::ConstIterator it = md->FindChild(label); if (it == md->End()) { btk::MetaData::Pointer c = btk::MetaData::New(label); md->AppendChild(c); md = c; } else md = *it; mxFree(label); } if (level == (nrhs - 1)) { switch(f) { case btk::MetaDataInfo::Char: { std::vector<std::string> values = std::vector<std::string>(numberOfValues, ""); size_t maxLen = 0; for (int i = 0 ; i < static_cast<int>(numberOfValues) ; ++i) { mxArray* temp = mxGetCell(mxValues, i); if (!temp || !mxIsChar(temp)) mexErrMsgTxt("Error in the format of the values: only strings are accepted in cell."); size_t strlen_ = (mxGetM(temp) * mxGetN(temp) * sizeof(mxChar)) + 1; char* val = (char*)mxMalloc(strlen_); mxGetString(temp, val, strlen_); values[i] = std::string(val); mxFree(val); strlen_ = values[i].length(); if (strlen_ > maxLen) maxLen = strlen_; } dims[0] = static_cast<uint8_t>(maxLen); int prod = 1; for (size_t i = 0 ; i < dims.size() ; ++i) prod *= dims[i]; if (prod > 65535) mexErrMsgTxt("The number of characters exceed the maximum number (65535) available for a metadata."); md->SetInfo(btk::MetaDataInfo::New(dims, values)); break; } case btk::MetaDataInfo::Byte: { double* temp = mxGetPr(mxValues); std::vector<int8_t> values = std::vector<int8_t>(numberOfValues, 0); for (size_t i = 0 ; i < numberOfValues ; ++i) values[i] = static_cast<int8_t>(temp[i]); md->SetInfo(btk::MetaDataInfo::New(dims, values)); break; } case btk::MetaDataInfo::Integer: { double* temp = mxGetPr(mxValues); std::vector<int16_t> values = std::vector<int16_t>(numberOfValues, 0); for (size_t i = 0 ; i < numberOfValues ; ++i) values[i] = static_cast<int16_t>(temp[i]); md->SetInfo(btk::MetaDataInfo::New(dims, values)); break; } case btk::MetaDataInfo::Real: { double* temp = mxGetPr(mxValues); std::vector<float> values = std::vector<float>(numberOfValues, 0); for (size_t i = 0 ; i < numberOfValues ; ++i) values[i] = static_cast<float>(temp[i]); md->SetInfo(btk::MetaDataInfo::New(dims, values)); break; } } } plhs[0] = btkMXCreateMetaDataStructure(acq->GetMetaData()); };
unsigned int sf_adcs_v15_integral_Power_no_charge_in_detumb_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)(4060032410U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2149457384U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(220542832U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3168113298U); } 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)(2457863733U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1394616720U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2967142384U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(4067375986U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c1_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 2: { extern void sf_c2_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c2_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 4: { extern void sf_c4_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c4_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 5: { extern void sf_c5_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c5_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 6: { extern void sf_c6_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c6_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 7: { extern void sf_c7_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c7_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 8: { extern void sf_c8_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c8_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 9: { extern void sf_c9_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c9_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 10: { extern void sf_c10_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c10_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 11: { extern void sf_c11_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c11_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 12: { extern void sf_c12_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c12_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 13: { extern void sf_c13_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c13_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 16: { extern void sf_c16_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c16_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 19: { extern void sf_c19_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c19_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 20: { extern void sf_c20_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c20_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 22: { extern void sf_c22_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c22_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 23: { extern void sf_c23_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c23_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 24: { extern void sf_c24_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c24_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 25: { extern void sf_c25_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c25_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 26: { extern void sf_c26_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c26_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 27: { extern void sf_c27_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c27_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 28: { extern void sf_c28_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c28_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 29: { extern void sf_c29_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c29_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 30: { extern void sf_c30_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c30_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum(plhs); break; } case 31: { extern void sf_c31_adcs_v15_integral_Power_no_charge_in_detumb_get_check_sum (mxArray *plhs[]); sf_c31_adcs_v15_integral_Power_no_charge_in_detumb_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)(2364224360U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1521043920U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3255461816U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(789461005U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(2416251650U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1161514731U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(4004375365U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2849367992U); } return 1; #else return 0; #endif }
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] ) { int i, j; double *c=NULL, *b=NULL, *A=NULL, *H=NULL, *l=NULL, *u=NULL, *x=NULL, *lambda=NULL ; int *nzA=NULL, *nzH=NULL ; int *iA=NULL, *kA=NULL ; int *iH=NULL, *kH=NULL ; #ifndef MX_COMPAT_32 long *iA_=NULL, *kA_=NULL ; long *iH_=NULL, *kH_=NULL ; #endif int neq=0, m=0, n=0, display=0; long *cpenv=NULL, *p_qp=NULL; char *Sense=NULL ; CPXENVptr env = NULL; CPXLPptr qp = NULL; int status, qpstat; double objval; double * p_qpstat ; char opt_method[128]="auto" ; if (nrhs > 10 || nrhs < 1) { mexErrMsgTxt("Usage: [x,lambda,how,p_qp] " "= qp_solve(cpenv,Q,c,A,b,l,u,neq,disp,method)"); return; } switch (nrhs) { case 10: if (mxGetM(prhs[9]) != 0 || mxGetN(prhs[9]) != 0) { if (mxIsNumeric(prhs[9]) || mxIsComplex(prhs[9]) || !mxIsChar(prhs[9]) || mxIsSparse(prhs[9]) || !(mxGetM(prhs[9])==1 && mxGetN(prhs[9])>=1)) { mexErrMsgTxt("10th argument (method) must be " "a string."); return; } mxGetString(prhs[9], opt_method, 128) ; } case 9: if (mxGetM(prhs[8]) != 0 || mxGetN(prhs[8]) != 0) { if (!mxIsNumeric(prhs[8]) || mxIsComplex(prhs[8]) || mxIsSparse(prhs[8]) || !(mxGetM(prhs[8])==1 && mxGetN(prhs[8])==1)) { mexErrMsgTxt("9th argument (display) must be " "an integer scalar."); return; } display = *mxGetPr(prhs[8]); } case 8: if (mxGetM(prhs[7]) != 0 || mxGetN(prhs[7]) != 0) { if (!mxIsNumeric(prhs[7]) || mxIsComplex(prhs[7]) || mxIsSparse(prhs[7]) || !(mxGetM(prhs[7])==1 && mxGetN(prhs[7])==1)) { mexErrMsgTxt("8th argument (neqcstr) must be " "an integer scalar."); return; } neq = *mxGetPr(prhs[7]); } case 7: if (mxGetM(prhs[6]) != 0 || mxGetN(prhs[6]) != 0) { if (!mxIsNumeric(prhs[6]) || mxIsComplex(prhs[6]) || mxIsSparse(prhs[6]) || !mxIsDouble(prhs[6]) || mxGetN(prhs[6])!=1 ) { mexErrMsgTxt("7th argument (u) must be " "a column vector."); return; } u = mxGetPr(prhs[6]); n = mxGetM(prhs[6]); } case 6: if (mxGetM(prhs[5]) != 0 || mxGetN(prhs[5]) != 0) { if (!mxIsNumeric(prhs[5]) || mxIsComplex(prhs[5]) || mxIsSparse(prhs[5]) || !mxIsDouble(prhs[5]) || mxGetN(prhs[5])!=1 ) { mexErrMsgTxt("6th argument (l) must be " "a column vector."); return; } if (n != 0 && n != mxGetM(prhs[5])) { mexErrMsgTxt("Dimension error (arg 6 and later)."); return; } l = mxGetPr(prhs[5]); n = mxGetM(prhs[5]); } case 5: if (mxGetM(prhs[4]) != 0 || mxGetN(prhs[4]) != 0) { if (!mxIsNumeric(prhs[4]) || mxIsComplex(prhs[4]) || mxIsSparse(prhs[4]) || !mxIsDouble(prhs[4]) || mxGetN(prhs[4])!=1 ) { mexErrMsgTxt("5th argument (b) must be " "a column vector."); return; } if (m != 0 && m != mxGetM(prhs[4])) { mexErrMsgTxt("Dimension error (arg 5 and later)."); return; } b = mxGetPr(prhs[4]); m = mxGetM(prhs[4]); } case 4: if (mxGetM(prhs[3]) != 0 || mxGetN(prhs[3]) != 0) { if (!mxIsNumeric(prhs[3]) || mxIsComplex(prhs[3]) || !mxIsSparse(prhs[3]) ) { mexErrMsgTxt("4th argument (A) must be " "a sparse matrix."); return; } if (m != 0 && m != mxGetM(prhs[3])) { mexErrMsgTxt("Dimension error (arg 4 and later)."); return; } if (n != 0 && n != mxGetN(prhs[3])) { mexErrMsgTxt("Dimension error (arg 4 and later)."); return; } m = mxGetM(prhs[3]); n = mxGetN(prhs[3]); A = mxGetPr(prhs[3]); #ifdef MX_COMPAT_32 iA = mxGetIr(prhs[3]); kA = mxGetJc(prhs[3]); #else iA_ = mxGetIr(prhs[3]); kA_ = mxGetJc(prhs[3]); iA = (int*)malloc(mxGetNzmax(prhs[3])*sizeof(int)) ; for (i=0; i<mxGetNzmax(prhs[3]); i++) iA[i]=iA_[i] ; kA = (int*)malloc((n+1)*sizeof(int)) ; for (i=0; i<n+1; i++) kA[i]=kA_[i] ; #endif nzA=myMalloc(n*sizeof(int)) ; for (i=0; i<n; i++) nzA[i]=kA[i+1]-kA[i] ; Sense=myMalloc((m+1)*sizeof(char)) ; for (i=0; i<m; i++) if (i<neq) Sense[i]='E' ; else Sense[i]='L' ; Sense[m]=0 ; } case 3: if (mxGetM(prhs[2]) != 0 || mxGetN(prhs[2]) != 0) { if (!mxIsNumeric(prhs[2]) || mxIsComplex(prhs[2]) || mxIsSparse(prhs[2]) || !mxIsDouble(prhs[2]) || mxGetN(prhs[2])!=1 ) { mexErrMsgTxt("3rd argument (c) must be " "a column vector."); return; } if (n != 0 && n != mxGetM(prhs[2])) { mexErrMsgTxt("Dimension error (arg 3 and later)."); return; } c = mxGetPr(prhs[2]); n = mxGetM(prhs[2]); } case 2: if (mxGetM(prhs[1]) != 0 || mxGetN(prhs[1]) != 0) { if (!mxIsNumeric(prhs[1]) || mxIsComplex(prhs[1]) || !mxIsSparse(prhs[1]) ) { mexErrMsgTxt("2nd argument (H) must be " "a sparse matrix."); return; } if (n != 0 && n != mxGetM(prhs[1])) { mexErrMsgTxt("Dimension error (arg 2 and later)."); return; } if (n != 0 && n != mxGetN(prhs[1])) { mexErrMsgTxt("Dimension error (arg 2 and later)."); return; } n = mxGetN(prhs[1]); H = mxGetPr(prhs[1]); #ifdef MX_COMPAT_32 iH = mxGetIr(prhs[1]); kH = mxGetJc(prhs[1]); #else iH_ = mxGetIr(prhs[1]); kH_ = mxGetJc(prhs[1]); iH = (int*)malloc(mxGetNzmax(prhs[1])*sizeof(int)) ; for (i=0; i<mxGetNzmax(prhs[1]); i++) iH[i]=iH_[i] ; kH = (int*)malloc((n+1)*sizeof(int)) ; for (i=0; i<n+1; i++) kH[i]=kH_[i] ; #endif nzH=myMalloc(n*sizeof(int)) ; for (i=0; i<n; i++) nzH[i]=kH[i+1]-kH[i] ; } case 1: if (mxGetM(prhs[0]) != 0 || mxGetN(prhs[0]) != 0) { if (!mxIsNumeric(prhs[0]) || mxIsComplex(prhs[0]) || mxIsSparse(prhs[0]) || !mxIsDouble(prhs[0]) || mxGetN(prhs[0])!=1 ) { mexErrMsgTxt("1st argument (cpenv) must be " "a column vector."); return; } if (1 != mxGetM(prhs[0])) { mexErrMsgTxt("Dimension error (arg 1)."); return; } cpenv = (long*) mxGetPr(prhs[0]); } } /*if (display>3) */ fprintf(STD_OUT,"argument processing finished") ; /* Initialize the CPLEX environment */ env = (CPXENVptr) cpenv[0] ; /* Turn on output to the screen */ if (display>0) status = CPXsetintparam (env, CPX_PARAM_SCRIND, CPX_ON); else status = CPXsetintparam (env, CPX_PARAM_SCRIND, CPX_OFF); if ( status ) { fprintf (STD_OUT, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } status = CPXsetintparam (env, CPX_PARAM_SIMDISPLAY, display); if ( status ) { fprintf (STD_OUT,"Failed to turn up simplex display level.\n"); goto TERMINATE; } if (nlhs > 4 || nlhs < 1) { mexErrMsgTxt("Usage: [x,lambda,how,p_qp] " "= qp_solve(cpenv,H,c,A,b,l,u,neqcstr)"); return; } if (display>3) fprintf(STD_OUT, "(m=%i, n=%i, neq=%i) \n", m, n, neq) ; switch (nlhs) { case 4: plhs[3] = mxCreateDoubleMatrix(1, 1, mxREAL); p_qp = (long*) mxGetPr(plhs[3]); case 3: /* plhs[2] = mxCreateDoubleMatrix(1, 1, mxREAL); p_qpstat = mxGetPr(plhs[2]);*/ case 2: plhs[1] = mxCreateDoubleMatrix(m, 1, mxREAL); lambda = mxGetPr(plhs[1]); case 1: plhs[0] = mxCreateDoubleMatrix(n, 1, mxREAL); x = mxGetPr(plhs[0]); break; } if (display>2) fprintf(STD_OUT, "argument processing finished\n") ; if (strcmp(opt_method, "primal") && strcmp(opt_method, "dual") && strcmp(opt_method, "net") && strcmp(opt_method, "bar") && strcmp(opt_method, "sift") && strcmp(opt_method, "con") && strcmp(opt_method, "auto")) mexErrMsgTxt("method \\in " "{'auto','primal','dual','bar','net','sift','con'}\n") ; if (strcmp(opt_method, "primal")==0) status = CPXsetintparam (env, CPX_PARAM_QPMETHOD, 1); else if (strcmp(opt_method, "dual")==0) status = CPXsetintparam (env, CPX_PARAM_QPMETHOD, 2); else if (strcmp(opt_method, "net")==0) status = CPXsetintparam (env, CPX_PARAM_QPMETHOD, 3); else if (strcmp(opt_method, "bar")==0) status = CPXsetintparam (env, CPX_PARAM_QPMETHOD, 4); else if (strcmp(opt_method, "sift")==0) status = CPXsetintparam (env, CPX_PARAM_QPMETHOD, 5); else if (strcmp(opt_method, "con")==0) status = CPXsetintparam (env, CPX_PARAM_QPMETHOD, 6); else if (strcmp(opt_method, "auto")==0) status = CPXsetintparam (env, CPX_PARAM_QPMETHOD, 0); else status = 1 ; if ( status ) { fprintf (STD_OUT,"Failed to set QP method.\n"); goto TERMINATE; } /* Create the problem */ if (display>2) fprintf(STD_OUT, "calling CPXcreateprob \n") ; qp = CPXcreateprob (env, &status, "xxx"); if ( qp == NULL ) { fprintf (STD_OUT,"Failed to create subproblem\n"); status = 1; goto TERMINATE; } if (p_qp) *p_qp=(long) qp ; /* Copy network part of problem. */ /*if (display>2) */ fprintf(STD_OUT, "calling CPXcopylp (m=%i, n=%i) \n", m, n) ; status = CPXcopylp(env, qp, n, m, CPX_MIN, c, b, Sense, kA, nzA, iA, A, l, u, NULL); if ( status ) { fprintf (STD_OUT, "CPXcopylp failed.\n"); goto TERMINATE; } /*if (display>2) */ fprintf(STD_OUT, "calling CPXcopyquad \n") ; status = CPXcopyquad (env, qp, kH, nzH, iH, H); if ( status ) { fprintf (STD_OUT, "CPXcopyquad failed.\n"); goto TERMINATE; } /*if (display>2) */ fprintf(STD_OUT, "calling optimizer 'bar'\n") ; status = CPXqpopt (env, qp); if (display>3) fprintf(STD_OUT, "CPXbaropt=%i\n", status) ; if ( status ) { fprintf (STD_OUT,"CPXbaropt failed.\n"); goto TERMINATE; } if (display>2) fprintf(STD_OUT, "calling CPXsolution\n") ; status = CPXsolution (env, qp, &qpstat, &objval, x, lambda, NULL, NULL); if ( status ) { fprintf (STD_OUT,"CPXsolution failed.\n"); goto TERMINATE; } if (display>1) fprintf (STD_OUT, "Solution status: %i,%s\n", qpstat, err_str[qpstat]); if (display>2) fprintf (STD_OUT, "Objective value %g\n", objval); if (nlhs >= 3) if (qpstat==1) plhs[2] = mxCreateString(err_str[0]) ; else plhs[2] = mxCreateString(err_str[qpstat]) ; /* if (nlhs >= 3) if (qpstat==1) *p_qpstat = 0 ; else *p_qpstat = qpstat ;*/ TERMINATE: if (status) { char errmsg[1024]; CPXgeterrorstring (env, status, errmsg); fprintf (STD_OUT, "%s", errmsg); if (nlhs >= 3) plhs[2] = mxCreateString(errmsg) ; } ; if (nzA) myFree(nzA) ; if (nzH) myFree(nzH) ; if (Sense) myFree(Sense) ; #ifndef MX_COMPAT_32 if (iA) myFree(iA) ; if (kA) myFree(kA) ; if (iH) myFree(iH) ; if (kH) myFree(kH) ; #endif if (!p_qp) { if ( qp != NULL ) { if (display>2) fprintf(STD_OUT, "calling CPXfreeprob\n") ; status = CPXfreeprob (env, &qp); if ( status ) { fprintf (STD_OUT, "CPXfreeprob failed, error code %d.\n", status); } } } return ; }
unsigned int sf_adcs_v15_integral_Power_no_charge_in_detumb_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_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c1_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 2: { extern const mxArray *sf_c2_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c2_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 4: { extern const mxArray *sf_c4_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c4_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 5: { extern const mxArray *sf_c5_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c5_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 6: { extern const mxArray *sf_c6_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c6_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 7: { extern const mxArray *sf_c7_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c7_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 8: { extern const mxArray *sf_c8_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c8_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 9: { extern const mxArray *sf_c9_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c9_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 10: { extern const mxArray *sf_c10_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c10_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 11: { extern const mxArray *sf_c11_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c11_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 12: { extern const mxArray *sf_c12_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c12_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 13: { extern const mxArray *sf_c13_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c13_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 16: { extern const mxArray *sf_c16_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c16_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 19: { extern const mxArray *sf_c19_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c19_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 20: { extern const mxArray *sf_c20_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c20_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 22: { extern const mxArray *sf_c22_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c22_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 23: { extern const mxArray *sf_c23_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c23_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 24: { extern const mxArray *sf_c24_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c24_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 25: { extern const mxArray *sf_c25_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c25_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 26: { extern const mxArray *sf_c26_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c26_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 27: { extern const mxArray *sf_c27_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c27_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 28: { extern const mxArray *sf_c28_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c28_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 29: { extern const mxArray *sf_c29_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c29_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 30: { extern const mxArray *sf_c30_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c30_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 31: { extern const mxArray *sf_c31_adcs_v15_integral_Power_no_charge_in_detumb_get_eml_resolved_functions_info (void); mxArray *persistentMxArray = (mxArray *) sf_c31_adcs_v15_integral_Power_no_charge_in_detumb_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 }
/* --- GATEWAY FUNCTION --- */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { double *img = NULL, *distmap = NULL, *vor = NULL; double *voxsize = NULL, *seeds = NULL; mwSize size[3], nbseeds, sdist; char *dist = NULL; mxArray *dmap = NULL, *vord = NULL; /* Check for proper number of arguments. */ if (nrhs < 2) mexErrMsgTxt("Not enough input arguments."); else if (nrhs > 3) mexErrMsgTxt("Too many input arguments."); else if (nlhs > 2) mexErrMsgTxt("Too many output arguments."); /* The input IMG must be a real double array. */ if (!mxIsDouble(prhs[0]) || mxIsComplex(prhs[0]) || !(mxGetNumberOfDimensions(prhs[0])==2 || mxGetNumberOfDimensions(prhs[0])==3)) mexErrMsgTxt("Input img must be a real double array."); size[0] = mxGetDimensions(prhs[0])[0]; size[1] = mxGetDimensions(prhs[0])[1]; if (mxGetNumberOfDimensions(prhs[0])==3) size[2] = mxGetDimensions(prhs[0])[2]; else size[2] = 1; img = mxGetPr(prhs[0]); /* The input SEEDS must be a real double array [n x 3] */ if (!mxIsDouble(prhs[1]) || mxIsComplex(prhs[1]) || mxGetNumberOfDimensions(prhs[1]) != 2 || mxGetDimensions(prhs[1])[1] != 3) mexErrMsgTxt("Input seeds must be a real double array [n x 3]."); seeds = mxGetPr(prhs[1]); nbseeds = mxGetDimensions(prhs[1])[0]; /* The input DIST must be a string */ if (nrhs > 2) { if (!mxIsChar(prhs[2])) mexErrMsgTxt("Input dist must be a string."); sdist = (mxGetM(prhs[2]) * mxGetN(prhs[2])) + 1; dist = mxCalloc(sdist, sizeof(char)); mxGetString(prhs[2], dist, sdist); } else { dist = "d34"; } /* The input VOXSIZE must be a [x y z] array */ if (nrhs > 3) { if (!mxIsDouble(prhs[3]) || mxIsComplex(prhs[3]) || mxGetNumberOfElements(prhs[3])!=3) mexErrMsgTxt("Input voxsize must be a 3 elements vector."); voxsize = mxGetPr(prhs[3]); } else { voxsize = mxMalloc(3*sizeof(double)); voxsize[0] = voxsize[1] = voxsize[2] = 1.0; } /* Create mxArray's */ dmap = mxCreateNumericArray(3, size, mxDOUBLE_CLASS, mxREAL); distmap = mxGetPr(dmap); vord = mxCreateNumericArray(3, size, mxDOUBLE_CLASS, mxREAL); vor = mxGetPr(vord); /* Call the Geodesic Voronoi subroutine. */ geodesic_voronoi(img, size, voxsize, seeds, nbseeds, vor, distmap, dist); /* Assign pointers to output */ if (nlhs > 0) plhs[0] = vord; else mxDestroyArray(vord); if (nlhs > 1) plhs[1] = dmap; else mxDestroyArray(dmap); /* Free memory */ if (nrhs < 4) mxFree(voxsize); }
// Function definitions. // ----------------------------------------------------------------- void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { //Input Args user_function_data fun, grad; iter_fun_data iterF; double *x0, *lb, *ub; //Options int printLevel = 0, maxIter = 1000, nupdate = 5, maxFeval = 1500; double ftol = 1e-7, pgtol = 1e-5, maxtime = 1000; iterF.enabled = false; //Outputs Args double *x, *fval, *exitflag, *iter, *feval; //Internal Vars size_t ndec; int iiter, nfeval; if (nrhs < 1) { if(nlhs < 1) printSolverInfo(); else plhs[0] = mxCreateString(LBFGSB_VERSION); return; } //Check user inputs checkInputs(prhs,nrhs); try { //Get Size ndec = mxGetNumberOfElements(prhs[4]); //Get Function Handles if (mxIsChar(prhs[0])) { CHECK(mxGetString(prhs[0], fun.f, FLEN) == 0,"error reading objective name string"); fun.nrhs = 1; fun.xrhs = 0; } else { fun.prhs[0] = (mxArray*)prhs[0]; strcpy(fun.f, "feval"); fun.nrhs = 2; fun.xrhs = 1; } if (mxIsChar(prhs[1])) { CHECK(mxGetString(prhs[1], grad.f, FLEN) == 0,"error reading gradient name string"); grad.nrhs = 1; grad.xrhs = 0; } else { grad.prhs[0] = (mxArray*)prhs[1]; strcpy(grad.f, "feval"); grad.nrhs = 2; grad.xrhs = 1; } fun.prhs[fun.xrhs] = mxCreateDoubleMatrix(ndec, 1, mxREAL); //x0 grad.prhs[grad.xrhs] = mxCreateDoubleMatrix(ndec, 1, mxREAL); //Get Bounds + x0 lb = mxGetPr(prhs[2]); ub = mxGetPr(prhs[3]); x0 = mxGetPr(prhs[4]); //Get Options if specified if(nrhs > 5) { GetIntegerOption(prhs[5], "display", &printLevel); GetIntegerOption(prhs[5], "maxiter", &maxIter); GetIntegerOption(prhs[5], "maxfeval", &maxFeval); GetIntegerOption(prhs[5], "nupdate", &nupdate); GetDoubleOption(prhs[5], "tolrfun", &ftol); GetDoubleOption(prhs[5], "tolrfun", &ftol); GetDoubleOption(prhs[5], "pgtol", &pgtol); GetDoubleOption(prhs[5], "maxtime", &maxtime); if(mxGetField(prhs[5],0,"iterfun") && !mxIsEmpty(mxGetField(prhs[5],0,"iterfun"))) { iterF.prhs[0] = (mxArray*)mxGetField(prhs[5],0,"iterfun"); strcpy(iterF.f, "feval"); iterF.enabled = true; iterF.prhs[1] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL); iterF.prhs[2] = mxCreateDoubleMatrix(1,1,mxREAL); iterF.prhs[3] = mxCreateDoubleMatrix(ndec,1,mxREAL); } } //Create Outputs plhs[0] = mxCreateDoubleMatrix(ndec,1, mxREAL); plhs[1] = mxCreateDoubleMatrix(1,1, mxREAL); plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL); plhs[3] = mxCreateDoubleMatrix(1,1, mxREAL); plhs[4] = mxCreateDoubleMatrix(1,1, mxREAL); x = mxGetPr(plhs[0]); fval = mxGetPr(plhs[1]); exitflag = mxGetPr(plhs[2]); iter = mxGetPr(plhs[3]); feval = mxGetPr(plhs[4]); //Create Class for Peter's L-BFGS-B Interface lbfgsb_program solver(&fun,&grad,&iterF,ndec,lb,ub,x0,x,fval,iter,printLevel,maxIter,maxFeval,maxtime,ftol,nupdate,pgtol); //Run the Solver int exitStatus = solver.runSolver(iiter,nfeval,*fval); //Save Status & Iterations *exitflag = (double)exitStatus; *iter = (double)iiter; *feval = (double)nfeval; } catch (std::exception& error) { mexErrMsgTxt(error.what()); } }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { size_t buflen; int nwhisk; char *filename; Whisker_Seg *ws; set_reporter(mxreport); /* check for proper number of arguments */ if(nrhs!=1) mexErrMsgTxt("One input required."); else if(nlhs > 2) mexErrMsgTxt("Too many output arguments."); /* input must be a string */ if ( mxIsChar(prhs[0]) != 1) mexErrMsgTxt("Input must be a string."); /* get the length of the input string */ buflen = (mxGetM(prhs[0]) * mxGetN(prhs[0])) + 1; /* copy the string data from prhs[0] into a C string input_ buf. * */ filename = mxArrayToString(prhs[0]); if(filename == NULL) mexErrMsgTxt("Could not convert input to string."); //mexPrintf("Got %s\n",filename); ws = Load_Whiskers(filename,NULL,&nwhisk); if(!ws) mexErrMsgTxt("Could not load whiskers.\n"); if(nlhs==0) goto Done; if(nlhs==2) { char *format=NULL; if( Whisker_File_Autodetect(filename,&format)==-1 ) goto AutodetectException; plhs[1] = mxCreateString(format); if(!plhs[1]) goto AllocateFormatStringException; } { const char *fields[] = {"id","time","x","y","thick","scores"}; plhs[0] = mxCreateStructMatrix( nwhisk , 1 , sizeof(fields)/sizeof(char*) , fields); if(!plhs[0]) { Free_Whisker_Seg_Vec(ws,nwhisk); mexPrintf("Allocating struct array for %d whiskers.\n",nwhisk); mexErrMsgTxt("Allocation failed.\n"); } } { int i; for(i=0;i<nwhisk;++i) { mxArray *id,*time,*x,*y,*thick,*scores; int *pid,*ptime; float *px, *py, *pthick, *pscores; int n; n = ws[i].len; id = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL); time = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL); x = mxCreateNumericMatrix(n,1,mxSINGLE_CLASS,mxREAL); y = mxCreateNumericMatrix(n,1,mxSINGLE_CLASS,mxREAL); thick = mxCreateNumericMatrix(n,1,mxSINGLE_CLASS,mxREAL); scores = mxCreateNumericMatrix(n,1,mxSINGLE_CLASS,mxREAL); if(!(id && time && x && y && thick && scores)) { Free_Whisker_Seg_Vec(ws,nwhisk); mexPrintf("Allocating space for whisker #%d (%d points).\n", i, ws[i].len); mexErrMsgTxt("Allocation failed.\n"); return; } mxSetFieldByNumber(plhs[0],i,0,id); mxSetFieldByNumber(plhs[0],i,1,time); mxSetFieldByNumber(plhs[0],i,2,x); mxSetFieldByNumber(plhs[0],i,3,y); mxSetFieldByNumber(plhs[0],i,4,thick); mxSetFieldByNumber(plhs[0],i,5,scores); pid = (int*) mxGetData(id); *pid = ws[i].id; ptime = (int*) mxGetData(time); *ptime = ws[i].time; memcpy(mxGetData(x),ws[i].x,n*sizeof(float)); memcpy(mxGetData(y),ws[i].y,n*sizeof(float)); memcpy(mxGetData(thick),ws[i].thick,n*sizeof(float)); memcpy(mxGetData(scores),ws[i].scores,n*sizeof(float)); } } Done: Free_Whisker_Seg_Vec(ws,nwhisk); return; AutodetectException: Free_Whisker_Seg_Vec(ws,nwhisk); mexErrMsgTxt("Could not autodetect file format.\n"); AllocateFormatStringException: Free_Whisker_Seg_Vec(ws,nwhisk); mexErrMsgTxt("Allocation failed for format string.\n"); }
void mexFunction (int nlhs, mxArray * plhs[], int nrhs, const mxArray * prhs[]) { type_TFR first_TFR, second_TFR; double coef, *dist; int dist_name_length; int N_time, N_freq, dist_name; char *dist_name_string; if ((nrhs < 3) || (nrhs > 4)) mexErrMsgTxt ("Dist=Ctfrdist(TFR1,TFR2,distance_name,distance_coef)"); /* Recovery of TFRs */ first_TFR.real_part = mxGetPr (TFR1); second_TFR.real_part = mxGetPr (TFR2); first_TFR.is_complex = FALSE; second_TFR.is_complex = FALSE; /* TFRs dimensions recovery */ first_TFR.N_time = mxGetM (TFR1); first_TFR.N_freq = mxGetN (TFR1); second_TFR.N_time = mxGetM (TFR2); second_TFR.N_freq = mxGetN (TFR2); if ((first_TFR.N_time != second_TFR.N_time) || (first_TFR.N_freq != second_TFR.N_freq)) mexErrMsgTxt ("Time frequency matrices must be the same size"); /* recovery of the ditance name */ if(!mxIsChar(DIST_NAME)) mexErrMsgTxt("Variable distance_name must contain a string.\n"); dist_name_length = mxGetN(DIST_NAME)+1; dist_name_string = (char *) ALLOC (dist_name_length,sizeof(char)); mxGetString(DIST_NAME,dist_name_string,dist_name_length); /* distance name recovery */ dist_name = 0; if((!(strcmp(dist_name_string,"Lq"))) || (!(strcmp(dist_name_string,"LQ"))) || (!(strcmp(dist_name_string,"lq")))) { dist_name = LQ; } if((!(strcmp(dist_name_string,"Quadratic"))) || (!(strcmp(dist_name_string,"QUADRATIC"))) || (!(strcmp(dist_name_string,"quadratic")))) { dist_name = QUADRATIC; } if((!(strcmp(dist_name_string,"Correlation"))) || (!(strcmp(dist_name_string,"CORRELATION"))) || (!(strcmp(dist_name_string,"correlation")))) { dist_name = CORRELATION; } if((!(strcmp(dist_name_string,"Kolmogorov"))) || (!(strcmp(dist_name_string,"KOLMOGOROV"))) || (!(strcmp(dist_name_string,"kolmogorov")))) { dist_name = KOLMOGOROV; } if((!(strcmp(dist_name_string,"Kullback"))) || (!(strcmp(dist_name_string,"KULLBACK"))) || (!(strcmp(dist_name_string,"kullback")))) { dist_name = KULLBACK; } if((!(strcmp(dist_name_string,"Chernoff"))) || (!(strcmp(dist_name_string,"CHERNOFF"))) || (!(strcmp(dist_name_string,"chernoff")))) { dist_name = CHERNOFF; } if((!(strcmp(dist_name_string,"Matusita"))) || (!(strcmp(dist_name_string,"MATUSITA"))) || (!(strcmp(dist_name_string,"matusita")))) { dist_name = MATUSITA; } if((!(strcmp(dist_name_string,"NLq"))) || (!(strcmp(dist_name_string,"NLQ"))) || (!(strcmp(dist_name_string,"nlq")))) { dist_name = NLQ; } if((!(strcmp(dist_name_string,"Lsd"))) || (!(strcmp(dist_name_string,"LSD"))) || (!(strcmp(dist_name_string,"lsd")))) { dist_name = LSD; } if((!(strcmp(dist_name_string,"Jensen"))) || (!(strcmp(dist_name_string,"JENSEN"))) || (!(strcmp(dist_name_string,"jensen")))) { dist_name = JENSEN; } if (dist_name == 0) { mexErrMsgTxt ("Unknown distance name"); } /* some tests about the distence coef */ /* to have or not to have a coefficient ? */ if ((dist_name == LQ) || (dist_name == CHERNOFF) || (dist_name == MATUSITA) ||(dist_name == NLQ) || (dist_name == LSD) || (dist_name == JENSEN)) { if (nrhs == 3) /* cases where there should be a coef given */ { mexErrMsgTxt ("A coefficient is required for this distance"); } } /* Distance coefficient recovery */ if (nrhs == 4) { coef = mxGetScalar (DIST_COEF); } else { coef = 1.0; } /* Error cases */ if ((dist_name == LQ) && (coef <= 0)) mexErrMsgTxt ("distance_coef > 0 for Lq distance"); if ((dist_name == CHERNOFF) && ((coef > 1) || (coef < 0))) mexErrMsgTxt ("0 <= distance_coef <= 1 for Chernoff distance"); if ((dist_name == MATUSITA) && (coef < 1)) mexErrMsgTxt ("distance_coef >= 1 for Generalized Matusita distance"); if ((dist_name == NLQ) && (coef <= 0)) mexErrMsgTxt ("distance_coef > 0 for Normalized Lq distance"); if ((dist_name == LSD) && (coef <= 0)) mexErrMsgTxt ("distance_coef > 0 for q-Log Spectral Deviation"); if ((dist_name == JENSEN) && (coef <= 0)) mexErrMsgTxt ("distance_coefq > 0 for q-Jensen divergence"); if ((dist_name != LQ) && (dist_name != QUADRATIC) && (dist_name != CORRELATION) && (dist_name != KOLMOGOROV) && (dist_name != KULLBACK) && (dist_name != CHERNOFF) && (dist_name != MATUSITA) && (dist_name != NLQ) && (dist_name != LSD) && (dist_name != JENSEN)) mexErrMsgTxt ("Bad distance identification number"); /* Creation of the output variable */ DISTANCE_OUT = mxCreateDoubleMatrix (1, 1, mxREAL); /* pointer on the results dist */ dist = mxGetPr (DISTANCE_OUT); /* computation of the distance */ distance (first_TFR, second_TFR, dist_name, coef, dist); FREE (dist_name_string); }
/* decide in which of the three modes we are, and do some * input argument checking. */ void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* first check for execution path 7 and 8 */ if(mxIsChar(prhs[0]) && 0 == compareString(prhs[0], "close")) { /* The user wants to close the connection */ if(0 == nlhs) { /* no output arguments */ /* Check if we have an open connection */ if(0 == connected) { mexWarnMsgTxt("bbci_acquire_bv: no open connection to close!"); return; } else { abv_close(); return; } } else { mexErrMsgTxt("bbci_acquire_bv: no output arguments on close connection."); } } /* check for execution path 1 and 2 */ if(1 <= nrhs && mxIsChar(prhs[0]) && 0 == compareString(prhs[0], "init")) { bool isStructInit = 2 == nrhs && mxIsStruct(prhs[1]); // check if we have path 1 if(!isStructInit) { // if we have no struct init check if it is a property list bool isListInit = 0 == (nrhs - 1) % 2; // number of elements in the list must be a divisor of 2 for(int i = 1; isStructInit && i < nrhs; i = i + 2) { // check if each second value in the list is a string isStructInit = isStructInit & mxIsChar(prhs[i]); } if(!isListInit) { // no valid init found mexErrMsgTxt("bbci_acquire_bv: init is only allowed with a struct or a property list as an argument."); } } if(1 == nlhs) { /* one output argument */ if(0 != connected) { mexErrMsgTxt("bbci_acquire_bv: close the connection first!"); } else { abv_init(nlhs, plhs, nrhs, prhs, isStructInit); return; } } else { mexErrMsgTxt("bbci_acquire_bv: only one output for a create connection."); } } /* check if we are in execution path 3 to 6 */ abv_assert(4 >= nlhs, "bbci_acquire_bv: Four ouput arguments are maximum."); abv_assert(nrhs == 1, "bbci_acquire_bv: exactly one input argument required"); abv_assert(mxIsStruct(prhs[0]), "bbci_acquire_bv: input argument must be struct"); /* check if we are connect to the server */ if(0 != connected) { abv_getdata(nlhs, plhs, nrhs, prhs); } else { mexErrMsgTxt("bbci_acquire_bv: open a connection first!"); } }
unsigned int sf_InverseDynamics_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, "EROkReCRXJCOIBLHD7YM8C") == 0) { extern mxArray *sf_c1_InverseDynamics_get_autoinheritance_info(void); plhs[0] = sf_c1_InverseDynamics_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 2: { if (strcmp(aiChksum, "EROkReCRXJCOIBLHD7YM8C") == 0) { extern mxArray *sf_c2_InverseDynamics_get_autoinheritance_info(void); plhs[0] = sf_c2_InverseDynamics_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 3: { if (strcmp(aiChksum, "dldOEgf5GZzKRtb40lcEtF") == 0) { extern mxArray *sf_c3_InverseDynamics_get_autoinheritance_info(void); plhs[0] = sf_c3_InverseDynamics_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }
unsigned int sf_zeppelin_model_7_test_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)(4258463466U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1008436462U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1569765484U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(1601912599U); } 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)(309314295U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3831742187U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(990842318U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3328659419U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 2: { extern void sf_c2_zeppelin_model_7_test_get_check_sum(mxArray *plhs[]); sf_c2_zeppelin_model_7_test_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)(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)(3837414856U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2620181977U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2770470462U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(114243421U); } return 1; #else return 0; #endif }
unsigned int sf_InverseDynamics_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_InverseDynamics_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c1_InverseDynamics_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 2: { extern const mxArray *sf_c2_InverseDynamics_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c2_InverseDynamics_get_eml_resolved_functions_info(); plhs[0] = mxDuplicateArray(persistentMxArray); mxDestroyArray(persistentMxArray); break; } case 3: { extern const mxArray *sf_c3_InverseDynamics_get_eml_resolved_functions_info(void); mxArray *persistentMxArray = (mxArray *) sf_c3_InverseDynamics_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 }
unsigned int sf_BoatDynamic_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)(4266279937U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2301601715U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2035947662U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2227678827U); } 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)(1696694212U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1767225808U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3740181501U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(2256016198U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_BoatDynamic_get_check_sum(mxArray *plhs[]); sf_c1_BoatDynamic_get_check_sum(plhs); break; } case 2: { extern void sf_c2_BoatDynamic_get_check_sum(mxArray *plhs[]); sf_c2_BoatDynamic_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)(1666150109U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(3277580775U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(294114188U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(4213807667U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(798114639U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1876369125U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3618836105U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3292593476U); } return 1; #else return 0; #endif }
unsigned int sf_InverseDynamics_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)(1726695110U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(2281583267U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1463948066U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3135976230U); } 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)(74004378U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(81334654U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(1458641145U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(690391788U); } else if (nrhs==3 && !strcmp(commandName,"chart")) { unsigned int chartFileNumber; chartFileNumber = (unsigned int)mxGetScalar(prhs[2]); switch (chartFileNumber) { case 1: { extern void sf_c1_InverseDynamics_get_check_sum(mxArray *plhs[]); sf_c1_InverseDynamics_get_check_sum(plhs); break; } case 2: { extern void sf_c2_InverseDynamics_get_check_sum(mxArray *plhs[]); sf_c2_InverseDynamics_get_check_sum(plhs); break; } case 3: { extern void sf_c3_InverseDynamics_get_check_sum(mxArray *plhs[]); sf_c3_InverseDynamics_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)(2083502392U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(1110276785U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(3258378658U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3926592909U); } else { return 0; } } else { ((real_T *)mxGetPr((plhs[0])))[0] = (real_T)(4086246526U); ((real_T *)mxGetPr((plhs[0])))[1] = (real_T)(889087160U); ((real_T *)mxGetPr((plhs[0])))[2] = (real_T)(2596072055U); ((real_T *)mxGetPr((plhs[0])))[3] = (real_T)(3748950613U); } return 1; #else return 0; #endif }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { Long *Ap, *Ai, *Zp, *Zi ; double *Ax, *Az, *Zx ; Long p, j, build_upper, zero_handling, nrow, ncol, mkind, skind, asize, znz, status ; int ok = TRUE ; char filename [LEN+1], title [73], key [9], mtype [4] ; SuiteSparse_config config ; config.malloc_memory = mxMalloc ; config.free_memory = mxFree ; /* ---------------------------------------------------------------------- */ /* check inputs */ /* ---------------------------------------------------------------------- */ if (nargin != 1 || nargout > 5 || !mxIsChar (pargin [0])) { mexErrMsgTxt ("Usage: [A Z title key mtype] = RBread (filename)") ; } /* ---------------------------------------------------------------------- */ /* get filename */ /* ---------------------------------------------------------------------- */ if (mxGetString (pargin [0], filename, LEN) != 0) { mexErrMsgTxt ("filename too long") ; } /* ---------------------------------------------------------------------- */ /* read the matrix */ /* ---------------------------------------------------------------------- */ build_upper = TRUE ; /* always build upper tri. part */ zero_handling = (nargout > 1) ? 2 : 1 ; /* prune or extract zeros */ status = RBread (filename, build_upper, zero_handling, title, key, mtype, &nrow, &ncol, &mkind, &skind, &asize, &znz, &Ap, &Ai, &Ax, &Az, &Zp, &Zi, &config) ; if (status != RBIO_OK) { RBerror (status) ; mexErrMsgTxt ("error reading file") ; } /* ---------------------------------------------------------------------- */ /* return A to MATLAB */ /* ---------------------------------------------------------------------- */ pargout [0] = mxCreateSparse (0, 0, 0, (mkind == 2) ? mxCOMPLEX : mxREAL) ; mxFree (mxGetJc (pargout [0])) ; mxFree (mxGetIr (pargout [0])) ; mxFree (mxGetPr (pargout [0])) ; if (mkind == 2) mxFree (mxGetPi (pargout [0])) ; mxSetM (pargout [0], nrow) ; mxSetN (pargout [0], ncol) ; mxSetNzmax (pargout [0], asize) ; mxSetJc (pargout [0], (mwIndex *) Ap) ; mxSetIr (pargout [0], (mwIndex *) Ai) ; mxSetPr (pargout [0], Ax) ; if (mkind == 2) mxSetPi (pargout [0], Az) ; /* ---------------------------------------------------------------------- */ /* return Z to MATLAB */ /* ---------------------------------------------------------------------- */ if (nargout > 1) { Zx = (double *) SuiteSparse_malloc (znz, sizeof (double), &ok, &config); for (p = 0 ; p < znz ; p++) { Zx [p] = 1 ; } pargout [1] = mxCreateSparse (0, 0, 0, mxREAL) ; mxFree (mxGetJc (pargout [1])) ; mxFree (mxGetIr (pargout [1])) ; mxFree (mxGetPr (pargout [1])) ; mxSetM (pargout [1], nrow) ; mxSetN (pargout [1], ncol) ; mxSetNzmax (pargout [1], MAX (znz,1)) ; mxSetJc (pargout [1], (mwIndex *) Zp) ; mxSetIr (pargout [1], (mwIndex *) Zi) ; mxSetPr (pargout [1], Zx) ; } /* ---------------------------------------------------------------------- */ /* return title */ /* ---------------------------------------------------------------------- */ if (nargout > 2) { pargout [2] = mxCreateString (title) ; } /* ---------------------------------------------------------------------- */ /* return key */ /* ---------------------------------------------------------------------- */ if (nargout > 3) { pargout [3] = mxCreateString (key) ; } /* ---------------------------------------------------------------------- */ /* return mtype */ /* ---------------------------------------------------------------------- */ if (nargout > 4) { pargout [4] = mxCreateString (mtype) ; } }
unsigned int sf_MiL_BMS_Bat_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, "FeaVVTQqfNZod1D6bACriC") == 0) { extern mxArray *sf_c1_MiL_BMS_Bat_get_autoinheritance_info(void); plhs[0] = sf_c1_MiL_BMS_Bat_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 2: { if (strcmp(aiChksum, "iqZlCE3QVJsbsfIx198lnH") == 0) { extern mxArray *sf_c2_MiL_BMS_Bat_get_autoinheritance_info(void); plhs[0] = sf_c2_MiL_BMS_Bat_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 4: { if (strcmp(aiChksum, "3fV3pMrJ33HZFBM3U9UgbF") == 0) { extern mxArray *sf_c4_MiL_BMS_Bat_get_autoinheritance_info(void); plhs[0] = sf_c4_MiL_BMS_Bat_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } case 12: { if (strcmp(aiChksum, "daJ2yPOQ0Lm8ig14kcsdcD") == 0) { extern mxArray *sf_c12_MiL_BMS_Bat_get_autoinheritance_info(void); plhs[0] = sf_c12_MiL_BMS_Bat_get_autoinheritance_info(); break; } plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); break; } default: plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL); } } return 1; #else return 0; #endif }