static mxArray*
resize_property_structure(mxArray *pprop, int size)
{
mxArray *newpprop;
mxArray *pattr, *pvalue;
int nump, k;
const char *fields[] = {"attr","name"};
/* new structure array */
newpprop = mxCreateStructMatrix(1,size, 2, fields);
/* copy over the old structure array */
if (pprop == NULL)
nump = 0; /* first one */
else
nump = mxGetM(pprop) * mxGetN(pprop);
for (k=0; k<nump; k++) {
pattr = mxGetFieldByNumber(pprop, k, 0);
pvalue = mxGetFieldByNumber(pprop, k, 1);
mxSetFieldByNumber(newpprop, k, 0, pattr);
mxSetFieldByNumber(newpprop, k, 1, pvalue);
}
/* destroy the old structure array */
if (pprop != NULL)
mxDestroyArray(pprop);
return newpprop;
}
DLL_EXPORT_SYM
void mexFunction(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) {
if (nrhs < 1) {
mexPrintf("Usage: publishLCMLog(lcm_log)\n");
return;
}
if (!lcm) lcm = lcm_create(NULL);
if (!lcm) mexErrMsgTxt("failed to create lcm node");
char* channel;
mxArray* data;
int channel_field_number = mxGetFieldNumber(prhs[0], "channel"),
data_field_number = mxGetFieldNumber(prhs[0], "data");
if (channel_field_number < 0 || data_field_number < 0)
mexErrMsgTxt(
"publishLCMLog failed: input must be a structure with fields 'channel' "
"and 'data'");
for (size_t i = 0; i < mxGetNumberOfElements(prhs[0]); i++) {
channel =
mxArrayToString(mxGetFieldByNumber(prhs[0], i, channel_field_number));
data = mxGetFieldByNumber(prhs[0], i, data_field_number);
lcm_publish(lcm, channel, mxGetData(data), mxGetNumberOfElements(data));
mxFree(channel);
}
}
/* Create a default freeman pyramid cache control structure,
and then customize it with the values from a matlab
structure */
int mexFreemanCacheCntrlStruct( const mxArray *mxStruct,
FreemanCacheCntrlStruct **fpcc )
{
mxArray *field;
double *ptr, ftmp;
int fn, m, n, k, itmp;
int nOrient, nScale;
/* make sure mxStruct is a structure */
if( !mxIsStruct(mxStruct) )
mexErrMsgTxt( "Freeman cache control structure expected" );
/* start with a default control structure */
*fpcc = defaultFreemanCacheCntrlStruct();
/* get the cacheFiles flags if they are specified */
fn = mxGetFieldNumber( mxStruct, "cacheFiles" );
if( fn >= 0 ) {
field = mxGetFieldByNumber( mxStruct, 0, fn );
m = mxGetM(field);
n = mxGetN(field);
if( min(m,n) != 1 )
mexErrMsgTxt( "cacheFiles - must be a vector" );
n = max(m,n);
if( n > NUMCODE )
mexErrMsgTxt( "cacheFiles - too many values" );
ptr = mxGetPr(field);
for( k = 0; k < n; k++ ) {
itmp = (int)ptr[k];
if( itmp != 0 && itmp != 1 )
mexErrMsgTxt( "cacheFiles - elements must be 0 or 1" );
(*fpcc)->cacheFiles[k] = itmp;
}
}
/* get the pathNameCache field */
fn = mxGetFieldNumber( mxStruct, "pathNameCache" );
if( fn >= 0 ) {
field = mxGetFieldByNumber( mxStruct, 0, fn );
if( !mxIsChar( field ) )
mexErrMsgTxt( "pathNameCache - must be a string" );
if( mxGetM(field)*mxGetN(field) > MAXLEN - 1 )
mexErrMsgTxt( "pathNameCache - string too long" );
mxGetString( field, (*fpcc)->pathNameCache, MAXLEN - 1 );
}
/* get the pathNameCache field */
fn = mxGetFieldNumber( mxStruct, "rootNameCache" );
if( fn >= 0 ) {
field = mxGetFieldByNumber( mxStruct, 0, fn );
if( !mxIsChar( field ) )
mexErrMsgTxt( "rootNameCache - must be a string" );
if( mxGetM(field)*mxGetN(field) > MAXLEN - 1 )
mexErrMsgTxt( "rootNameCache - string too long" );
mxGetString( field, (*fpcc)->rootNameCache, MAXLEN - 1 );
}
}
int PopulateParams(const mxArray *params, PogsData<T, T*> *pogs_data) {
// Check if parameter exists in params, then make sure that it has
// dimension 1x1 and finally set the corresponding value in pogs_data.
int rel_tol_idx = mxGetFieldNumber(params, "rel_tol");
if (rel_tol_idx != -1) {
mxArray *arr = mxGetFieldByNumber(params, 0, rel_tol_idx);
if (mxGetM(arr) != 1 || mxGetN(arr) != 1) {
mexErrMsgIdAndTxt("MATLAB:pogs:dimensionMismatch",
"Parameter rel_tol must have dimension (1,1)");
return 1;
}
pogs_data->rel_tol = GetVal<T>(mxGetPr(arr), 0, mxGetClassID(arr));
}
int abs_tol_idx = mxGetFieldNumber(params, "abs_tol");
if (abs_tol_idx != -1) {
mxArray *arr = mxGetFieldByNumber(params, 0, abs_tol_idx);
if (mxGetM(arr) != 1 || mxGetN(arr) != 1) {
mexErrMsgIdAndTxt("MATLAB:pogs:dimensionMismatch",
"Parameter abs_tol must have dimension (1,1)");
return 1;
}
pogs_data->abs_tol = GetVal<T>(mxGetPr(arr), 0, mxGetClassID(arr));
}
int rho_idx = mxGetFieldNumber(params, "rho");
if (rho_idx != -1) {
mxArray *arr = mxGetFieldByNumber(params, 0, rho_idx);
if (mxGetM(arr) != 1 || mxGetN(arr) != 1) {
mexErrMsgIdAndTxt("MATLAB:pogs:dimensionMismatch",
"Parameter rho must have dimension (1,1)");
return 1;
}
pogs_data->rho = GetVal<T>(mxGetPr(arr), 0, mxGetClassID(arr));
}
int max_iter_idx = mxGetFieldNumber(params, "max_iter");
if (max_iter_idx != -1) {
mxArray *arr = mxGetFieldByNumber(params, 0, max_iter_idx);
if (mxGetM(arr) != 1 || mxGetN(arr) != 1) {
mexErrMsgIdAndTxt("MATLAB:pogs:dimensionMismatch",
"Parameter max_iter must have dimension (1,1)");
return 1;
}
pogs_data->max_iter =
GetVal<unsigned int>(mxGetPr(arr), 0, mxGetClassID(arr));
}
int quiet_idx = mxGetFieldNumber(params, "quiet");
if (quiet_idx != -1) {
mxArray *arr = mxGetFieldByNumber(params, 0, quiet_idx);
if (mxGetM(arr) != 1 || mxGetN(arr) != 1) {
mexErrMsgIdAndTxt("MATLAB:pogs:dimensionMismatch",
"Parameter quiet must have dimension (1,1)");
return 1;
}
pogs_data->quiet = GetVal<bool>(mxGetPr(arr), 0, mxGetClassID(arr));
}
return 0;
}
/* assign c-node MATLAB structure pointers to C structure pointers */
void GetCnPtrs( int NumberParityBits, const mxArray *c_nodes_mx, c_node *c_nodes )
{
int i;
for(i=0; i< NumberParityBits; i++){
c_nodes[i].degree = mxGetData( mxGetFieldByNumber(c_nodes_mx, i, 0) );
c_nodes[i].index = mxGetData( mxGetFieldByNumber(c_nodes_mx, i, 1) );
c_nodes[i].message = mxGetData( mxGetFieldByNumber(c_nodes_mx, i, 2) );
c_nodes[i].socket = mxGetData( mxGetFieldByNumber(c_nodes_mx, i, 3) );
}
}
ostrm& json( ostrm& S, const mxArray *M ) {
// convert Matlab mxArray to JSON string
siz i, j, m, n=mxGetNumberOfElements(M);
void *A=mxGetData(M); ostrm *nms;
switch( mxGetClassID(M) ) {
case mxDOUBLE_CLASS: return json(S,(double*) A,n);
case mxSINGLE_CLASS: return json(S,(float*) A,n);
case mxINT64_CLASS: return json(S,(int64_t*) A,n);
case mxUINT64_CLASS: return json(S,(uint64_t*) A,n);
case mxINT32_CLASS: return json(S,(int32_t*) A,n);
case mxUINT32_CLASS: return json(S,(uint32_t*) A,n);
case mxINT16_CLASS: return json(S,(int16_t*) A,n);
case mxUINT16_CLASS: return json(S,(uint16_t*) A,n);
case mxINT8_CLASS: return json<int8_t,int32_t>(S,(int8_t*) A,n);
case mxUINT8_CLASS: return json<uint8_t,uint32_t>(S,(uint8_t*) A,n);
case mxLOGICAL_CLASS: return json<uint8_t,uint32_t>(S,(uint8_t*) A,n);
case mxCHAR_CLASS: return json(S,mxArrayToString(M));
case mxCELL_CLASS:
S << "["; for(i=0; i<n-1; i++) json(S,mxGetCell(M,i)) << ",";
if(n>0) json(S,mxGetCell(M,n-1)); S << "]"; return S;
case mxSTRUCT_CLASS:
if(n==0) { S<<"{}"; return S; } m=mxGetNumberOfFields(M);
if(m==0) { S<<"["; for(i=0; i<n; i++) S<<"{},"; S<<"]"; return S; }
if(n>1) S<<"["; nms=new ostrm[m];
for(j=0; j<m; j++) json(nms[j],mxGetFieldNameByNumber(M,j));
for(i=0; i<n; i++) for(j=0; j<m; j++) {
if(j==0) S << "{"; S << nms[j].str() << ":";
json(S,mxGetFieldByNumber(M,i,j)) << ((j<m-1) ? "," : "}");
if(j==m-1 && i<n-1) S<<",";
}
if(n>1) S<<"]"; delete [] nms; return S;
default:
mexErrMsgTxt( "Unknown type." ); return S;
}
}
const char *matlab_matrix_to_model(struct model *model_, const mxArray *matlab_struct)
{
int i, num_of_fields;
int nr_w;
double *ptr;
int id = 0;
int n, w_size;
mxArray **rhs;
num_of_fields = mxGetNumberOfFields(matlab_struct);
rhs = (mxArray **) mxMalloc(sizeof(mxArray *)*num_of_fields);
for(i=0;i<num_of_fields;i++)
rhs[i] = mxGetFieldByNumber(matlab_struct, 0, i);
model_->nr_class=0;
nr_w=0;
model_->nr_feature=0;
model_->w=NULL;
model_->label=NULL;
// Parameters
ptr = mxGetPr(rhs[id]);
model_->param.solver_type = (int)ptr[0];
id++;
// nr_class
ptr = mxGetPr(rhs[id]);
model_->nr_class = (int)ptr[0];
id++;
if(model_->nr_class==2 && model_->param.solver_type != MCSVM_CS)
nr_w=1;
else
nr_w=model_->nr_class;
// nr_feature
ptr = mxGetPr(rhs[id]);
model_->nr_feature = (int)ptr[0];
id++;
// bias
ptr = mxGetPr(rhs[id]);
model_->bias = (int)ptr[0];
id++;
if(model_->bias>=0)
n=model_->nr_feature+1;
else
n=model_->nr_feature;
w_size = n;
// Label
if(mxIsEmpty(rhs[id]) == 0)
{
model_->label = Malloc(int, model_->nr_class);
ptr = mxGetPr(rhs[id]);
for(i=0;i<model_->nr_class;i++)
model_->label[i] = (int)ptr[i];
}
GPUtype *
mxToGPUtype (const mxArray *prhs, GPUmanager *GPUman) {
///mexPrintf("************** begin mx to gputype ****************\n");
//GPUman->extCachePrint();
mxArray * tmp = (mxArray*)prhs;
//mexPrintf("-> %p\n",tmp->reserved2);
//mexPrintf("-> %p\n",tmp->data.number_array.pdata);
//printMx1(tmp, 1);
GPUtype *p = (GPUtype *) GPUman->extCacheGetGPUtypePtr( mxID( prhs));
if (p==NULL) {
// have to get it with slot number
GPUman->extCacheCacheMiss();
mxArray *lhs[1];
mexCallMATLAB(1, &lhs[0], 1, (mxArray**) &prhs, "struct");
int slot = (int) mxGetScalar(mxGetFieldByNumber(lhs[0], 0, 0));
//mexPrintf("-> slot %d\n",slot);
mxDestroyArray(lhs[0]);
p = (GPUtype *) GPUman->extCacheGetGPUtypePtrBySlot(slot);
if (p==NULL)
mexErrMsgTxt(ERROR_MXTOGPUTYPE);
}
//mexPrintf("************** end mx to gputype ****************\n");
return p;
}
int bind_params(sqlite3_stmt* stmt, const mxArray *params, int column)
{
TYPECHECK(params, mxSTRUCT_CLASS);
int i, n = mxGetNumberOfFields(params);
for (i = 0; i < n; i++) {
mxArray *array = mxGetFieldByNumber(params, column, i);
mxClassID cls = mxGetClassID(array);
int res;
switch (cls) {
case mxFUNCTION_CLASS:
break;
case mxCHAR_CLASS:
res = bind_string(stmt, i + 1, array);
break;
case mxSINGLE_CLASS:
case mxDOUBLE_CLASS:
res = bind_double(stmt, i + 1, array);
break;
default: /* anything else is an integer */
res = bind_int64(stmt, i + 1, array);
}
if (res != SQLITE_OK) {
return res;
}
}
return SQLITE_OK;
}
void
mexFunction (int nlhs, mxArray* plhs[], int nrhs,
const mxArray* prhs[])
{
int i;
mwIndex j;
mxArray *v;
const char *keys[] = { "this", "that" };
if (nrhs != 1 || ! mxIsStruct (prhs[0]))
mexErrMsgTxt ("expects struct");
for (i = 0; i < mxGetNumberOfFields (prhs[0]); i++)
for (j = 0; j < mxGetNumberOfElements (prhs[0]); j++)
{
mexPrintf ("field %s(%d) = ",
mxGetFieldNameByNumber (prhs[0], i), j);
v = mxGetFieldByNumber (prhs[0], j, i);
mexCallMATLAB (0, 0, 1, &v, "disp");
}
v = mxCreateStructMatrix (2, 2, 2, keys);
mxSetFieldByNumber (v, 0, 0, mxCreateString ("this1"));
mxSetFieldByNumber (v, 0, 1, mxCreateString ("that1"));
mxSetFieldByNumber (v, 1, 0, mxCreateString ("this2"));
mxSetFieldByNumber (v, 1, 1, mxCreateString ("that2"));
mxSetFieldByNumber (v, 2, 0, mxCreateString ("this3"));
mxSetFieldByNumber (v, 2, 1, mxCreateString ("that3"));
mxSetFieldByNumber (v, 3, 0, mxCreateString ("this4"));
mxSetFieldByNumber (v, 3, 1, mxCreateString ("that4"));
if (nlhs)
plhs[0] = v;
}
static mxArray*
get_array(YAP_Term ti)
{
if (YAP_IsIntTerm(ti)) {
return mxCreateDoubleScalar(YAP_IntOfTerm(ti));
} else if (YAP_IsFloatTerm(ti)) {
return mxCreateDoubleScalar(YAP_FloatOfTerm(ti));
} else if (YAP_IsAtomTerm(ti)) {
return matlab_getvar(ti);
} else if (YAP_IsPairTerm(ti)) {
YAP_Term tv = YAP_HeadOfTerm(ti);
YAP_Term tf = YAP_TailOfTerm(ti);
const mxArray *mout;
if (!YAP_IsAtomTerm(tv)) {
char s[BUFSIZE];
if (!YAP_StringToBuffer(ti, s, BUFSIZE))
return FALSE;
return mxCreateString(s);
}
mout = matlab_getvar(tv);
if (!mout)
return FALSE;
if (YAP_IsIntTerm(tf)) {
return mxGetFieldByNumber(mout, 0, YAP_IntOfTerm(tf));
} else if (YAP_IsAtomTerm(tf)) {
const char *s=YAP_AtomName(YAP_AtomOfTerm(tf));
return mxGetField(mout, 0, s);
} else {
return NULL;
}
} else {
return (mxArray *)YAP_IntOfTerm(YAP_ArgOfTerm(1,ti));
}
}
//Extracts values form prhs, which are right hand side values in matlab.
Problem::Problem(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
//If field_number != 1 checks are necessary to allow rearanging and skipping fields in input structure
int field_number = mxGetFieldNumber(prhs[1],"res");
if(field_number != -1)
res = mxGetScalar(mxGetFieldByNumber(prhs[1], 0, field_number));
field_number = mxGetFieldNumber(prhs[1],"prec");
if(field_number != -1)
prec = int(mxGetScalar(mxGetFieldByNumber(prhs[1], 0, field_number)));
field_number = mxGetFieldNumber(prhs[1],"vars");
if(field_number != -1)
extract_vars(mxGetFieldByNumber(prhs[1], 0, field_number), var_names, vars);
field_number = mxGetFieldNumber(prhs[1],"cnstrs");
if(field_number != -1)
extract_strings(mxGetFieldByNumber(prhs[1], 0, field_number), cnstrs);
this->plhs = plhs;
this->nlhs = nlhs;
};
ExportMode int* passFunction(const mxArray *ElemData,int *FieldNumbers,
double *r_in, int num_particles, int mode)
#define NUM_FIELDS_2_REMEMBER 1
{ double *M;
int *returnptr;
int fnum,*NewFieldNumbers;
switch(mode)
{ case NO_LOCAL_COPY: /* Not used in AT1.3 Get fields by names from MATLAB workspace */
{
} break;
case MAKE_LOCAL_COPY: /* Find field numbers first
Save a list of field number in an array
and make returnptr point to that array
*/
{
NewFieldNumbers = (int*)mxCalloc(NUM_FIELDS_2_REMEMBER,sizeof(int));
fnum = mxGetFieldNumber(ElemData,"M66");
if(fnum<0)
mexErrMsgTxt("Required field 'M66' was not found in the element data structure");
else
{ NewFieldNumbers[0] = fnum;
M = mxGetPr(mxGetFieldByNumber(ElemData,0,fnum));
returnptr = NewFieldNumbers;
}
} break;
case USE_LOCAL_COPY: /* Get fields from MATLAB using field numbers
The second argument ponter to the array of field
numbers is previously created with
QuadLinPass( ..., MAKE_LOCAL_COPY)
*/
{ M = mxGetPr(mxGetFieldByNumber(ElemData,0,FieldNumbers[0]));
returnptr = FieldNumbers;
} break;
}
Matrix66Pass(r_in, M, num_particles);
return(returnptr);
}
mxArray* GetPointerData(const mxArray *A)
{
mxArray *address, *data;
address = mxGetFieldByNumber(A, 0, 0);
memcpy((void *)(&data), (void *)(mxGetPr(address)), sizeof(data));
return data;
}
mxArray *mxGetField(const mxArray *ptr, int lindex, const char *string)
{
int field_num = mxGetFieldNumber(ptr, string);
if (field_num < 0)
{
return NULL;
}
return mxGetFieldByNumber(ptr, lindex, field_num);
}
void mexFunction( int nlhs, mxArray *plhs[],int nrhs, const mxArray*prhs[] )
{
/* Check for proper number of arguments */
if (!(nrhs == 2) || !(nlhs==0))
{
mexErrMsgTxt("You have to input camera handle");
}
if (!mxIsStruct(prhs[1]))
{
mexErrMsgTxt("That second input has to be an image structure, you know.");
}
int error = 0;
HCAM hCam = *(HCAM *)mxGetPr(prhs[0]);
int pointer_field = mxGetFieldNumber(prhs[1],"pointer");
int ID_field = mxGetFieldNumber(prhs[1],"id");
mxArray *ppointer_field = mxGetFieldByNumber(prhs[1],0,pointer_field);
char *ppImgMem = (char *)*(int *)mxGetPr(ppointer_field);
mxArray *pID_field = mxGetFieldByNumber(prhs[1],0,ID_field);
int id = *(int *)mxGetPr(pID_field);
if (hCam!= NULL)
{
error = is_FreeImageMem(hCam, ppImgMem, id);
if (error != IS_SUCCESS)
{
mexErrMsgTxt("Error freeing image memory");
}
//Close and exit camera
error = is_ExitCamera(hCam );
if (error != IS_SUCCESS)
{
mexErrMsgTxt("Error exiting camera");
}
hCam = NULL;
ppImgMem = NULL;
// mexPrintf("Memory freed. \n");
}
return;
}
/*
* sample file that shows how to transform an array of structs
* containing (id, handle) pairs to a callback list and return the
* pointer to the data. the callback list can thus be passed to the
* second file in this example (exec_callbacks.cpp).
*
* The passed matlab functions must not have any argument as this example here
* doesn't take care of those arguments.
*/
void
mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if (nrhs != 1)
mexErrMsgTxt("Function requires exactly one argument.\n");
if (nlhs != 1)
mexErrMsgTxt("Function returns exactly one value.\n");
if (!mxIsStruct(prhs[0]))
mexErrMsgTxt("Function requires a structure array as argument\n");
int nfields = mxGetNumberOfFields(prhs[0]);
mwSize nstructs = mxGetNumberOfElements(prhs[0]);
std::vector<callback*> *cb_list = new std::vector<callback*>();
// parse each struct
for (mwIndex i = 0; i < nstructs; i++) {
bool id_found = false;
bool fn_found = false;
callback *cb = new callback();
for (int j = 0; j < nfields; j++) {
mxArray *field = mxGetFieldByNumber(prhs[0], i, j);
if (!field) {
mexWarnMsgTxt("Invalid structure found\n");
continue;
}
const char *fname = mxGetFieldNameByNumber(prhs[0], j);
if (!strncmp(fname, "id", sizeof("id"))) {
if (!mxIsNumeric(field) || mxGetNumberOfElements(field) != 1) {
mexWarnMsgTxt("Invalid id (must be numeric scalar).\n");
continue;
}
id_found = true;
cb->id = (int)mxGetScalar(field);
}
else if (!strncmp(fname, "handle", sizeof("handle"))) {
if (!mxIsClass(field, "function_handle")) {
mexWarnMsgTxt("Invalid handle (must be function_handle).\n");
continue;
}
fn_found = true;
cb->fn = field;
}
}
if (!id_found || !fn_found)
delete cb;
else
cb_list->push_back(cb);
}
// return the list
plhs[0] = create_mex_obj(cb_list);
}
void setCameraProperty(const EdsCameraRef handle, const mxArray* mxstruct) {
if (mxIsStruct(mxstruct)) {
unsigned numProperties = mxGetNumberOfFields(mxstruct);
for (unsigned iterProperty = 0; iterProperty < numProperties; ++iterProperty) {
setCameraProperty(handle, stringToCameraProperty(mxGetFieldNameByNumber(mxstruct, iterProperty)), \
mxGetFieldByNumber(mxstruct, 0, iterProperty));
}
} else if (!mxIsEmpty(mxstruct)) {
mexErrMsgIdAndTxt(ERROR_ID, "For setting multiple attributes, a struct array must be provided.");
}
}
double *x_Neumann_conditions_end(const mxArray *prhs[], const int N){
double *a, *bound, *u_x, *a_x;
int *indxPr, i;
indxPr = (int *)mxGetData(prhs[8]);
a= mxGetPr(prhs[6]);
bound = (double *)malloc(N*sizeof(double));
u_x = 3*N + mxGetPr( mxGetFieldByNumber(prhs[7], 0, indxPr[0]-1) );
if( mxGetM(prhs[6]) == 1){
for(i=0; i<N; ++i)
bound[i] = (*a) *u_x[i]*(N-1);
}
else{
a_x = 3*N + mxGetPr( mxGetFieldByNumber(prhs[7], 0, indxPr[1]-1) );
for(i=0; i<N; ++i)
bound[i] =0.5*a_x[i]*u_x[i] +(N-1)*a[i*N +N-1] *u_x[i];
}
return bound;
}
mxArray *mexProblem::GetFieldbyName(const mxArray *S, integer idxstruct, const char *name)
{
integer nfields = mxGetNumberOfFields(S);
for (integer i = 0; i < nfields; i++)
{
if (strcmp(mxGetFieldNameByNumber(S, i), name) == 0)
{
return mxGetFieldByNumber(S, idxstruct, i);
}
}
return nullptr;
};
pParallelTopology topoStructureToC(const mxArray *prhs)
{
mxArray *a;
pParallelTopology pt = (pParallelTopology)malloc(sizeof(ParallelTopology));
a = mxGetFieldByNumber(prhs,0,0);
pt->ndim = (int)*mxGetPr(a);
a = mxGetFieldByNumber(prhs,0,1);
pt->comm = (int)*mxGetPr(a);
int *val;
int i;
val = (int *)mxGetData(mxGetFieldByNumber(prhs,0,2));
for(i = 0; i < pt->ndim; i++) pt->coord[i] = val[i];
val = (int *)mxGetData(mxGetFieldByNumber(prhs,0,3));
for(i = 0; i < pt->ndim; i++) pt->neighbor_left[i] = val[i];
val = (int *)mxGetData(mxGetFieldByNumber(prhs,0,4));
for(i = 0; i < pt->ndim; i++) pt->neighbor_right[i] = val[i];
val = (int *)mxGetData(mxGetFieldByNumber(prhs,0,5));
for(i = 0; i < pt->ndim; i++) pt->nproc[i] = val[i];
for(i = pt->ndim; i < 4; i++) {
pt->coord[i] = 0;
pt->nproc[i] = 1;
}
return pt;
}
void readHaarfeature(
matrix2d haarfeature,
const mxArray * haar_ptr,
int NStructElems,
int nfields
)
{
for(int ifield = 0; ifield < nfields; ifield ++) {
for(int jstruct = 0; jstruct < NStructElems; jstruct ++) {
// get the haarfeature(jstruct).field(ifield)
haarfeature[jstruct][ifield] = matrix<double>(mxGetFieldByNumber(haar_ptr, jstruct, ifield));
//haarfeature[jstruct][ifield] = tmp;
}
}
}
void readParameter(
double * parameter,
const mxArray * parameter_ptr
)
{
mxArray * tmp;
int nfields = mxGetNumberOfFields(parameter_ptr);
for(int ifield = 0, ip = 0; ifield < nfields; ifield ++) {
// get the haarfeature(jstruct).field(ifield)
tmp = mxGetFieldByNumber(parameter_ptr, 0, ifield);
//haarfeature[jstruct][ifield] = tmp;
if(mxIsDouble(tmp) && mxGetM(tmp) == 1 && mxGetN(tmp) == 1){
parameter[ip++] = mxGetPr(tmp)[0];
}
}
}
/* assign v-node MATLAB structure pointers to C structure pointers */
void GetVnPtrs( int CodeLength, const mxArray *v_nodes_mx, v_node *v_nodes )
{
int i;
for(i=0; i< CodeLength; i++){
v_nodes[i].degree = mxGetData( mxGetFieldByNumber(v_nodes_mx, i, 0) );
v_nodes[i].initial_value = mxGetData( mxGetFieldByNumber(v_nodes_mx, i, 1) );
v_nodes[i].index = mxGetData( mxGetFieldByNumber(v_nodes_mx, i, 2) );
v_nodes[i].socket = mxGetData( mxGetFieldByNumber(v_nodes_mx, i, 3) );
v_nodes[i].message = mxGetData( mxGetFieldByNumber(v_nodes_mx, i, 4) );
v_nodes[i].sign = mxGetData( mxGetFieldByNumber(v_nodes_mx, i, 5) );
}
}
static void set_object_data(const mxArray *data)
{
OBJECT *obj;
mxArray *pId = mxGetField(data,0,"id");
char id[256];
if (pId==NULL)
output_error("set_object_data(const mxArray *data={...}) did not find a required object id field");
else if (mxGetString(pId,id,sizeof(id)))
output_error("set_object_data(const mxArray *data={...}) couldn't read the object id field");
else if ((obj=object_find_name(id))==NULL)
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't find object id", id);
else
{
int i;
for (i=0; i<mxGetNumberOfFields(data); i++)
{
const char *name;
const mxArray *pField = mxGetFieldByNumber(data,0,i);
char value[4096];
if ((name=mxGetFieldNameByNumber(data,i))==NULL)
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't read the name of field %d", id, i);
else if (strcmp(name,"id")==0 || strcmp(name,"class")==0)
{ /* these may not be changed */ }
else if (pField==NULL)
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't read the object field '%s' for object '%s'", id, name);
else if (mxIsChar(pField) && mxGetString(pField,value,sizeof(value)))
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't read the string value '%s' from field '%s'", id, value, name);
else if (mxIsDouble(pField) && sprintf(value,"%lg",*(double*)mxGetPr(pField))<1)
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't read the double value '%lg' from field '%s'", id, *(double*)mxGetPr(pField), name);
else if (mxIsComplex(pField) && sprintf(value,"%lg%+lgi",*(double*)mxGetPr(pField),*(double*)mxGetPi(pField))<1)
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't read the complex value '%lg%+lgi' from field '%s'", id, *(double*)mxGetPr(pField), *(double*)mxGetPi(pField), name);
else if (mxIsUint32(pField) && sprintf(value,"%lu",*(unsigned int*)mxGetPr(pField))<1)
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't read the uint32 value '%lu' from field '%s'", id, *(unsigned int*)mxGetPr(pField), name);
else if (strcmp(value,ERROR)==0)
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't use error value '%s'", id, value);
else if (strcmp(value,NONE)==0 && strcpy(value,"")==NULL)
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't clear empty value '%s'", id, value);
else if (!object_set_value_by_name(obj,name,value))
output_error("set_object_data(const mxArray *data={id='%s',...}) couldn't read the value '%s' into property '%s'", id, value, name);
}
}
}
/* Pass analyze_structure a pointer to a structure mxArray. Each element
in a structure mxArray holds one or more fields; each field holds zero
or one mxArray. analyze_structure accesses every field of every
element and displays information about it. */
static void
analyze_structure(const mxArray *structure_array_ptr)
{
mwSize total_num_of_elements;
mwIndex index;
int number_of_fields, field_index;
const char *field_name;
const mxArray *field_array_ptr;
mexPrintf("\n");
total_num_of_elements = mxGetNumberOfElements(structure_array_ptr);
number_of_fields = mxGetNumberOfFields(structure_array_ptr);
/* Walk through each structure element. */
for (index=0; index<total_num_of_elements; index++) {
/* For the given index, walk through each field. */
for (field_index=0; field_index<number_of_fields; field_index++) {
mexPrintf("\n\t\t");
display_subscript(structure_array_ptr, index);
field_name = mxGetFieldNameByNumber(structure_array_ptr,
field_index);
mexPrintf(".%s\n", field_name);
field_array_ptr = mxGetFieldByNumber(structure_array_ptr,
index,
field_index);
if (field_array_ptr == NULL) {
mexPrintf("\tEmpty Field\n");
} else {
/* Display a top banner. */
mexPrintf("------------------------------------------------\n");
get_characteristics(field_array_ptr);
analyze_class(field_array_ptr);
mexPrintf("\n");
}
}
mexPrintf("\n\n");
}
}
bool parse(const mxArray* opts_in)
{
if (!mxIsStruct(opts_in)) {
mexErrMsgTxt("Options parameter must be a structure.\n");
return (false);
}
int num_fields = mxGetNumberOfFields(opts_in);
for (int fn=0; fn<num_fields; fn++) {
const char* opt_name = mxGetFieldNameByNumber(opts_in, fn);
std::string opt_name_str = opt_name;
mxArray *opt_val = mxGetFieldByNumber(opts_in, 0, fn);
if (opt_name_str == "num_max_iter") {
num_max_iter = static_cast<size_t>(mxGetScalar(opt_val));
}
else if (opt_name_str == "rho") {
rho = mxGetScalar(opt_val);
}
else if (opt_name_str == "eps_gnorm") {
eps_gnorm = mxGetScalar(opt_val);
}
else if (opt_name_str == "solver") {
std::string solver_name = GetMatlabString(opt_val);
if (solver_name == "fistadescent") {
solver = SOLVER_FISTADESCENT;
}
else if (solver_name == "lbfgs") {
solver = SOLVER_LBFGS;
}
else {
mexErrMsgTxt("No solver with this name.\n");
return false;
}
}
else {
mexErrMsgTxt("Name of the option is invalid.\n");
return (false);
}
}
return true;
}
void mexFunction(int nOut, mxArray *pOut[],
int nIn, const mxArray *pIn[])
{
mxArray *address, *data;
char *field_name;
int field_number;
// assert(nOut == 2)
// assert(nIn == 2)
address = GetPointerData(pIn[0]);
data = GetPointerData(address);
if (!data)
{
//mexErrMsgTxt("Pointer is NULL");
pOut[0] = mxCreateScalarDouble(0);
pOut[1] = mxCreateScalarDouble(0);
}
else
{
field_name = AllocAndGetString(pIn[1]);
field_number = mxGetFieldNumber(data, field_name);
if (field_number == -1)
{
//mexErrMsgTxt("Reference to non-existent field");
pOut[0] = mxCreateScalarDouble(-1);
pOut[1] = mxCreateScalarDouble(-1);
}
else
{
pOut[0] = mxGetFieldByNumber(data, 0, field_number);
pOut[1] = mxCreateScalarDouble(1);
}
mxFree(field_name);
}
}
bool ConnectionHeader::fromMatlab(const mxArray *array)
{
data_.reset();
if (!mxIsStruct(array) && !mxGetNumberOfElements(array) == 1) return false;
data_.reset(new ros::M_string);
int numberOfFields = mxGetNumberOfFields(array);
for(int i = 0; i < numberOfFields; i++) {
std::string key = mxGetFieldNameByNumber(array, i);
const mxArray *value = mxGetFieldByNumber(array, 0, i);
if (Options::isString(value)) {
data_->insert(ros::StringPair(key, Options::getString(value)));
} else if (Options::isDoubleScalar(value)) {
data_->insert(ros::StringPair(key, boost::lexical_cast<std::string>(Options::getDoubleScalar(value))));
} else if (Options::isIntegerScalar(value)) {
data_->insert(ros::StringPair(key, boost::lexical_cast<std::string>(Options::getIntegerScalar(value))));
} else if (Options::isLogicalScalar(value)) {
data_->insert(ros::StringPair(key, boost::lexical_cast<std::string>(Options::getLogicalScalar(value))));
}
}
return true;
}
void object(mxArray *ma, int i, json_object **jo){
int j = 0;
int n = mxGetNumberOfFields(ma);
mxArray *tmpma;
json_object *tmpobj;
*jo = json_object_new_object();
for(; j < n; j++){
bool needDestroy = false;
tmpma = mxGetFieldByNumber(ma, i, j);
if (tmpma == NULL){
/* Object is NULL, create an empty matrix instead */
tmpma = mxCreateNumericMatrix(0, 0, mxDOUBLE_CLASS, mxREAL);
needDestroy = true;
}
parse(tmpma, &tmpobj);
json_object_object_add(*jo, mxGetFieldNameByNumber(ma, j), tmpobj);
if (needDestroy)
mxDestroyArray(tmpma);
}
}
