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