void mexFunction(const int nlhs, mxArray *plhs[], const int nrhs, const mxArray *prhs[]) {
size_t n,j;
size_t nCard;
bool isLast, lastPassed;
mxArray *codeArray;
if(nrhs<1){
mexErrMsgTxt("Not enough inputs.");
}
if(nrhs>2){
mexErrMsgTxt("Too many inputs.");
}
if(nlhs>4) {
mexErrMsgTxt("Too many outputs.");
}
//If an empty code matrix is passed, then the second argument is
//required, and we will return the first gray code in the sequence.
if(mxIsEmpty(prhs[0])) {
mwSize dims[2];
if(nrhs<2) {
mexErrMsgTxt("The second argument is required when an empty code matrix is passed.");
}
dims[0]=getSizeTFromMatlab(prhs[1]);
dims[1]=1;
//Allocate the array; this also initializes all of the elements to
//0.
codeArray=mxCreateLogicalArray(2, dims);
//This is the code
plhs[0]=codeArray;
if(nlhs>1) {
//This is nCard
plhs[1]=mxCreateDoubleScalar(0.0);
if(nlhs>2) {
//This is isLast
plhs[2]=mxCreateLogicalScalar(false);
if(nlhs>3) {
//This is j.
plhs[3]=mxCreateDoubleMatrix(0, 0, mxREAL);
}
}
}
return;
}
//The code array cannot be complex.
if(mxIsComplex(prhs[0])!=false) {
mexErrMsgTxt("The code array cannot be complex.");
}
//Copy the code value so that the input matrix is not modified on
//return.
{
size_t n1,n2;
n1=mxGetM(prhs[0]);
n2=mxGetN(prhs[0]);
if((n1==1&&n2>=1)||(n2==1&&n1>=1)) {
n=std::max(n1,n2);
codeArray=mxDuplicateArray(prhs[0]);
} else {
mexErrMsgTxt("The code vector has the wrong dimensionality.");
}
}
if(nrhs>1) {
nCard=getSizeTFromMatlab(prhs[1]);
} else {
mxArray *lhs[1];
//Sum up the ones in codeArray to get nCard if it is not provided.
mexCallMATLAB(1,lhs,1, &codeArray, "sum");
nCard=getSizeTFromMatlab(lhs[0]);
mxDestroyArray(lhs[0]);
}
//The type of the data in the code array is whatever the user passed to
//the function. The function has to be called with the correct template
//value for the type of the code.
lastPassed=false;
switch(mxGetClassID(codeArray)){
case mxCHAR_CLASS:
{
mxChar *code=(mxChar*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxLOGICAL_CLASS:
{
mxLogical* code=(mxLogical*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxDOUBLE_CLASS:
{
double* code=(double*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxSINGLE_CLASS:
{
float* code=(float*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxINT8_CLASS:
{
int8_T* code=(int8_T*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxUINT8_CLASS:
{
uint8_T* code=(uint8_T*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxINT16_CLASS:
{
int16_T* code=(int16_T*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxUINT16_CLASS:
{
uint16_T* code=(uint16_T*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxINT32_CLASS:
{
int32_T* code=(int32_T*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxUINT32_CLASS:
{
uint32_T* code=(uint32_T*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxINT64_CLASS:
{
int64_T* code=(int64_T*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
case mxUINT64_CLASS:
{
uint64_T* code=(uint64_T*)mxGetData(codeArray);
if(nCard==(size_t)code[n-1]&&nCard!=0) {
lastPassed=true;
} else{
isLast=getNextGrayCodeCPP(n, code, nCard, j);
}
break;
}
default:
mexErrMsgTxt("The code vector is of an unknown data type.");
}
//If the final gray code was passed, then just return empty matrices
//and put n in nCard. That way, if called again, the function will
//start from the beginning.
if(lastPassed==true) {
mxDestroyArray(codeArray);
plhs[0]=mxCreateDoubleMatrix(0, 0, mxREAL);
if(nlhs>1) {
mxArray *nCardMat=allocUnsignedSizeMatInMatlab(1, 1);
*(size_t*)mxGetData(nCardMat)=n;
plhs[1]=nCardMat;
if(nlhs>2) {
//This is isLast
plhs[2]=mxCreateDoubleMatrix(0, 0, mxREAL);;
if(nlhs>3) {
//This is j
plhs[3]=mxCreateDoubleMatrix(0, 0, mxREAL);;
}
}
}
return;
}
//Set the return values for the case when the last code was not passed.
plhs[0]=codeArray;
if(nlhs>1) {
mxArray *nCardMat=allocUnsignedSizeMatInMatlab(1, 1);
*(size_t*)mxGetData(nCardMat)=nCard;
plhs[1]=nCardMat;
if(nlhs>2) {
//This is isLast
plhs[2]=mxCreateLogicalScalar(isLast);
if(nlhs>3) {
mxArray *jMat=allocUnsignedSizeMatInMatlab(1, 1);
//Increment j to be an index for Matlab.
j++;
*(size_t*)mxGetData(jMat)=j;
plhs[3]=jMat;
}
}
}
}
mxArray *sf_c2_MPC_framework_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)(4146277402U);
pr[1] = (double)(3031080980U);
pr[2] = (double)(1162626880U);
pr[3] = (double)(4240345295U);
mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum);
}
{
const char *dataFields[] = {"size","type","complexity"};
mxArray *mxData = mxCreateStructMatrix(1,6,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));
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(3));
mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(3));
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);
}
mxArray *sf_c6_TTR_mdl_get_autoinheritance_info(void)
{
const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters",
"outputs", "locals" };
mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5,
autoinheritanceFields);
{
mxArray *mxChecksum = mxCreateString("VVPNWBOOtqWmckFbbcB3AH");
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)(2);
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_c13_ARP_02_RPSs_Bdr_GK_BIS7_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);
}
/// @brief get a frame from the leap controller
///
/// @param nlhs matlab mex output interface
/// @param plhs[] matlab mex output interface
void get_frame (int nlhs, mxArray *plhs[])
{
// get the frame
const matleap::frame &f = fg->get_frame ();
// create matlab frame struct
const char *frame_field_names[] =
{
"id",
"timestamp",
"pointables",
"hands"
};
int frame_fields = sizeof (frame_field_names) / sizeof (*frame_field_names);
plhs[0] = mxCreateStructMatrix (1, 1, frame_fields, frame_field_names);
// fill the frame struct
mxSetFieldByNumber (plhs[0], 0, 0, mxCreateDoubleScalar (f.id));
mxSetFieldByNumber (plhs[0], 0, 1, mxCreateDoubleScalar (f.timestamp));
// create the pointables structs
if (f.pointables.count () > 0)
{
const char *pointable_field_names[] =
{
"id",
"position",
"velocity",
"direction",
"is_extended",
"is_finger",
"is_tool",
"is_valid",
"length",
"width",
"touch_distance",
"time_visible"
};
int pointable_fields = sizeof (pointable_field_names) / sizeof (*pointable_field_names);
mxArray *p = mxCreateStructMatrix (1, f.pointables.count (), pointable_fields, pointable_field_names);
mxSetFieldByNumber (plhs[0], 0, 2, p);
// fill the pointables structs
for (size_t i = 0; i < f.pointables.count (); ++i)
{
// set the id
mxSetFieldByNumber (p, i, 0, mxCreateDoubleScalar (f.pointables[i].id ()));
// create and fill arrays for vectors
mxArray *pos = create_and_fill (f.pointables[i].tipPosition ());
mxArray *vel = create_and_fill (f.pointables[i].tipVelocity ());
mxArray *dir = create_and_fill (f.pointables[i].direction ());
// set them in the struct
mxSetFieldByNumber (p, i, 1, pos);
mxSetFieldByNumber (p, i, 2, vel);
mxSetFieldByNumber (p, i, 3, dir);
mxSetFieldByNumber (p, i, 4, mxCreateDoubleScalar (f.pointables[i].isExtended ()));
mxSetFieldByNumber (p, i, 5, mxCreateDoubleScalar (f.pointables[i].isFinger ()));
mxSetFieldByNumber (p, i, 6, mxCreateDoubleScalar (f.pointables[i].isTool ()));
mxSetFieldByNumber (p, i, 7, mxCreateDoubleScalar (f.pointables[i].isValid ()));
mxSetFieldByNumber (p, i, 8, mxCreateDoubleScalar (f.pointables[i].length ()));
mxSetFieldByNumber (p, i, 9, mxCreateDoubleScalar (f.pointables[i].width ()));
mxSetFieldByNumber (p, i, 10, mxCreateDoubleScalar (f.pointables[i].touchDistance ()));
mxSetFieldByNumber (p, i, 11, mxCreateDoubleScalar (f.pointables[i].timeVisible ()));
}
}
if (f.hands.count () > 0)
{
const char *hand_field_names[] =
{
"id", // 0
"basis", // 1
"confidence", // 2
"direction", // 3
"grab_strength", // 4
"is_left", // 5
"is_right", // 6
"is_valid", // 7
"palm_normal", // 8
"palm_position", // 9
"palm_velocity", // 10
"palm_width", // 11
"pinch_strength", // 12
"sphere_center", // 13
"sphere_radius", // 14
"stabilized_palm_position", // 15
"time_visible", // 16
"wrist_position" // 17
};
int hand_fields = sizeof (hand_field_names) / sizeof (*hand_field_names);
mxArray *p = mxCreateStructMatrix (1, f.hands.count (), hand_fields, hand_field_names);
mxSetFieldByNumber (plhs[0], 0, 3, p);
// 3 because hands is the third (fourth) field name in
// the overall struct we are creating.
for (size_t i = 0; i < f.hands.count (); ++i)
{
// one by one, get the fields for the hand
mxSetFieldByNumber (p, i, 0, mxCreateDoubleScalar (f.hands[i].id ()));
mxSetFieldByNumber (p, i, 1, create_and_fill (f.hands[i].basis ()));
mxSetFieldByNumber (p, i, 2, mxCreateDoubleScalar (f.hands[i].confidence ()));
mxSetFieldByNumber (p, i, 3, create_and_fill (f.hands[i].direction ()));
mxSetFieldByNumber (p, i, 4, mxCreateDoubleScalar (f.hands[i].grabStrength ()));
mxSetFieldByNumber (p, i, 5, mxCreateDoubleScalar (f.hands[i].isLeft ()));
mxSetFieldByNumber (p, i, 6, mxCreateDoubleScalar (f.hands[i].isRight ()));
mxSetFieldByNumber (p, i, 7, mxCreateDoubleScalar (f.hands[i].isValid ()));
mxSetFieldByNumber (p, i, 8, create_and_fill (f.hands[i].palmNormal ()));
mxSetFieldByNumber (p, i, 9, create_and_fill (f.hands[i].palmPosition ()));
mxSetFieldByNumber (p, i, 10, create_and_fill (f.hands[i].palmVelocity ()));
mxSetFieldByNumber (p, i, 11, mxCreateDoubleScalar (f.hands[i].palmWidth ()));
mxSetFieldByNumber (p, i, 12, mxCreateDoubleScalar (f.hands[i].pinchStrength ()));
mxSetFieldByNumber (p, i, 13, create_and_fill (f.hands[i].sphereCenter ()));
mxSetFieldByNumber (p, i, 14, mxCreateDoubleScalar (f.hands[i].sphereRadius ()));
mxSetFieldByNumber (p, i, 15, create_and_fill (f.hands[i].stabilizedPalmPosition ()));
mxSetFieldByNumber (p, i, 16, mxCreateDoubleScalar (f.hands[i].timeVisible ()));
mxSetFieldByNumber (p, i, 17, create_and_fill (f.hands[i].wristPosition ()));
} // re: for f.hands.count()
} // re: if f.hands.count() > 0
}
DLL_EXPORT_SYM
void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
if (nrhs != 3 || nlhs != 8) {
mexErrMsgIdAndTxt(
"Drake:testMultipleTimeLinearPostureConstrainttmex:BadInputs",
"Usage [num_cnst, cnst_val, iAfun, jAvar, A, cnst_name, lb, ub] = "
"testMultipleTimeLinearPostureConstraintmex(kinCnst, q, t)");
}
MultipleTimeLinearPostureConstraint* cnst =
(MultipleTimeLinearPostureConstraint*)getDrakeMexPointer(prhs[0]);
int n_breaks = static_cast<int>(mxGetNumberOfElements(prhs[2]));
double* t_ptr = new double[n_breaks];
memcpy(t_ptr, mxGetPrSafe(prhs[2]), sizeof(double) * n_breaks);
int nq = cnst->getRobotPointer()->get_num_positions();
Eigen::MatrixXd q(nq, n_breaks);
if (mxGetM(prhs[1]) != nq || mxGetN(prhs[1]) != n_breaks) {
mexErrMsgIdAndTxt(
"Drake:testMultipleTimeLinearPostureConstraintmex:BadInputs",
"Argument 2 must be of size nq*n_breaks");
}
memcpy(q.data(), mxGetPrSafe(prhs[1]), sizeof(double) * nq * n_breaks);
int num_cnst = cnst->getNumConstraint(t_ptr, n_breaks);
Eigen::VectorXd c(num_cnst);
cnst->feval(t_ptr, n_breaks, q, c);
Eigen::VectorXi iAfun;
Eigen::VectorXi jAvar;
Eigen::VectorXd A;
cnst->geval(t_ptr, n_breaks, iAfun, jAvar, A);
std::vector<std::string> cnst_names;
cnst->name(t_ptr, n_breaks, cnst_names);
Eigen::VectorXd lb(num_cnst);
Eigen::VectorXd ub(num_cnst);
cnst->bounds(t_ptr, n_breaks, lb, ub);
Eigen::VectorXd iAfun_tmp(iAfun.size());
Eigen::VectorXd jAvar_tmp(jAvar.size());
for (int i = 0; i < iAfun.size(); i++) {
iAfun_tmp(i) = (double)iAfun(i) + 1;
jAvar_tmp(i) = (double)jAvar(i) + 1;
}
plhs[0] = mxCreateDoubleScalar((double)num_cnst);
plhs[1] = mxCreateDoubleMatrix(num_cnst, 1, mxREAL);
memcpy(mxGetPrSafe(plhs[1]), c.data(), sizeof(double) * num_cnst);
plhs[2] = mxCreateDoubleMatrix(iAfun_tmp.size(), 1, mxREAL);
memcpy(mxGetPrSafe(plhs[2]), iAfun_tmp.data(),
sizeof(double) * iAfun_tmp.size());
plhs[3] = mxCreateDoubleMatrix(jAvar_tmp.size(), 1, mxREAL);
memcpy(mxGetPrSafe(plhs[3]), jAvar_tmp.data(),
sizeof(double) * jAvar_tmp.size());
plhs[4] = mxCreateDoubleMatrix(A.size(), 1, mxREAL);
memcpy(mxGetPrSafe(plhs[4]), A.data(), sizeof(double) * A.size());
int name_ndim = 1;
mwSize name_dims[] = {(mwSize)num_cnst};
plhs[5] = mxCreateCellArray(name_ndim, name_dims);
mxArray* name_ptr;
for (int i = 0; i < num_cnst; i++) {
name_ptr = mxCreateString(cnst_names[i].c_str());
mxSetCell(plhs[5], i, name_ptr);
}
plhs[6] = mxCreateDoubleMatrix(num_cnst, 1, mxREAL);
plhs[7] = mxCreateDoubleMatrix(num_cnst, 1, mxREAL);
memcpy(mxGetPrSafe(plhs[6]), lb.data(), sizeof(double) * num_cnst);
memcpy(mxGetPrSafe(plhs[7]), ub.data(), sizeof(double) * num_cnst);
delete[] t_ptr;
}
mxArray *sf_c2_object_tracker_intensity_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)(854637128U);
pr[1] = (double)(4226084400U);
pr[2] = (double)(14798454U);
pr[3] = (double)(2387218890U);
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)(2);
pr[1] = (double)(10);
mxSetField(mxData,0,"size",mxSize);
}
{
const char *typeFields[] = {"base","aliasId","fixpt"};
mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields);
mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));
mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(5));
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)(2);
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(5));
mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(5));
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","aliasId","fixpt"};
mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields);
mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));
mxSetField(mxType,0,"aliasId",mxCreateDoubleScalar(5));
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,3,3,dataFields);
{
mxArray *mxSize = mxCreateDoubleMatrix(1,2,mxREAL);
double *pr = mxGetPr(mxSize);
pr[0] = (double)(2);
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(5));
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)(4);
mxSetField(mxData,1,"size",mxSize);
}
{
const char *typeFields[] = {"base","aliasId","fixpt"};
mxArray *mxType = mxCreateStructMatrix(1,1,3,typeFields);
mxSetField(mxType,0,"base",mxCreateDoubleScalar(5));
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(5));
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);
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]
)
{ const double *h1, *h2;
mwSize nrow1, nrow2;
mwIndex *ir1, *ir2, i1, i2;
mwIndex maxc1, maxc2;
double ret=0;
/* Check I/O number */
if (nlhs!=1) {
mexErrMsgTxt("Incorrect number of outputs");
}
if (nrhs!=2) {
mexErrMsgTxt("Incorrect number of inputs");
}
/* Brief error checking */
/*ncol1 = mxGetN(prhs[0]);
ncol2 = mxGetN(prhs[1]);*/
nrow1 = mxGetM(prhs[0]);
nrow2 = mxGetM(prhs[1]);
/*if ((ncol!=mxGetM(prhs[1])) || (mxGetN(prhs[1])!=1)) {
mexErrMsgTxt("Wrong input dimensions");
}
if (!mxIsSparse(prhs[0])) {
mexErrMsgTxt("Matrix must be sparse");
}*/
/* Allocate output */
/*plhs[0] = mxCreateDoubleMatrix(mxGetM(prhs[0]), 1, mxREAL);*/
/* I/O pointers */
ir1 = mxGetIr(prhs[0]); /* Row indexing */
ir2 = mxGetIr(prhs[1]); /* Row indexing */
h1 = mxGetPr(prhs[0]); /* Non-zero elements */
h2 = mxGetPr(prhs[1]); /* Rhs vector */
maxc1 = mxGetJc(prhs[0])[1];
maxc2 = mxGetJc(prhs[1])[1];
i1=0;
i2=0;
while(i1<maxc1 && i2<maxc2) { /* Loop through columns */
if (ir1[i1]==ir2[i2]) {
ret=ret+h1[i1]*h2[i2]/(h1[i1]+h2[i2]);
i1++;
i2++;
} else {
if (ir1[i1]>ir2[i2])
i2++;
else
i1++;
}
}
plhs[0] = mxCreateDoubleScalar(2-4*ret);
}
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);
}
/*
* o b t a i n O u t p u t s S B
*/
returnValue obtainOutputsSB( int k, QProblemB* qp, returnValue returnvalue, int _nWSRout, double _cpuTime,
int nlhs, mxArray* plhs[], int nV, int handle
)
{
double *x=0, *obj=0, *status=0, *nWSRout=0, *y=0, *workingSetB=0, *workingSetC=0, *cpuTime;
mxArray *auxOutput=0, *curField=0;
/* Create output vectors and assign pointers to them. */
int curIdx = 0;
/* handle */
if ( handle >= 0 )
plhs[curIdx++] = mxCreateDoubleScalar( handle );
/* x */
x = mxGetPr( plhs[curIdx++] );
QProblemB_getPrimalSolution( qp,&(x[k*nV]) );
if ( nlhs > curIdx )
{
/* fval */
obj = mxGetPr( plhs[curIdx++] );
obj[k] = QProblemB_getObjVal( qp );
if ( nlhs > curIdx )
{
/* exitflag */
status = mxGetPr( plhs[curIdx++] );
status[k] = (double)qpOASES_getSimpleStatus( returnvalue,0 );
if ( nlhs > curIdx )
{
/* iter */
nWSRout = mxGetPr( plhs[curIdx++] );
nWSRout[k] = (double) _nWSRout;
if ( nlhs > curIdx )
{
/* lambda */
y = mxGetPr( plhs[curIdx++] );
QProblemB_getDualSolution( qp,&(y[k*nV]) );
/* auxOutput */
if ( nlhs > curIdx )
{
auxOutput = plhs[curIdx];
curField = 0;
/* working set bounds */
if ( nV > 0 )
{
curField = mxGetField( auxOutput,0,"workingSetB" );
workingSetB = mxGetPr(curField);
QProblemB_getWorkingSetBounds( qp,&(workingSetB[k*nV]) );
}
/* cpu time */
curField = mxGetField( auxOutput,0,"cpuTime" );
cpuTime = mxGetPr(curField);
cpuTime[0] = (double) _cpuTime;
}
}
}
}
}
return SUCCESSFUL_RETURN;
}
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 *message_constructor(const MessagePtr& message, int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
mxArray *result = 0;
// parse inputs
if (nrhs > 0 && Options::isString(prhs[0])) {
std::string option = Options::getString(prhs[0]);
if (nrhs == 1 && boost::algorithm::iequals(option, "definition")) {
result = mxCreateString(message->getDefinition());
return result;
}
if (nrhs == 1 && boost::algorithm::iequals(option, "md5sum")) {
result = mxCreateString(message->getMD5Sum());
return result;
}
if (nrhs == 1 && boost::algorithm::iequals(option, "fields")) {
result = mxCreateCellMatrix(1, message->getFieldNames().size());
for(std::size_t i = 0; i < message->getFieldNames().size(); ++i) {
mxSetCell(result, i, mxCreateString(message->getFieldNames().at(i)));
}
return result;
}
if ((nrhs == 1 || nrhs == 2) && boost::algorithm::iequals(option, "default")) {
if (nrhs == 2) {
const mxArray *default_options = prhs[1];
Conversion::perMessageOptions(message).merge(ConversionOptions(1, &default_options));
}
return Conversion::perMessageOptions(message).toMatlab();
}
}
// Check if a numeric argument (message count) has been given
std::size_t count = 1;
if (nrhs > 0 && (Options::isIntegerScalar(prhs[0]) || Options::isDoubleScalar(prhs[0]))) {
count = Options::getIntegerScalar(prhs[0]);
nrhs--; prhs++;
}
// Get conversion options
ConversionOptions options;
if (nrhs % 2 == 0) {
options.init(nrhs, prhs);
} else {
options.init(nrhs - 1, prhs + 1);
}
// Is this a copy constructor?
if (nrhs % 2 != 0) {
Conversion conversion(message, options);
V_Message copy(conversion.numberOfInstances(prhs[0]));
for(std::size_t j = 0; j < copy.size(); j++) {
copy[j] = conversion.fromMatlab(prhs[0], j);
// std::cout << "Constructed a new " << copy[j]->getDataType() << " message: " << *boost::shared_static_cast<MessageType const>(copy[j]->getConstInstance()) << std::endl;
result = Conversion(conversion, copy[j]).toMatlab(result, j, copy.size());
}
// otherwise construct a new message
} else {
MessagePtr m = message->introspect(message->createInstance());
// std::cout << "Constructed a new " << m->getDataType() << " message: " << *boost::shared_static_cast<MessageType const>(m->getConstInstance()) << std::endl;
Conversion conversion(m, options);
result = conversion.toMatlab();
}
// copy the contents of result if count > 1
if (count > 1) {
// This seems to be a bit hacky. Is there a better solution?
mxArray *repmatrhs[] = { result, mxCreateDoubleScalar(1), mxCreateDoubleScalar(count) };
mxArray *repmatlhs[] = { 0 };
mexCallMATLAB(1, repmatlhs, 3, repmatrhs, "repmat");
mxDestroyArray(repmatrhs[0]);
mxDestroyArray(repmatrhs[1]);
mxDestroyArray(repmatrhs[2]);
result = repmatlhs[0];
}
return result;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
double *wv, *nFeatures, *np, *ep, *Z, lambda;
unsigned int nStates, nFeaturesTotal, maxSentenceLength;
SubMatrix w, v, v_start, v_end, gw, gv, gv_start, gv_end, sentences, y, X, featureStart;
double f = 0;
wv = mxGetPr(prhs[0]);
X.value_start = mxGetPr(prhs[1]);
X.numRows = mxGetM(prhs[1]);
X.numColumns = mxGetN(prhs[1]);
y.value_start = mxGetPr(prhs[2]);
y.numRows = mxGetM(prhs[2]);
y.numColumns = mxGetN(prhs[2]);
nStates = mxGetScalar(prhs[3]);
nFeatures = mxGetPr(prhs[4]);
featureStart.value_start = mxGetPr(prhs[5]);
featureStart.numRows = mxGetM(prhs[5]);
featureStart.numColumns = mxGetN(prhs[5]);
sentences.value_start = mxGetPr(prhs[6]);
sentences.numRows = mxGetM(prhs[6]);
sentences.numColumns = mxGetN(prhs[6]);
maxSentenceLength = mxGetScalar(prhs[7]);
lambda = mxGetScalar(prhs[8]);
/*nFeaturesTotal = featureStart(end)-1;*/
nFeaturesTotal = submat_value(featureStart, 1, featureStart.numColumns) - 1;
int nSentences = mxGetM(prhs[6]);
/*Set up the submatrices for node and edge parameters*/
w.value_start = wv;
w.numRows = nFeaturesTotal;
w.numColumns = nStates;
v_start.value_start = wv + nFeaturesTotal*nStates;
v_start.numRows = nStates;
v_start.numColumns = 1;
v_end.value_start = wv + nFeaturesTotal*nStates + nStates;
v_end.numRows = nStates;
v_end.numColumns = 1;
v.value_start = wv + nFeaturesTotal*nStates + 2*nStates;
v.numRows = nStates;
v.numColumns = nStates;
mxArray *g = mxCreateDoubleMatrix(mxGetM(prhs[0]),mxGetN(prhs[0]),mxREAL);
/*mxArray *g = prhs[7];*/
gw.value_start = mxGetPr(g);
gw.numRows = nFeaturesTotal;
gw.numColumns = nStates;
gv_start.value_start = mxGetPr(g) + nFeaturesTotal*nStates;
gv_start.numRows = nStates;
gv_start.numColumns = 1;
gv_end.value_start = gv_start.value_start + nStates;
gv_end.numRows = nStates;
gv_end.numColumns = 1;
gv.value_start = gv_end.value_start + nStates;
gv.numRows = nStates;
gv.numColumns = nStates;
int i,j, s, n, k, feat, state, state1, state2;
SubMatrix nodePot, edgePot, nodeBel, edgeBel, alpha, beta;
nodePot.value_start = mxCalloc(maxSentenceLength*nStates,sizeof(double));
edgePot.value_start = mxCalloc(nStates*nStates,sizeof(double));
nodeBel.value_start = mxCalloc(maxSentenceLength*nStates,sizeof(double));
edgeBel.value_start = mxCalloc(nStates*nStates*(maxSentenceLength-1),sizeof(double));
alpha.value_start = mxCalloc(maxSentenceLength*nStates, sizeof(double));
beta.value_start = mxCalloc(maxSentenceLength*nStates, sizeof(double));
Z = mxCalloc(maxSentenceLength,sizeof(double));
for (s = 1; s <= nSentences; ++s) {
int nNodes = submat_value(sentences, s, 2) - submat_value(sentences, s, 1) + 1;
SubMatrix y_s;
y_s.value_start = submat_pointer(y, (long)submat_value(sentences, s, 1), 1);
y_s.numRows = submat_value(sentences, s, 2) - submat_value(sentences, s, 1) + 1;
y_s.numColumns = 1;
/*******************************************************************************/
/* Make nodePot/edgePot */
nodePot.numRows = nNodes;
nodePot.numColumns = nStates;
edgePot.numRows = v.numRows;
edgePot.numColumns = v.numColumns;
for (n = 1; n <= nNodes; ++n) {
double features[X.numColumns];
int k;
for (k = 1; k <= X.numColumns; ++k) {
features[k-1] = submat_value(X, (long)submat_value(sentences, s, 1)+(long)n-(long)1, (long)k);
}
int state;
for (state = 1; state <= nStates; ++state) {
double pot = 0;
int f;
for (f = 1; f <= mxGetN(prhs[4]); ++f) {
if (features[f-1] != 0) {
int featureParam = submat_value(featureStart, 1, f) + features[f-1] - 1;
pot += w.value_start[featureParam+nFeaturesTotal*(state-1)-1];
}
}
submat_value(nodePot, n, state) = pot;
}
}
for (k = 1; k <= nodePot.numColumns; ++k) {
submat_value(nodePot, 1, k) += submat_value(v_start, k, 1);
}
for (k = 1; k <= nodePot.numColumns; ++k) {
submat_value(nodePot, nodePot.numRows, k) += submat_value(v_end, k, 1);
}
for (k = 0; k < nodePot.numRows*nodePot.numColumns; ++k) {
nodePot.value_start[k] = exp(nodePot.value_start[k]);
}
for (k = 0; k < edgePot.numRows*edgePot.numColumns; ++k) {
edgePot.value_start[k] = exp(v.value_start[k]);
}
/*******************************************************************************/
/*******************************************************************************/
/* Infer */
nodeBel.numRows = nodePot.numRows;
nodeBel.numColumns = nodePot.numColumns;
edgeBel.numRows = nStates;
edgeBel.numColumns = nStates;
edgeBel.numMatrices = nNodes - 1;
alpha.numRows = nNodes;
alpha.numColumns = nStates;
beta.numRows = nNodes;
beta.numColumns = nStates;
for (n=0; n< nNodes*nStates;n++)
beta.value_start[n] = 0;
for (n=0; n < nNodes;n++)
Z[n]=0;;
for (i = 1; i <= alpha.numColumns; ++i) {
submat_value(alpha, 1, i) = submat_value(nodePot, 1, i);
}
for (i = 1; i <= alpha.numColumns; ++i) {
Z[0] += submat_value(alpha, 1, i);
}
for (i = 1; i <= alpha.numColumns; ++i) {
submat_value(alpha, 1, i) /= Z[0];
}
for (n = 2; n <= nNodes; ++n) {
double tmp[edgePot.numColumns];
for (i = 0; i < edgePot.numColumns; ++i) {
tmp[i] = 0;
}
for (i = 1; i <= alpha.numColumns; ++i) {
for (j = 1; j <= nStates; ++j) {
tmp[j-1] += submat_value(alpha, n-1, i)*submat_value(edgePot, i, j);
}
}
for (i = 1; i <= alpha.numColumns; ++i) {
submat_value(alpha, n, i) = submat_value(nodePot, n, i)*tmp[i-1];
}
for (i = 1; i <= alpha.numColumns; ++i) {
Z[n-1] += submat_value(alpha, n, i);
}
for (i = 1; i <= alpha.numColumns; ++i) {
submat_value(alpha, n, i) /= Z[n-1];
}
}
for (i = 1; i<= nStates; ++i) {
submat_value(beta, nNodes, i) = 1;
}
for (n = nNodes - 1; n >= 1; --n) {
for (j = 1; j <= nodePot.numColumns; ++j) {
for (i = 1; i <= nStates; ++i) {
submat_value(beta, n, i) += submat_value(nodePot, n+1, j)*submat_value(edgePot, i, j)*submat_value(beta, n+1, j);
}
}
double tmp = 0;
for (i = 1; i <= beta.numColumns; ++i) {
tmp += submat_value(beta, n, i);
}
for (i = 1; i <= beta.numColumns; ++i) {
submat_value(beta, n, i) /= tmp;
}
}
for (n = 1; n <= nNodes; ++n) {
double tmp[alpha.numColumns];
for (i = 0; i < alpha.numColumns; ++i) {
tmp[i] = 0;
}
double sumTmp = 0;
for (i = 1; i <= alpha.numColumns; ++i) {
tmp[i-1] += submat_value(alpha, n, i)*submat_value(beta, n, i);
sumTmp += tmp[i-1];
}
for (i = 1; i <= alpha.numColumns; ++i) {
submat_value(nodeBel, n, i) = tmp[i-1]/sumTmp;
}
}
for (n = 1; n <= nNodes-1; ++n) {
double sum = 0;
for (i = 1; i <= nStates; ++i) {
for (j = 1; j <= nStates; ++j) {
submat_value3(edgeBel, i, j, n) = submat_value(alpha, n, i)*submat_value(nodePot, n+1, j)*submat_value(beta, n+1, j)*submat_value(edgePot, i, j);
sum += submat_value3(edgeBel, i, j, n);
}
}
for (i = 1; i <= nStates; ++i) {
for (j = 1; j <= nStates; ++j) {
submat_value3(edgeBel, i, j, n) /= sum;
}
}
}
double logZ = 0;
for (i = 0; i < nNodes; ++i) {
logZ += log(Z[i]);
}
/*******************************************************************************/
for (n = 1; n <= nNodes; ++n) {
f += log(submat_value(nodePot, n, (long)submat_value(y_s, n, 1)));
}
for (n = 1; n <= nNodes - 1; ++n) {
f += log(submat_value(edgePot, (long)submat_value(y_s, n, 1), (long)submat_value(y_s, n+1, 1)));
}
f -= logZ;
/*Update gradient of node features*/
for (n = 1; n <= nNodes; ++n) {
double features[X.numColumns];
int k;
for (k = 1; k <= X.numColumns; ++k) {
features[k-1] = submat_value(X, (long)submat_value(sentences, s, 1)+(long)n-(long)1, (long)k);
}
for (feat = 1; feat <= mxGetN(prhs[4]); ++feat) {
if (features[feat-1] != 0) {
int featureParam = submat_value(featureStart, 1, feat) + features[feat-1] - 1;
for (state = 1; state <= nStates; ++state) {
int O = (state == submat_value(y_s, n, 1));
double E = submat_value(nodeBel, n, state);
submat_value(gw, featureParam, state) += O - E;
}
}
}
}
/*Update gradient of BoS and EoS transitions*/
for (state = 1; state <= nStates; ++state) {
int O = (state == submat_value(y_s, 1, 1));
double E = submat_value(nodeBel, 1, state);
submat_value(gv_start, state, 1) += O - E;
O = (state == submat_value(y_s, y_s.numRows, 1));
E = submat_value(nodeBel, nodeBel.numRows, state);
submat_value(gv_end, state, 1) += O - E;
}
/*GOOD TO HERE*/
/*Update gradient of transitions*/
for (n = 1; n <= nNodes - 1; ++n) {
for (state1 = 1; state1 <= nStates; ++state1) {
for (state2 = 1; state2 <= nStates; ++state2) {
int O = ((state1 == submat_value(y_s, n, 1)) && (state2 == submat_value(y_s, n+1, 1)));
double E = edgeBel.value_start[(state1-1) + edgeBel.numRows*((state2-1) + edgeBel.numColumns*(n-1))];
submat_value(gv, state1, state2) += O - E;
}
}
}
}
double* temp = mxGetPr(g);
for (n = 1; n <= mxGetM(g); ++n) {
*temp *= -1;
temp += 1;
}
/* Add L2-penalty to Objective and Gradient*/
double sumSquared = 0;
temp = mxGetPr(g);
for(i = 0; i < nFeaturesTotal*nStates + 2*nStates + nStates*nStates;i++)
{
sumSquared += wv[i]*wv[i];
temp[i] += lambda*wv[i];
}
f = f - (lambda/2)*sumSquared;
plhs[0] = mxCreateDoubleScalar(-f);
plhs[1] = g;
mxFree(nodePot.value_start);
mxFree(edgePot.value_start);
mxFree(nodeBel.value_start);
mxFree(edgeBel.value_start);
mxFree(alpha.value_start);
mxFree(beta.value_start);
mxFree(Z);
}
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);
}
mxArray *sf_c12_ekffedepre_get_autoinheritance_info(void)
{
const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters",
"outputs", "locals" };
mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5,
autoinheritanceFields);
{
mxArray *mxChecksum = mxCreateDoubleMatrix(4,1,mxREAL);
double *pr = mxGetPr(mxChecksum);
pr[0] = (double)(1571567285U);
pr[1] = (double)(2463084369U);
pr[2] = (double)(780662584U);
pr[3] = (double)(3535259596U);
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)(3);
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);
}
mxArray *sf_c3_MPC_framework_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);
}
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);
}
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
mwSize n, m, nz; /* m- number of rows; n-number of col; */
mxArray *v1,*v2; /* used for pass the return value-- left hand values (plhs). */
mwIndex i,j;
double *pr, *Y, *r, *delta, *delta_beta, *beta, *beta2;
mwIndex *ir, *jc;
double Z, value, F,lamda; /* Z denotes the denuminator*/
mwIndex row;
double a,b,f,e, betaj, s, deriv, delta_vj, delta_betaj,de,deltaj,intcpt, delta_BOUND_intcpt,delta_intcpt, delta_intcpt_cand,abs_d_beta,abs_beta, crit;
double iter;
if (! mxIsSparse (prhs[0]))
mexErrMsgTxt ("expects sparse matrix");
/* pass X */
m = mxGetM (prhs [0]);
n = mxGetN (prhs [0]);
nz = mxGetNzmax (prhs [0]);
pr = mxGetPr (prhs[0]);
ir = mxGetIr (prhs[0]);
jc = mxGetJc (prhs[0]);
/* pass Y,r,delta,lambda,delta_beta,beta */
Y = mxGetPr(prhs[1]);
r = mxGetPr(prhs[2]);
delta = mxGetPr(prhs[3]);
delta_beta = mxGetPr(prhs[4]);
beta = mxGetPr(prhs[5]);
lamda = mxGetScalar(prhs[6]);
/*
beta = zeros(1,p);
intcpt = 0;
delta = ones(1,p);
delta_BOUND_intcpt = 1;
r = zeros(n,1);
delta_beta = zeros(1,p);
%delta_vj = 0;
delta_r = zeros(n,1);*/
/*initialization
for(j = 0; j < n; j ++)
{ beta[j] = 0;
delta[j] = 1;
delta_beta[j] = 0;
}
for(i = 0; i < m; i ++)
{
r[i] = 0;
/*delta_r[i] = 0;
}
*/
intcpt = 0;
delta_BOUND_intcpt = 1;
iter = 0;
while(1)
{
iter = iter + 1;
while(1) {
/*par2 = delta_BOUND_intcpt * ones(n,1);
de = sum(F(r,par2));
*/
de = 0.0;
b = delta_BOUND_intcpt;
for(i = 0; i < m; i++){
a = r[i];
if (a <= b) F = 0.25;
else {
e = exp(a - b);
F = 1.0 / (2.0 + e + 1.0 / e);
}
de = de + F;
}
delta_intcpt_cand = 0.0;
for(i = 0; i < m; i ++)
{
delta_intcpt_cand = delta_intcpt_cand + Y[i]/(1.0 + exp(r[i]));
}
delta_intcpt_cand = delta_intcpt_cand / de;
/*delta_intcpt_cand = sum(Y./(1+exp(r))) / de; */
delta_intcpt = min(max(delta_intcpt_cand,-delta_BOUND_intcpt),delta_BOUND_intcpt);
for(i = 0; i < m; i++)
r[i] = r[i] + delta_intcpt*Y[i];
intcpt = intcpt + delta_intcpt;
delta_BOUND_intcpt = max(2*fabs(delta_intcpt),delta_BOUND_intcpt/2.0);
if (fabs(delta_intcpt)/(1+fabs(intcpt)) < 5E-4)
break;
}
for(j = 0; j < n; j++){
if( jc[j+1] == jc[j]) continue; /*there is no nonzero elements in j-th column*/
Z = 0;
de = 0;
for(i = jc[j]; i < jc[j+1]; i ++) /* print the jth non-zero col*/
/* the value is pr[i]; the row is ir[i] */
{
row = ir[i];
value = pr[i];
Z = Z + value * Y[row] / (1+exp(r[row])); a = fabs(r[row]);
b = fabs(delta[j] * value);
/*F; // = a<=b ? 0.25 : 1.0/( 2.0 + exp(a-b) + exp(b-a) );*/
if (a <= b) F = 0.25;
else {
e = exp(a - b);
F = 1.0 / (2.0 + e + 1.0 / e);
}
de += F * value * value;
}
betaj = beta[j];
deltaj = delta[j];
if (betaj)
{
s = betaj / fabs(betaj);
deriv = lamda * s;
delta_vj = (Z - deriv) / de;
if (s*(betaj + delta_vj) < 0)
delta_vj = -betaj;
}
else
{ s = 1;
deriv = lamda * s;
delta_vj = (Z - deriv) / de;
if (delta_vj <= 0)
{ s = -1;
deriv = lamda * s;
delta_vj = (Z - deriv) / de;
if (delta_vj >= 0)
delta_vj = 0;
}
}
delta_betaj = min(max(delta_vj,-deltaj),deltaj);
for(i = jc[j]; i < jc[j+1]; i ++) /* print the jth non-zero col*/
/* the value is pr[i]; the row is ir[i] */
{
row = ir[i];
value = pr[i];
r[row] = r[row] + delta_betaj * Y[row] * pr[i];
/*r(index) = rnow + delta_betaj * (Xnow.* Ynow);*/
}
beta[j] = betaj+delta_betaj;
delta[j] = max(2.0*fabs(delta_betaj),deltaj/2.0);
delta_beta[j] = delta_betaj;
}
abs_d_beta = 0.0;
abs_beta = 0.0;
for(j = 0; j < n; j ++)
{
abs_d_beta = abs_d_beta + fabs(delta_beta[j]);
abs_beta = abs_beta + fabs(beta[j]);
}
crit = 1.0* abs_d_beta / (1+abs_beta);
/*crit = ( sum( abs(delta_beta) ) )/ (1+sum(abs(beta)) ); */
if (crit < 5E-4 || iter > 2000)
break;
}
/*
v1 = mxCreateDoubleMatrix(m,1,mxREAL);
r2 = mxGetPr(v1);
for(i = 0; i< m; i ++)
r2[i] = r[i];
plhs[0] = v1;
v2 = mxCreateDoubleMatrix(1,n,mxREAL);
delta2 = mxGetPr(v2);
for(i = 0; i< n; i++)
delta2[i] = delta[i];
plhs[1] = v2; /*plhs[1] = delta;
v3 = mxCreateDoubleMatrix(1,n,mxREAL);
delta_beta2 = mxGetPr(v3);
for(i =0; i< n; i++)
delta_beta2[i] = delta_beta[i];
plhs[2] = v3; /*plhs[2] = delta_beta; */
v1 = mxCreateDoubleScalar(intcpt);
/*intcpt2 = mxGetPr(v1);
intcpt2 = intcpt; */
plhs[0] = v1; /*plhs[3] = beta;*/
v2 = mxCreateDoubleMatrix(1,n,mxREAL);
beta2 = mxGetPr(v2);
for(i = 0; i< n; i++)
beta2[i] = beta[i];
plhs[1] = v2; /*plhs[3] = beta;*/
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]) {
mwSize N;
double *x, *lb, *ub, fx;
lbfgsb_options_t op;
if (nrhs<4)
mexErrMsgTxt("lbfgs_ requires exactly 4 input arguments.");
if( mxGetClassID(prhs[0]) != mxFUNCTION_CLASS )
mexErrMsgTxt("The first argument must be a function handle.");
if (!mxIsDouble(prhs[1]))
mexErrMsgTxt("The second argument must be a column vector.");
if (!mxIsDouble(prhs[2]))
mexErrMsgTxt("The third argument must be a column vector.");
if (!mxIsDouble(prhs[3]))
mexErrMsgTxt("The fourth argument must be a column vector.");
if (!mxIsStruct(prhs[4]))
mexErrMsgTxt("The fith argument must be a struct.");
N = mxGetM(prhs[1])*mxGetN(prhs[1]);
// Get function handle for use with mexCallMATLAB
rhs[0] = mxDuplicateArray(prhs[0]);
rhs[1] = mxCreateDoubleMatrix(N,1,mxREAL);
op.m = (int) mxGetScalar(mxGetField(prhs[4],0,"m"));
op.maxiter = (int) mxGetScalar(mxGetField(prhs[4],0,"maxiter"));
op.pgtol = (double) mxGetScalar(mxGetField(prhs[4],0,"pgtol"));
op.factr = (double) mxGetScalar(mxGetField(prhs[4],0,"factr"));
op.iter = iter;
// Allocate memory for solution vector and initialize it to x0
// do the same for the lower and upper bounds
x = (double*)mxMalloc(N*sizeof(double));
lb = (double*)mxMalloc(N*sizeof(double));
ub = (double*)mxMalloc(N*sizeof(double));
memcpy(x, mxGetPr(prhs[1]),N*sizeof(double));
memcpy(lb,mxGetPr(prhs[2]),N*sizeof(double));
memcpy(ub,mxGetPr(prhs[3]),N*sizeof(double));
LBFGSB lfbsgb(N, x, lb, ub, evaluate, &op);
lbfgsb_res_t res = lfbsgb.solve(fx);
mxArray *res_str;
switch(res) {
case CONVERGED:
mexPrintf("L-BFGS-B converged\n");
res_str = mxCreateString("converged");
break;
case ABNORMAL_TERMINATION:
mexPrintf("L-BFGS-B abnormal termination\n");
res_str = mxCreateString("abnormal termination");
break;
case ERROR:
mexPrintf("L-BFGS-B error\n");
res_str = mxCreateString("error");
break;
case MAX_ITER:
mexPrintf("L-BFGS-B max iterations reached\n");
res_str = mxCreateString("max iterations reached");
break;
case UNHANDLED:
default:
mexWarnMsgTxt("Unknown result state");
res_str = mxCreateString("Unknown result state");
break;
}
// Allocate outputs
plhs[0] = mxCreateDoubleMatrix(N,1,mxREAL);
if(nlhs > 1)
plhs[1] = mxCreateDoubleScalar(fx);
if(nlhs > 2)
plhs[2] = mxCreateDoubleScalar(res);
// Copy current iterate to output
memcpy(mxGetPr(plhs[0]),x,N*sizeof(double));
}
/*
* o b t a i n O u t p u t s
*/
returnValue obtainOutputs( int k, QProblemB* qp, returnValue returnvalue, int _nWSRout, double _cpuTime,
int nlhs, mxArray* plhs[], int nV, int nC = 0, int handle = -1
)
{
/* Create output vectors and assign pointers to them. */
int curIdx = 0;
/* handle */
if ( handle >= 0 )
plhs[curIdx++] = mxCreateDoubleScalar( handle );
/* x */
double* x = mxGetPr( plhs[curIdx++] );
qp->getPrimalSolution( &(x[k*nV]) );
if ( nlhs > curIdx )
{
/* fval */
double* obj = mxGetPr( plhs[curIdx++] );
obj[k] = qp->getObjVal( );
if ( nlhs > curIdx )
{
/* exitflag */
double* status = mxGetPr( plhs[curIdx++] );
status[k] = (double)getSimpleStatus( returnvalue );
if ( nlhs > curIdx )
{
/* iter */
double* nWSRout = mxGetPr( plhs[curIdx++] );
nWSRout[k] = (double) _nWSRout;
if ( nlhs > curIdx )
{
/* lambda */
double* y = mxGetPr( plhs[curIdx++] );
qp->getDualSolution( &(y[k*(nV+nC)]) );
/* auxOutput */
if ( nlhs > curIdx )
{
QProblem* problemPointer;
problemPointer = dynamic_cast<QProblem*>(qp);
mxArray* auxOutput = plhs[curIdx];
mxArray* curField = 0;
/* working set bounds */
if ( nV > 0 )
{
curField = mxGetField( auxOutput,0,"workingSetB" );
double* workingSetB = mxGetPr(curField);
/* cast successful? */
if (problemPointer != NULL) {
problemPointer->getWorkingSetBounds( &(workingSetB[k*nV]) );
} else {
qp->getWorkingSetBounds( &(workingSetB[k*nV]) );
}
}
/* working set constraints */
if ( nC > 0 )
{
curField = mxGetField( auxOutput,0,"workingSetC" );
double* workingSetC = mxGetPr(curField);
/* cast successful? */
if (problemPointer != NULL) {
problemPointer->getWorkingSetConstraints( &(workingSetC[k*nC]) );
} else {
qp->getWorkingSetConstraints( &(workingSetC[k*nC]) );
}
}
/* cpu time */
curField = mxGetField( auxOutput,0,"cpuTime" );
double* cpuTime = mxGetPr(curField);
cpuTime[0] = (double) _cpuTime;
}
}
}
}
}
return SUCCESSFUL_RETURN;
}
/*
* This ist the Entry Function of this Mex-DLL
*/
void mexFunction(int nlhs, mxArray*plhs[], int nrhs, const mxArray*prhs[])
{
mexAtExit(CloseDBs);
/*
* Get the current Language
*/
if (Language == -1)
{
#ifdef _WIN32
switch(PRIMARYLANGID(GetUserDefaultLangID()))
{
case LANG_GERMAN:
Language = 1;
break;
default:
Language = 0;
}
#else
Language = 0;
#endif
}
/*
* Print Version Information
*/
if (! FirstStart)
{
FirstStart = true;
mexPrintf (MSG_HELLO, sqlite3_libversion());
}
int db_id = 0;
int CommandPos = 0;
int NumArgs = nrhs;
int i;
/*
* Check if the first argument is a number, then we have to use
* this number as an database id.
*/
if (nrhs >= 1 && mxIsNumeric(prhs[0]))
{
db_id = getinteger(prhs[0]);
if (db_id < 0 || db_id > MaxNumOfDbs)
{
mexPrintf(MSG_INVALIDDBHANDLE);
mexErrMsgTxt(MSG_IMPOSSIBLE);
}
db_id --;
CommandPos ++;
NumArgs --;
}
/*
* no argument -> fail
*/
if (NumArgs < 1)
{
mexPrintf(MSG_USAGE);
mexErrMsgTxt(MSG_INVALIDARG);
}
/*
* The next (or first if no db number available) is the command,
* it has to be a string.
* This fails also, if the first arg is a db-id and there is no
* further argument
*/
if (! mxIsChar(prhs[CommandPos]))
{
mexPrintf(MSG_USAGE);
mexErrMsgTxt(MSG_INVALIDARG);
}
/*
* Get the command string
*/
char *command = getstring(prhs[CommandPos]);
/*
* Adjust the Argument pointer and counter
*/
int FirstArg = CommandPos +1;
NumArgs --;
if (! strcmp(command, "open"))
{
/*
* open a database. There has to be one string argument,
* the database filename
*/
if (NumArgs != 1 || !mxIsChar(prhs[FirstArg]))
{
mexPrintf(MSG_NOOPENARG, mexFunctionName());
mxFree(command);
mexErrMsgTxt(MSG_INVALIDARG);
}
// TODO: possible Memoryleak 'command not freed' when getstring fails
char* dbname = getstring(prhs[FirstArg]);
/*
* Is there an database ID? The close the database with the same id
*/
if (db_id > 0 && g_dbs[db_id])
{
sqlite3_close(g_dbs[db_id]);
g_dbs[db_id] = 0;
}
/*
* If there isn't an database id, then try to get one
*/
if (db_id < 0)
{
for (i = 0; i < MaxNumOfDbs; i++)
{
if (g_dbs[i] == 0)
{
db_id = i;
break;
}
}
}
/*
* no database id? sorry, database id table full
*/
if (db_id < 0)
{
plhs[0] = mxCreateDoubleScalar((double) 0);
mexPrintf(MSG_NOFREESLOT);
mxFree(command);
mxFree(dbname);
mexErrMsgTxt(MSG_IMPOSSIBLE);
}
/*
* Open the database
*/
int rc = sqlite3_open(dbname, &g_dbs[db_id]);
if (rc)
{
/*
* Anything wrong? free the database id and inform the user
*/
mexPrintf(MSG_CANTOPEN, sqlite3_errmsg(g_dbs[db_id]));
sqlite3_close(g_dbs[db_id]);
g_dbs[db_id] = 0;
plhs[0] = mxCreateDoubleScalar((double) 0);
mxFree(command);
mxFree(dbname);
mexErrMsgTxt(MSG_IMPOSSIBLE);
}
/*
* Set Default Busytimeout
*/
rc = sqlite3_busy_timeout(g_dbs[db_id], DEFAULT_BUSYTIMEOUT);
if (rc)
{
/*
* Anything wrong? free the database id and inform the user
*/
mexPrintf(MSG_CANTOPEN, sqlite3_errmsg(g_dbs[db_id]));
sqlite3_close(g_dbs[db_id]);
g_dbs[db_id] = 0;
plhs[0] = mxCreateDoubleScalar((double) 0);
mxFree(command);
mxFree(dbname);
mexErrMsgTxt(MSG_BUSYTIMEOUTFAIL);
}
/*
* return value will be the used database id
*/
plhs[0] = mxCreateDoubleScalar((double) db_id +1);
mxFree(dbname);
}
else if (! strcmp(command, "close"))
{
/*
* close a database
*/
/*
* There should be no Argument to close
*/
if (NumArgs > 0)
{
mxFree(command);
mexErrMsgTxt(MSG_INVALIDARG);
}
/*
* if the database id is < 0 than close all open databases
*/
if (db_id < 0)
{
for (i = 0; i < MaxNumOfDbs; i++)
{
if (g_dbs[i])
{
sqlite3_close(g_dbs[i]);
g_dbs[i] = 0;
}
}
}
else
{
/*
* If the database is open, then close it. Otherwise
* inform the user
*/
if (! g_dbs[db_id])
{
mxFree(command);
mexErrMsgTxt(MSG_DBNOTOPEN);
}
else
{
sqlite3_close(g_dbs[db_id]);
g_dbs[db_id] = 0;
}
}
}
else if (! strcmp(command, "status"))
{
/*
* There should be no Argument to status
*/
if (NumArgs > 0)
{
mxFree(command);
mexErrMsgTxt(MSG_INVALIDARG);
}
for (i = 0; i < MaxNumOfDbs; i++)
{
mexPrintf("DB Handle %d: %s\n", i, g_dbs[i] ? "OPEN" : "CLOSED");
}
}
else if (! _strcmpi(command, "setbusytimeout"))
{
/*
* There should be one Argument, the Timeout in ms
*/
if (NumArgs != 1 || !mxIsNumeric(prhs[FirstArg]))
{
mxFree(command);
mexErrMsgTxt(MSG_INVALIDARG);
}
if (! g_dbs[db_id])
{
mxFree(command);
mexErrMsgTxt(MSG_DBNOTOPEN);
}
else
{
/*
* Set Busytimeout
*/
int TimeoutValue = getinteger(prhs[FirstArg]);
int rc = sqlite3_busy_timeout(g_dbs[db_id], TimeoutValue);
if (rc)
{
/*
* Anything wrong? free the database id and inform the user
*/
mexPrintf(MSG_CANTOPEN, sqlite3_errmsg(g_dbs[db_id]));
sqlite3_close(g_dbs[db_id]);
g_dbs[db_id] = 0;
plhs[0] = mxCreateDoubleScalar((double) 0);
mxFree(command);
mexErrMsgTxt(MSG_BUSYTIMEOUTFAIL);
}
}
}
else
{
/*
* database id < 0? Thats an error...
*/
if (db_id < 0)
{
mexPrintf(MSG_INVALIDDBHANDLE);
mxFree(command);
mexErrMsgTxt(MSG_IMPOSSIBLE);
}
/*
* database not open? -> error
*/
if (!g_dbs[db_id])
{
mxFree(command);
mexErrMsgTxt(MSG_DBNOTOPEN);
}
/*
* Every unknown command is treated as an sql query string
*/
const char* query = command;
/*
* a query shuld have no arguments
*/
if (NumArgs > 0)
{
mxFree(command);
mexErrMsgTxt(MSG_INVALIDARG);
}
/*
* emulate the "show tables" sql query
*/
if (! _strcmpi(query, "show tables"))
{
query = "SELECT name as tablename FROM sqlite_master "
"WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' "
"UNION ALL "
"SELECT name as tablename FROM sqlite_temp_master "
"WHERE type IN ('table','view') "
"ORDER BY 1";
}
/*
* complete the query
*/
if (sqlite3_complete(query))
{
mxFree(command);
mexErrMsgTxt(MSG_INVQUERY);
}
sqlite3_stmt *st;
/*
* and prepare it
* if anything is wrong with the query, than complain about it.
*/
if (sqlite3_prepare_v2(g_dbs[db_id], query, -1, &st, 0))
{
if (st)
sqlite3_finalize(st);
mxFree(command);
mexErrMsgIdAndTxt(TransErrToIdent(g_dbs[db_id]), sqlite3_errmsg(g_dbs[db_id]));
}
/*
* Any results?
*/
int ncol = sqlite3_column_count(st);
if (ncol > 0)
{
char **fieldnames = new char *[ncol]; /* Column names */
Values* allrows = 0; /* All query results */
Values* lastrow = 0; /* pointer to the last result row */
int rowcount = 0; /* number of result rows */
/*
* Get the column names of the result set
*/
for(i=0; i<ncol; i++)
{
const char *cname = sqlite3_column_name(st, i);
fieldnames[i] = new char [strlen(cname) +1];
strcpy (fieldnames[i], cname);
/*
* replace invalid chars by '_', so we can build
* valid MATLAB structs
*/
char *mk_c = fieldnames[i];
while (*mk_c)
{
if ((*mk_c == ' ') || (*mk_c == '*') || (*mk_c == '?'))
*mk_c = '_';
mk_c++;
}
}
/*
* get the result rows from the engine
*
* We cannot get the number of result lines, so we must
* read them in a loop and save them into an temporary list.
* Later, we can transfer this List into an MATLAB array of structs.
* This way, we must allocate enough memory for two result sets,
* but we save time by allocating the MATLAB Array at once.
*/
for(;;)
{
/*
* Advance to teh next row
*/
int step_res = sqlite3_step(st);
/*
* no row left? break out of the loop
*/
if (step_res != SQLITE_ROW)
break;
/*
* get new memory for the result
*/
Values* RecordValues = new Values(ncol);
Value *v = RecordValues->m_Values;
for (int j = 0; j < ncol; j++, v++)
{
int fieldtype = sqlite3_column_type(st,j);
v->m_Type = fieldtype;
v->m_Size = 0;
switch (fieldtype)
{
case SQLITE_NULL: v->m_NumericValue = g_NaN; break;
case SQLITE_INTEGER: v->m_NumericValue = (double) sqlite3_column_int(st, j); break;
case SQLITE_FLOAT: v->m_NumericValue = (double) sqlite3_column_double(st, j); break;
case SQLITE_TEXT: v->m_StringValue = strnewdup((const char*) sqlite3_column_text(st, j)); break;
case SQLITE_BLOB:
{
v->m_Size = sqlite3_column_bytes(st,j);
if (v->m_Size > 0)
{
v->m_StringValue = new char[v->m_Size];
memcpy(v->m_StringValue, sqlite3_column_blob(st,j), v->m_Size);
}
else
{
v->m_Size = 0;
}
}
break;
default:
mxFree(command);
mexErrMsgTxt(MSG_UNKNWNDBTYPE);
}
}
/*
* and add this row to the list of all result rows
*/
if (! lastrow)
{
allrows = lastrow = RecordValues;
}
else
{
lastrow->m_NextValues = RecordValues;
lastrow = lastrow->m_NextValues;
}
/*
* we have one more...
*/
rowcount ++;
}
/*
* end the sql engine
*/
sqlite3_finalize(st);
/*
* got nothing? return an empty result to MATLAB
*/
if (rowcount == 0 || ! allrows)
{
if (!( plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL) ))
{
mxFree(command);
mexErrMsgTxt(MSG_CANTCREATEOUTPUT);
}
}
else
{
/*
* Allocate an array of MATLAB structs to return as result
*/
int ndims[2];
ndims[0] = rowcount;
ndims[1] = 1;
if (( plhs[0] = mxCreateStructArray (2, ndims, ncol, (const char**)fieldnames)) == 0)
{
mxFree(command);
mexErrMsgTxt(MSG_CANTCREATEOUTPUT);
}
/*
* transfer the result rows from the temporary list into the result array
*/
lastrow = allrows;
i = 0;
while(lastrow)
{
Value* recordvalue = lastrow->m_Values;
for (int j = 0; j < ncol; j++, recordvalue++)
{
if (recordvalue -> m_Type == SQLITE_TEXT)
{
mxArray* c = mxCreateString(recordvalue->m_StringValue);
mxSetFieldByNumber(plhs[0], i, j, c);
}
else if (recordvalue -> m_Type == SQLITE_NULL && !NULLasNaN)
{
mxArray* out_double = mxCreateDoubleMatrix(0,0,mxREAL);
mxSetFieldByNumber(plhs[0], i, j, out_double);
}
else if (recordvalue -> m_Type == SQLITE_BLOB)
{
if (recordvalue->m_Size > 0)
{
int BytePos;
int NumDims[2]={1,1};
NumDims[1]=recordvalue->m_Size;
mxArray*out_uchar8=mxCreateNumericArray(2, NumDims, mxUINT8_CLASS, mxREAL);
unsigned char *v = (unsigned char *) mxGetData(out_uchar8);
memcpy(v, recordvalue->m_StringValue, recordvalue->m_Size);
mxSetFieldByNumber(plhs[0], i, j, out_uchar8);
}
else
{
// empty BLOB
mxArray* out_double = mxCreateDoubleMatrix(0,0,mxREAL);
mxSetFieldByNumber(plhs[0], i, j, out_double);
}
}
else
{
mxArray* out_double = mxCreateDoubleScalar(recordvalue->m_NumericValue);
mxSetFieldByNumber(plhs[0], i, j, out_double);
}
}
allrows = lastrow;
lastrow = lastrow->m_NextValues;
delete allrows;
i++;
}
}
for(int i=0; i<ncol; i++)
delete [] fieldnames[i];
delete [] fieldnames;
}
else
{
/*
* no result, cleanup the sqlite engine
*/
int res = sqlite3_step(st);
sqlite3_finalize(st);
if (!( plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL) ))
{
mexErrMsgTxt(MSG_CANTCREATEOUTPUT);
}
if (res != SQLITE_DONE)
{
mxFree(command);
mexErrMsgIdAndTxt(TransErrToIdent(g_dbs[db_id]), sqlite3_errmsg(g_dbs[db_id]));
}
}
}
mxFree(command);
}
mxArray *get_polarity(Miscellaneous *miscell, PMap *predMap, Node *phi)
{
/* Peer reviewed on 2013.07.22 by Dokhanchi, Adel */
const char *fields[] = {"polarity", "index"};
mxArray *tmp, *Array;
/*mwSize *dims;*/
mwSize dims;
double *pr;
int temp_pol = 0;
Polarity *p;
int i = 0,ii;
int iii=0; /* used for check the index for subformula*/
int jjj=0; /* length-1 of the subformula array */
int *qi;
int temp = 1;
#define subMax 200 /* biggest number of iterations the subformula could store*/
Node *subformula[subMax]; /* subformula array as a cross-reference for the phi*/
/* Initialize some variables for BFS */
queue q;
queue *Q = &q;
init_queue(Q); /*initial the queue*/
qi = &temp;
/*----------------------------------*/
p = (Polarity *)emalloc(sizeof(Polarity));
p->polar = UNDEFINED_POLAR;
tmp = mxCreateStructMatrix(1, 1, 2, fields);
/*-----BFS for formula--------------*/
jjj = BreadthFirstTraversal(Q,phi,subformula,qi);
for(iii=1; iii<jjj; iii++) /* check the index for subformula*/
{
if(iii != subformula[iii]->index)
mexErrMsgTxt("mx_dp_taliro: subformula not in right index!");
}
make_predicate_list(miscell, p);
/* predicate list*/
pr = mxCalloc(miscell->dp_taliro_param.nPred, sizeof(double));
/*dims = &(miscell->dp_taliro_param.nPred);*/
dims = (mwSize)(miscell->dp_taliro_param.nPred);
Array = mxCreateDoubleMatrix (1, dims, mxREAL);
for(i = 0;i<miscell->dp_taliro_param.nPred;i++)
{
pr[i] = miscell->pList.pindex[i];
if(pr[i] == -1)
{
pr[i] = 0;
}
}
mxSetPr(Array,pr);
/* predicate list ends*/
/* polarity calculation*/
i = jjj;
while(i>0)
{
switch (subformula[i]->ntyp)
{
case TRUE:
subformula[i]->pol = UNDEFINED_POLAR;
break;
case FALSE:
subformula[i]->pol = UNDEFINED_POLAR;
break;
case VALUE:
subformula[i]->pol = UNDEFINED_POLAR;
break;
case PREDICATE:
/* match predicate index*/
for(ii = 0; ii < miscell->dp_taliro_param.nPred; ii++)
{
if(miscell->predMap[ii].str != NULL)
{
if(strcmp(subformula[i]->sym->name,predMap[ii].str)==0)
{
if(predMap[ii].parameter!=NULL){
subformula[i]->pol = POSITIVE_POLAR;
}
else{
subformula[i]->pol = UNDEFINED_POLAR;
}
}
}
}
break;
case NOT:
subformula[i]->pol = flip(subformula[i]->lft->pol);
/*p->polar = flip(p->polar);*/
break;
case AND:
subformula[i]->pol = mix(subformula[i]->lft->pol, subformula[i]->rgt->pol);
break;
case OR:
subformula[i]->pol = mix(subformula[i]->lft->pol, subformula[i]->rgt->pol);
break;
case NEXT:
subformula[i]->pol = subformula[i]->lft->pol;
break;
case WEAKNEXT:
subformula[i]->pol = subformula[i]->lft->pol;
break;
case ALWAYS:
if(subformula[i]->time.l_par == 1 && subformula[i]->time.u_par == 0)
{
subformula[i]->pol = pos(subformula[i]->rgt->pol);
}
else if(subformula[i]->time.l_par == 0 && subformula[i]->time.u_par == 1)
{
subformula[i]->pol = neg(subformula[i]->rgt->pol);
}
else if(subformula[i]->time.l_par == 1 && subformula[i]->time.u_par == 1)
{
subformula[i]->pol = MIXED_POLAR;
}
else
{
subformula[i]->pol = subformula[i]->rgt->pol;
}
break;
case EVENTUALLY:
if(subformula[i]->time.l_par == 1 && subformula[i]->time.u_par == 0)
{
subformula[i]->pol = neg(subformula[i]->rgt->pol);
}
else if(subformula[i]->time.l_par == 0 && subformula[i]->time.u_par == 1)
{
subformula[i]->pol = pos(subformula[i]->rgt->pol);
}
else if(subformula[i]->time.l_par == 1 && subformula[i]->time.u_par == 1)
{
subformula[i]->pol = MIXED_POLAR;
}
else
{
subformula[i]->pol = subformula[i]->rgt->pol;
}
break;
case U_OPER:
if(subformula[i]->time.l_par == 1 && subformula[i]->time.u_par == 0)
{
temp_pol = NEGATIVE_POLAR;
subformula[i]->pol = mix(temp_pol,mix(subformula[i]->lft->pol,subformula[i]->rgt->pol));
}
else if(subformula[i]->time.l_par == 0 && subformula[i]->time.u_par == 1)
{
temp_pol = POSITIVE_POLAR;
subformula[i]->pol = mix(temp_pol,mix(subformula[i]->lft->pol,subformula[i]->rgt->pol));
}
else if(subformula[i]->time.l_par == 1 && subformula[i]->time.u_par == 1)
{
subformula[i]->pol = MIXED_POLAR;
}
else
{
subformula[i]->pol = mix(subformula[i]->lft->pol,subformula[i]->rgt->pol);
}
break;
case V_OPER:
if(subformula[i]->time.l_par == 1 && subformula[i]->time.u_par == 0)
{
/* temp_pol = POSITIVE_POLAR;
subformula[i]->pol = mix(temp_pol,mix(subformula[i]->lft->pol,subformula[i]->rgt->pol));*/
temp_pol = NEGATIVE_POLAR;
subformula[i]->pol = flip(mix(temp_pol,mix(flip(subformula[i]->lft->pol),flip(subformula[i]->rgt->pol))));
}
else if(subformula[i]->time.l_par == 0 && subformula[i]->time.u_par == 1)
{
/* temp_pol = NEGATIVE_POLAR;
subformula[i]->pol = mix(temp_pol,mix(subformula[i]->lft->pol,subformula[i]->rgt->pol));*/
temp_pol = POSITIVE_POLAR;
subformula[i]->pol = flip(mix(temp_pol,mix(flip(subformula[i]->lft->pol),flip(subformula[i]->rgt->pol))));
}
else if(subformula[i]->time.l_par == 1 && subformula[i]->time.u_par == 1)
{
subformula[i]->pol = MIXED_POLAR;
}
else
{
subformula[i]->pol = mix(subformula[i]->lft->pol,subformula[i]->rgt->pol);
}
break;
default:
break;
}
i--;
}
/* polarity calculation ends*/
mxSetField(tmp, 0, "polarity", mxCreateDoubleScalar(subformula[1]->pol));
mxSetField(tmp, 0, "index", Array);
return (tmp);
}
/*
* [type,num_constraint,constraint_val,dconstraint_val,constraint_name,lower_bound,upper_bound] = testSingleTimeKinCnstmex(kinCnst_ptr,q,t)
* @param kinCnst_ptr A pointer to a SingleTimeKinematicConstraint object
* @param q A nqx1 double vector
* @param t A double scalar, the time to evaluate constraint value, bounds and name. This is optional.
* @retval type The type of the constraint
* @retval num_constraint The number of constraint active at time t
* @retval constraint_val The value of the constraint at time t
* @retval dconstraint_val The gradient of the constraint w.r.t q at time t
* @retval constraint_name The name of the constraint at time t
* @retval lower_bound The lower bound of the constraint at time t
* @retval upper_bound The upper bound of the constraint at time t
* */
void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])
{
if((nrhs!=3 && nrhs != 2)||nlhs != 7)
{
mexErrMsgIdAndTxt("Drake:testSingleTimeKinCnstmex:BadInputs","Usage [type, num_cnst,cnst_val,dcnst_val,cnst_name,lb,ub] = testSingleTimeKinKinCnstmex(kinCnst,q,t)");
}
SingleTimeKinematicConstraint* cnst = (SingleTimeKinematicConstraint*) getDrakeMexPointer(prhs[0]);
double* t_ptr;
if(nrhs == 2)
{
t_ptr = nullptr;
}
else
{
int num_t = mxGetNumberOfElements(prhs[2]);
if(num_t == 0)
{
t_ptr = nullptr;
}
if(num_t == 1)
{
t_ptr = mxGetPrSafe(prhs[2]);
}
if(num_t>1)
{
mexErrMsgIdAndTxt("Drake:testSingleTimeKinCnstmex:BadInputs","t must be either empty or a single number");
}
}
int type = cnst->getType();
int num_cnst = cnst->getNumConstraint(t_ptr);
//mexPrintf("num_cnst = %d\n",num_cnst);
int nq = cnst->getRobotPointer()->num_positions;
Map<VectorXd> q(mxGetPrSafe(prhs[1]), nq);
VectorXd v = VectorXd::Zero(0);
cnst->getRobotPointer()->doKinematics(q, v);
VectorXd c(num_cnst);
MatrixXd dc(num_cnst,nq);
cnst->eval(t_ptr,c,dc);
//mexPrintf("get c,dc\n");
VectorXd lb(num_cnst);
VectorXd ub(num_cnst);
cnst->bounds(t_ptr,lb,ub);
//mexPrintf("get lb, ub\n");
std::vector<std::string> cnst_names;
cnst->name(t_ptr,cnst_names);
//mexPrintf("get name\n");
int retvec_size;
if(num_cnst == 0)
{
retvec_size = 0;
}
else
{
retvec_size = 1;
}
plhs[0] = mxCreateDoubleScalar((double) type);
plhs[1] = mxCreateDoubleScalar((double) num_cnst);
plhs[2] = mxCreateDoubleMatrix(num_cnst,retvec_size,mxREAL);
memcpy(mxGetPrSafe(plhs[2]),c.data(),sizeof(double)*num_cnst);
plhs[3] = mxCreateDoubleMatrix(num_cnst,nq,mxREAL);
memcpy(mxGetPrSafe(plhs[3]),dc.data(),sizeof(double)*num_cnst*nq);
int name_ndim = 1;
mwSize name_dims[] = {(mwSize) num_cnst};
plhs[4] = mxCreateCellArray(name_ndim,name_dims);
mxArray *name_ptr;
for(int i = 0;i<num_cnst;i++)
{
name_ptr = mxCreateString(cnst_names[i].c_str());
mxSetCell(plhs[4],i,name_ptr);
}
plhs[5] = mxCreateDoubleMatrix(num_cnst,retvec_size,mxREAL);
plhs[6] = mxCreateDoubleMatrix(num_cnst,retvec_size,mxREAL);
memcpy(mxGetPrSafe(plhs[5]),lb.data(),sizeof(double)*num_cnst);
memcpy(mxGetPrSafe(plhs[6]),ub.data(),sizeof(double)*num_cnst);
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if (nrhs < 9)
{
mexErrMsgTxt("The number of arguments should be nine.\n");
}
double *C1, *C2;
double w = 0;
C1 = mxGetPr(prhs[0]);
C2 = mxGetPr(prhs[1]);
/* dimensions of input matrices */
integer d, n, rotated, isclosed, onlyDP, skipm, autoselectC;
n = mxGetM(prhs[0]);
d = mxGetN(prhs[0]);
std::cout << "(n, d):" << n << "," << d << std::endl;
if (mxGetM(prhs[1]) != n || mxGetN(prhs[1]) != d)
{
mexErrMsgTxt("The size of matrix C2 does not match the size of C1.\n");
}
w = mxGetScalar(prhs[2]);
rotated = static_cast<integer> (mxGetScalar(prhs[3]));
isclosed = static_cast<integer> (mxGetScalar(prhs[4]));
onlyDP = static_cast<integer> (mxGetScalar(prhs[5]));
skipm = static_cast<integer> (mxGetScalar(prhs[6]));
char methodname[30] = "";
mxGetString(prhs[7], methodname, 30);
autoselectC = static_cast<integer> (mxGetScalar(prhs[8]));
init_genrand(0);
CheckMemoryDeleted = new std::map<integer *, integer>;
integer numofmanis = 3;
integer numofmani1 = 1;
integer numofmani2 = 1;
integer numofmani3 = 1;
L2SphereVariable FNSV(n);
OrthGroupVariable OGV(d);
EucVariable EucV(1);
ProductElement *Xopt = new ProductElement(numofmanis, &FNSV, numofmani1, &OGV, numofmani2, &EucV, numofmani3);
bool swap;
plhs[2] = mxCreateDoubleMatrix(5, 1, mxREAL);
plhs[3] = mxCreateDoubleMatrix(5, 1, mxREAL);
double *fopts = mxGetPr(plhs[2]), *comtime = mxGetPr(plhs[3]);
integer ns, lms;
DriverElasticCurvesRO(C1, C2, d, n, w, rotated != 0, isclosed != 0, onlyDP != 0, skipm, methodname,
autoselectC, Xopt, swap, fopts, comtime, ns, lms);
/*create output matrix*/
integer sizex = n + d * d + 1;
plhs[0] = mxCreateDoubleMatrix(sizex, 1, mxREAL);
double *opt = mxGetPr(plhs[0]);
plhs[1] = mxCreateDoubleScalar(static_cast<double> (swap));
plhs[4] = mxCreateDoubleScalar(static_cast<double> (ns));
plhs[5] = mxCreateDoubleScalar(static_cast<double> (lms));
const double *Xoptptr = Xopt->ObtainReadData();
integer inc = 1;
dcopy_(&sizex, const_cast<double *> (Xoptptr), &inc, opt, &inc);
delete Xopt;
std::map<integer *, integer>::iterator iter = CheckMemoryDeleted->begin();
for (iter = CheckMemoryDeleted->begin(); iter != CheckMemoryDeleted->end(); iter++)
{
if (iter->second != 1)
std::cout << "Global address:" << iter->first << ", sharedtimes:" << iter->second << std::endl;
}
delete CheckMemoryDeleted;
return;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
#define B_OUT plhs[0]
#define X_IN prhs[0]
#define Y_IN prhs[1]
#define Kmax_IN prhs[2]
#define D_IN prhs[3]
int N,p,q;
int i,j;
//mexPrintf("n par %d\n",nrhs);
N = mxGetN(X_IN);
p = mxGetM(X_IN);
q = mxGetM(Y_IN);
double *x_single = mxGetPr(X_IN);
double *y_single = mxGetPr(Y_IN);
// compute the x and y to send in input
double** x = new double*[p];
double** y = new double*[q];
for(j=0;j<p;j++){
x[j] = new double[N];
for(i=0;i<N;i++)
x[j][i] = x_single[j + p*i];
}
for(j=0;j<q;j++){
y[j] = new double[N];
for(i=0;i<N;i++)
y[j][i] = y_single[j + q*i];
}
int Kmax = mxGetScalar(Kmax_IN);
int D = mxGetScalar(D_IN);
/*
mexPrintf("N %d\n",N);
mexPrintf("X[0] %f\n",*X);
mexPrintf("Y[0] %f\n",*Y);
mexPrintf("Kmax %d\n",Kmax);
mexPrintf("D %d",D);
*/
double res = RICrndFerns(x,y,N,p,q,Kmax,D);
B_OUT = mxCreateDoubleScalar(res);
for(j=0;j<p;j++)
delete[] x[j];
delete[] x;
for(j=0;j<q;j++)
delete[] y[j];
delete[] y;
return;
}
mxArray *sf_c7_ekffede_get_autoinheritance_info(void)
{
const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters",
"outputs", "locals" };
mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5,
autoinheritanceFields);
{
mxArray *mxChecksum = mxCreateDoubleMatrix(4,1,mxREAL);
double *pr = mxGetPr(mxChecksum);
pr[0] = (double)(869705337U);
pr[1] = (double)(4037793131U);
pr[2] = (double)(919190404U);
pr[3] = (double)(3945250788U);
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)(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));
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_c45_Expriment_Gaze_get_autoinheritance_info(void)
{
const char *autoinheritanceFields[] = { "checksum", "inputs", "parameters",
"outputs", "locals" };
mxArray *mxAutoinheritanceInfo = mxCreateStructMatrix(1,1,5,
autoinheritanceFields);
{
mxArray *mxChecksum = mxCreateString("PBOOE2ONCJlr45MWsYJj7G");
mxSetField(mxAutoinheritanceInfo,0,"checksum",mxChecksum);
}
{
const char *dataFields[] = { "size", "type", "complexity" };
mxArray *mxData = mxCreateStructMatrix(1,6,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));
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)(6);
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_controller1_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)(3719275678U);
pr[1] = (double)(4192044686U);
pr[2] = (double)(4111541287U);
pr[3] = (double)(4053187991U);
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);
}
return(mxAutoinheritanceInfo);
}
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);
}