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

}
Beispiel #3
0
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()
Beispiel #5
0
/// 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);
}
Beispiel #7
0
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(']');
    
  }
  
}
Beispiel #8
0
/* 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");
    }
}
Beispiel #9
0
/* -------------------------------------------------------------------
 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

}
Beispiel #12
0
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;
}
Beispiel #13
0
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

}
Beispiel #14
0
/** 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

}
Beispiel #17
0
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

}
Beispiel #19
0
/* --- 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);

}
Beispiel #20
0
// 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());
    }
}
Beispiel #21
0
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");
}
Beispiel #22
0
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

}
Beispiel #29
0
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) ;
    }
}
Beispiel #30
0
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

}