int get_QuadOptions(const mxArray *options, cvmPbData thisPb, booleantype fwd, long int Nq, booleantype *rhs_s, booleantype *errconQ, int *itolQ, double *reltolQ, double *SabstolQ, double **VabstolQ) { mxArray *opt; long int i, m, n; double *tmp; char *fctName; char *fwd_fctName = "CVodeQuadInit/CVodeQuadReInit"; char *bck_fctName = "CVodeQuadInitB/CVodeQuadReInitB"; if (fwd) fctName = fwd_fctName; else fctName = bck_fctName; *errconQ = FALSE; *itolQ = CV_SS; *reltolQ = 1.0e-4; *SabstolQ = 1.0e-6; *VabstolQ = NULL; *rhs_s = FALSE; /* Return now if options was empty */ if (mxIsEmpty(options)) return(0); /* For backward problems only, check dependency on forward sensitivities */ if (!fwd) { opt = mxGetField(options,0,"SensDependent"); if ( !mxIsEmpty(opt) ) { if (!mxIsLogical(opt)) { cvmErrHandler(-999, "CVODES", fctName, "SensDependent is not a logical scalar.", NULL); return(-1); } if (mxIsLogicalScalarTrue(opt)) *rhs_s = TRUE; else *rhs_s = FALSE; } } /* Quadrature error control and tolerances */ opt = mxGetField(options,0,"ErrControl"); if ( mxIsEmpty(opt) ) return(0); if (!mxIsLogical(opt)) { cvmErrHandler(-999, "CVODES", fctName, "ErrControl is not a logical scalar.", NULL); return(-1); } if (!mxIsLogicalScalarTrue(opt)) return(0); /* the remining options are interpreted only if quadratures are included in error control */ *errconQ = TRUE; opt = mxGetField(options,0,"RelTol"); if ( !mxIsEmpty(opt) ) { *reltolQ = *mxGetPr(opt); if (*reltolQ < 0.0) { cvmErrHandler(-999, "CVODES", fctName, "RelTol is negative.", NULL); return(-1); } } opt = mxGetField(options,0,"AbsTol"); if ( !mxIsEmpty(opt) ) { m = mxGetN(opt); n = mxGetM(opt); if ( (n != 1) && (m != 1) ) { cvmErrHandler(-999, "CVODES", fctName, "AbsTol is not a scalar or a vector.", NULL); return(-1); } if ( m > n ) n = m; tmp = mxGetPr(opt); if (n == 1) { *itolQ = CV_SS; *SabstolQ = *tmp; if (*SabstolQ < 0.0) { cvmErrHandler(-999, "CVODES", fctName, "AbsTol is negative.", NULL); return(-1); } } else if (n == Nq) { *itolQ = CV_SV; *VabstolQ = (double *)malloc(Nq*sizeof(double)); for(i=0;i<Nq;i++) { (*VabstolQ)[i] = tmp[i]; if (tmp[i] < 0.0) { cvmErrHandler(-999, "CVODES", fctName, "AbsTol has a negative component.", NULL); return(-1); } } } else { cvmErrHandler(-999, "CVODES", fctName, "AbsTol does not contain Nq elements.", NULL); return(-1); } } /* We made it here without problems */ return(0); }
int get_FSAOptions(const mxArray *options, cvmPbData thisPb, int *ism, char **pfield_name, int **plist, double **pbar, int *dqtype, double *rho, booleantype *errconS, int *itolS, double *reltolS, double **SabstolS, double **VabstolS) { mxArray *opt; char *bufval; int i, is, m, n, buflen, status, this_plist; double *tmp; /* Set default values */ *ism = CV_STAGGERED; *dqtype = CV_CENTERED; *rho = 0.0; *errconS = TRUE; *itolS = CV_EE; *SabstolS = NULL; *VabstolS = NULL; *pfield_name = NULL; *plist = NULL; *pbar = NULL; /* Return now if options was empty */ if (mxIsEmpty(options)) return(0); /* Sensitivity method */ opt = mxGetField(options,0,"method"); if ( !mxIsEmpty(opt) ) { buflen = mxGetM(opt) * mxGetN(opt) + 1; bufval = mxCalloc(buflen, sizeof(char)); status = mxGetString(opt, bufval, buflen); if(status != 0) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "Could not parse method.", NULL); return(-1); } if(!strcmp(bufval,"Simultaneous")) *ism = CV_SIMULTANEOUS; else if(!strcmp(bufval,"Staggered")) *ism = CV_STAGGERED; else { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "method has an illegal value.", NULL); return(-1); } } /* Field name in data structure for params. */ opt = mxGetField(options,0,"ParamField"); if ( !mxIsEmpty(opt) ) { buflen = mxGetM(opt) * mxGetN(opt) + 1; bufval = mxCalloc(buflen, sizeof(char)); status = mxGetString(opt, bufval, buflen); if(status != 0) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "Could not parse ParamField.", NULL); return(-1); } *pfield_name = mxCalloc(buflen, sizeof(char)); strcpy((*pfield_name), bufval); } /* PLIST */ opt = mxGetField(options,0,"ParamList"); if ( !mxIsEmpty(opt) ) { tmp = mxGetPr(opt); m = mxGetM(opt); n = mxGetN(opt); if ( (n != 1) && (m != 1) ) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "ParamList is not a vector.", NULL); return(-1); } if (m > n) n = m; if ( n != Ns) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "ParamList does not contain Ns elements.", NULL); return(-1); } *plist = (int *) malloc(Ns*sizeof(int)); for (is=0;is<Ns;is++) { this_plist = (int) tmp[is]; if (this_plist <= 0) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "ParamList must contain only positive integers.", NULL); return(-1); } (*plist)[is] = this_plist - 1; } } /* PBAR */ opt = mxGetField(options,0,"ParamScales"); if ( !mxIsEmpty(opt) ) { m = mxGetM(opt); n = mxGetN(opt); if ( (n != 1) && (m != 1) ) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "ParamScales is not a vector.", NULL); return(-1); } if ( m > n ) n = m; if ( n != Ns) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "ParamScales does not contain Ns elements.", NULL); return(-1); } tmp = mxGetPr(opt); *pbar = (double *) malloc(Ns*sizeof(double)); for(i=0;i<Ns;i++) (*pbar)[i] = tmp[i]; } /* DQ type */ opt = mxGetField(options,0,"DQtype"); if ( !mxIsEmpty(opt) ) { buflen = mxGetM(opt) * mxGetN(opt) + 1; bufval = mxCalloc(buflen, sizeof(char)); status = mxGetString(opt, bufval, buflen); if(status != 0) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "Cannot parse DQtype.", NULL); return(-1); } if(!strcmp(bufval,"Centered")) *dqtype = CV_CENTERED; else if(!strcmp(bufval,"Forward")) *dqtype = CV_FORWARD; else { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "DQtype has an illegal value.", NULL); return(-1); } } /* DQ parameter */ opt = mxGetField(options,0,"DQparam"); if ( !mxIsEmpty(opt) ) *rho = *mxGetPr(opt); /* Error control */ opt = mxGetField(options,0,"ErrControl"); if ( !mxIsEmpty(opt) ) { if (!mxIsLogical(opt)) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "ErrControl is not a logical scalar.", NULL); return(-1); } if (mxIsLogicalScalarTrue(opt)) *errconS = TRUE; else *errconS = FALSE; } /* Tolerances */ opt = mxGetField(options,0,"RelTol"); if ( !mxIsEmpty(opt) ) { *reltolS = *mxGetPr(opt); if (*reltolS < 0.0) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "RelTol is negative.", NULL); return(-1); } opt = mxGetField(options,0,"AbsTol"); if ( !mxIsEmpty(opt) ) { m = mxGetM(opt); n = mxGetN(opt); if ( (m == 1) && (n == Ns) ) { *itolS = CV_SS; tmp = mxGetPr(opt); *SabstolS = (double *) malloc(Ns*sizeof(double)); for (is=0; is<Ns; is++) { (*SabstolS)[is] = tmp[is]; if ( tmp[is] < 0.0 ) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "AbsTol has a negative component.", NULL); return(-1); } } } else if ( (m == N) && (n == Ns) ) { *itolS = CV_SV; tmp = mxGetPr(opt); *VabstolS = (double *)malloc(Ns*N*sizeof(double)); for (i=0; i<Ns*N; i++) { (*VabstolS)[i] = tmp[i]; if ( tmp[i] < 0.0 ) { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "AbsTol has a negative component.", NULL); return(-1); } } } else { cvmErrHandler(-999, "CVODES", "CVodeSensInit/CVodeSensReInit", "AbsTol must be either a 1xNs vector or an NxNs matrix.", NULL); return(-1); } } else { *itolS = CV_EE; } } /* We made it here without problems */ return(0); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // Get the command string char cmd[64]; if(nrhs < 1 || mxGetString(prhs[0], cmd, sizeof(cmd))) { mexErrMsgTxt("GaussianKernel: First input should be a command string less than 64 characters long."); } // New if (!strcmp(cmd, "new")) { // Check output parameters if (nlhs != 1) { mexErrMsgTxt("GaussianKernel: new: One output expected."); } // Check input parameters if (nrhs == 1) { plhs[0] = convertPtr2Mat(new GaussianKernel()); } else if (nrhs == 3) { if(!mxIsDouble(prhs[1]) || !mxIsDouble(prhs[2])) { mexErrMsgTxt("GaussianKernel: new: Invalid data type."); } double lowerBound = mxGetScalar(prhs[1]); double upperBound = mxGetScalar(prhs[2]); plhs[0] = convertPtr2Mat(new GaussianKernel(lowerBound, upperBound)); } else if (nrhs == 4) { if(!mxIsDouble(prhs[1]) || !mxIsDouble(prhs[2]) || !mxIsLogicalScalar(prhs[3])) { mexErrMsgTxt("GaussianKernel: new: Invalid data type."); } double lowerBound = mxGetScalar(prhs[1]); double upperBound = mxGetScalar(prhs[2]); bool interpolation = mxIsLogicalScalarTrue(prhs[3]); plhs[0] = convertPtr2Mat(new GaussianKernel(lowerBound, upperBound, interpolation)); } else mexErrMsgTxt("GaussianKernel: new: Invalid parameter number."); return; } // Check there is a second input, which should be the class instance handle if (nrhs < 2) mexErrMsgTxt("GaussianKernel: Second input should be a class instance handle."); // Delete if (!strcmp(cmd, "delete")) { // Destroy the C++ object destroyObject<GaussianKernel>(prhs[1]); // Warn if other commands were ignored if (nlhs != 0 || nrhs != 2) mexWarnMsgTxt("Delete: Unexpected arguments ignored."); return; } }
int get_IntgrOptions(const mxArray *options, cvmPbData thisPb, booleantype fwd, int lmm, int *maxord, booleantype *sld, booleantype *errmsg, long int *mxsteps, int *itol, realtype *reltol, double *Sabstol, double **Vabstol, double *hin, double *hmax, double *hmin, double *tstop, booleantype *rhs_s) { mxArray *opt; int q; long int i, m, n; double *tmp; char *fctName; char *fwd_fctName = "CVodeInit/CVodeReInit"; char *bck_fctName = "CVodeInitB/CVodeReInitB"; if (fwd) fctName = fwd_fctName; else fctName = bck_fctName; /* Set default values */ *maxord = (lmm == CV_ADAMS) ? 12 : 5; *sld = FALSE; *mxsteps = 0; *itol = CV_SS; *reltol = 1.0e-3; *Sabstol = 1.0e-6; *Vabstol = NULL; *hin = 0.0; *hmax = 0.0; *hmin = 0.0; *rhs_s = FALSE; Ng = 0; tstopSet = FALSE; mon = FALSE; *errmsg = TRUE; /* Return now if options was empty */ if (mxIsEmpty(options)) return(0); /* User data */ opt = mxGetField(options,0,"UserData"); if ( !mxIsEmpty(opt) ) { mxDestroyArray(mtlb_data); mtlb_data = mxDuplicateArray(opt); } /* Tolerances */ opt = mxGetField(options,0,"RelTol"); if ( !mxIsEmpty(opt) ) { *reltol = *mxGetPr(opt); if (*reltol < 0.0 ) { cvmErrHandler(-999, "CVODES", fctName, "RelTol is negative.", NULL); return(-1); } } opt = mxGetField(options,0,"AbsTol"); if ( !mxIsEmpty(opt) ) { m = mxGetM(opt); n = mxGetN(opt); if ( (n != 1) && (m != 1) ) { cvmErrHandler(-999, "CVODES", fctName, "AbsTol is not a scalar or a vector.", NULL); return(-1); } if ( m > n ) n = m; tmp = mxGetPr(opt); if (n == 1) { *itol = CV_SS; *Sabstol = *tmp; if (*Sabstol < 0.0) { cvmErrHandler(-999, "CVODES", fctName, "AbsTol is negative.", NULL); return(-1); } } else if (n == N) { *itol = CV_SV; *Vabstol = (double *) malloc(N*sizeof(double)); for(i=0;i<N;i++) { (*Vabstol)[i] = tmp[i]; if (tmp[i] < 0.0) { cvmErrHandler(-999, "CVODES", fctName, "AbsTol has a negative component.", NULL); return(-1); } } } else { cvmErrHandler(-999, "CVODES", fctName, "AbsTol does not contain N elements.", NULL); return(-1); } } /* Maximum number of steps */ opt = mxGetField(options,0,"MaxNumSteps"); if ( !mxIsEmpty(opt) ) { *mxsteps = (int)*mxGetPr(opt); if (*mxsteps < 0) { cvmErrHandler(-999, "CVODES", fctName, "MaxNumSteps is negative.", NULL); return(-1); } } /* Maximum order */ opt = mxGetField(options,0,"MaxOrder"); if ( !mxIsEmpty(opt) ) { q = (int)*mxGetPr(opt); if (q <= 0) { cvmErrHandler(-999, "CVODES", fctName, "MaxOrder must be positive.", NULL); return(-1); } if (q > *maxord) { cvmErrHandler(-999, "CVODES", fctName, "MaxOrder is too large for the Method specified.", NULL); return(-1); } *maxord = q; } /* Initial step size */ opt = mxGetField(options,0,"InitialStep"); if ( !mxIsEmpty(opt) ) { *hin = *mxGetPr(opt); } /* Maximum step size */ opt = mxGetField(options,0,"MaxStep"); if ( !mxIsEmpty(opt) ) { tmp = mxGetPr(opt); if (*tmp < 0.0) { cvmErrHandler(-999, "CVODES", fctName, "MaxStep is negative.", NULL); return(-1); } if ( mxIsInf(*tmp) ) *hmax = 0.0; else *hmax = *tmp; } /* Minimum step size */ opt = mxGetField(options,0,"MinStep"); if ( !mxIsEmpty(opt) ) { *hmin = *mxGetPr(opt); if (*hmin < 0.0) { cvmErrHandler(-999, "CVODES", fctName, "MinStep is negative.", NULL); return(-1); } } /* Stability Limit Detection */ opt = mxGetField(options,0,"StabilityLimDet"); if ( !mxIsEmpty(opt) ) { if (!mxIsLogical(opt)) { cvmErrHandler(-999, "CVODES", fctName, "StabilityLimDet is not a logical scalar.", NULL); return(-1); } if (mxIsLogicalScalarTrue(opt)) *sld = TRUE; else *sld = FALSE; } /* Monitor? */ opt = mxGetField(options,0,"MonitorFn"); if ( !mxIsEmpty(opt) ) { mon = TRUE; mxDestroyArray(mtlb_MONfct); mtlb_MONfct = mxDuplicateArray(opt); opt = mxGetField(options,0,"MonitorData"); if ( !mxIsEmpty(opt) ) { mxDestroyArray(mtlb_MONdata); mtlb_MONdata = mxDuplicateArray(opt); } } /* The remaining options are interpreted either for * forward problems only or backward problems only */ if (fwd) { /* FORWARD PROBLEM ONLY */ /* Disable error/warning messages? */ opt = mxGetField(options,0,"ErrorMessages"); if ( !mxIsEmpty(opt) ) { if (!mxIsLogical(opt)) { cvmErrHandler(-999, "CVODES", fctName, "ErrorMessages is not a logical scalar.", NULL); return(-1); } if (mxIsLogicalScalarTrue(opt)) *errmsg = TRUE; else *errmsg = FALSE; } /* Stopping time */ opt = mxGetField(options,0,"StopTime"); if ( !mxIsEmpty(opt) ) { *tstop = *mxGetPr(opt); tstopSet = TRUE; } /* Number of root functions */ opt = mxGetField(options,0,"NumRoots"); if ( !mxIsEmpty(opt) ) { Ng = (int)*mxGetPr(opt); if (Ng < 0) { cvmErrHandler(-999, "CVODES", fctName, "NumRoots is negative.", NULL); return(-1); } if (Ng > 0) { /* Roots function */ opt = mxGetField(options,0,"RootsFn"); if ( !mxIsEmpty(opt) ) { mxDestroyArray(mtlb_Gfct); mtlb_Gfct = mxDuplicateArray(opt); } else { cvmErrHandler(-999, "CVODES", fctName, "RootsFn required for NumRoots > 0", NULL); return(-1); } } } } else { /* BACKWARD PROBLEM ONLY */ /* Dependency on forward sensitivities */ opt = mxGetField(options,0,"SensDependent"); if ( !mxIsEmpty(opt) ) { if (!mxIsLogical(opt)) { cvmErrHandler(-999, "CVODES", fctName, "SensDependent is not a logical scalar.", NULL); return(-1); } if (mxIsLogicalScalarTrue(opt)) *rhs_s = TRUE; else *rhs_s = FALSE; } } /* We made it here without problems */ return(0); }
int get_SolverOptions(const mxArray *options, booleantype *verbose, int *mxiter, int *msbset, int *msbsetsub, int *etachoice, int *mxnbcf, double *eta, double *egamma, double *ealpha, double *mxnewtstep, double *relfunc, double *fnormtol, double *scsteptol, double **constraints, booleantype *noInitSetup, booleantype *noMinEps) { mxArray *opt; char *bufval; int i, buflen, status, n; double *tmp; /* Set default values (pass 0 values. KINSOL does the rest) */ *mxiter = 0; *msbset = 0; *msbsetsub = 0; *mxnbcf = 0; *etachoice = KIN_ETACHOICE1; *eta = 0.0; *egamma = 0.0; *ealpha = 0.0; *mxnewtstep = 0.0; *relfunc = 0.0; *fnormtol = 0.0; *scsteptol = 0.0; *noInitSetup = FALSE; *noMinEps = FALSE; *verbose = FALSE; *constraints = NULL; /* Return now if options was empty */ if (mxIsEmpty(options)) return(0); /* Integer values */ opt = mxGetField(options,0,"MaxNumIter"); if ( !mxIsEmpty(opt) ) *mxiter = (int)*mxGetPr(opt); opt = mxGetField(options,0,"MaxNumSetups"); if ( !mxIsEmpty(opt) ) *msbset = (int)*mxGetPr(opt); opt = mxGetField(options,0,"MaxNumSubSetups"); if ( !mxIsEmpty(opt) ) *msbsetsub = (int)*mxGetPr(opt); opt = mxGetField(options,0,"MaxNumBetaFails"); if ( !mxIsEmpty(opt) ) *mxnbcf = (int)*mxGetPr(opt); opt = mxGetField(options,0,"EtaForm"); if ( !mxIsEmpty(opt) ) { buflen = mxGetM(opt) * mxGetN(opt) + 1; bufval = mxCalloc(buflen, sizeof(char)); status = mxGetString(opt, bufval, buflen); if(status != 0) return(status); if(strcmp(bufval,"Type1")) *etachoice = KIN_ETACHOICE1; else if(strcmp(bufval,"Type2")) *etachoice = KIN_ETACHOICE2; else if(strcmp(bufval,"Constant")) *etachoice = KIN_ETACONSTANT; } /* Real values */ opt = mxGetField(options,0,"Eta"); if ( !mxIsEmpty(opt) ) *eta = (double)*mxGetPr(opt); opt = mxGetField(options,0,"EtaAlpha"); if ( !mxIsEmpty(opt) ) *ealpha = (double)*mxGetPr(opt); opt = mxGetField(options,0,"EtaGamma"); if ( !mxIsEmpty(opt) ) *egamma = (double)*mxGetPr(opt); opt = mxGetField(options,0,"MaxNewtonStep"); if ( !mxIsEmpty(opt) ) *mxnewtstep = (double)*mxGetPr(opt); opt = mxGetField(options,0,"FuncRelErr"); if ( !mxIsEmpty(opt) ) *relfunc = (double)*mxGetPr(opt); opt = mxGetField(options,0,"FuncNormTol"); if ( !mxIsEmpty(opt) ) *fnormtol = (double)*mxGetPr(opt); opt = mxGetField(options,0,"ScaledStepTol"); if ( !mxIsEmpty(opt) ) *scsteptol = (double)*mxGetPr(opt); /* Boolean values */ opt = mxGetField(options,0,"Verbose"); if ( !mxIsEmpty(opt) ) *verbose = mxIsLogicalScalarTrue(opt); opt = mxGetField(options,0,"InitialSetup"); if ( !mxIsEmpty(opt) ) *noInitSetup = !mxIsLogicalScalarTrue(opt); opt = mxGetField(options,0,"MinBoundEps"); if ( !mxIsEmpty(opt) ) *noMinEps = !mxIsLogicalScalarTrue(opt); /* Constraints */ opt = mxGetField(options,0,"Constraints"); if ( !mxIsEmpty(opt) ) { tmp = mxGetPr(opt); n = mxGetN(opt); if (n == N) { *constraints = (double *) malloc(N*sizeof(int)); for (i=0;i<N;i++) (*constraints)[i] = tmp[i]; } else { return(1); /* Error */ } } /* We made it here without problems */ return(0); }
int pfput_mxArray( Pf *pf, char *name, const mxArray *array ) { Pf *sub_pf; double number; char *string; mxArray *in[2], *out[1]; char warning[STRSZ]; char *fieldname; mxArray *mxfield; mxArray *mxcell; int M,N; int rc; int i; if( mxIsClass( array, "dbpf" ) ) { if( ! get_pf( array, &sub_pf ) ) { return PFINVALID; } if( sub_pf->type == PFFILE) { /* Don't embed a PFFILE in something else */ sub_pf->type = PFARR; } switch (pf->type) { case PFFILE: case PFARR: setarr ( pf->value.arr, name, sub_pf ) ; break ; case PFTBL: settbl ( pf->value.tbl, (int) name, sub_pf ) ; break ; default : return PFINVALID; } antelope_mex_clear_register( 1 ); } else if( mxIsDouble( array ) ) { if( ! get_scalar( array, &number ) ) { return PFINVALID; } in[0] = (mxArray *) array; /* Input scalar */ mexCallMATLAB( 1, out, 1, in, "floor" ); in[1] = out[0]; /* floor( Input scalar ) */ mexCallMATLAB( 1, out, 2, in, "eq" ); mxDestroyArray( in[1] ); if( mxIsLogicalScalarTrue( out[0] ) ) { pfput_int( pf, name, (int) number ); } else { pfput_double( pf, name, number ); } antelope_mex_clear_register( 1 ); mxDestroyArray( out[0] ); } else if( mxIsChar( array ) ) { if( ! mtlb_get_string( array, &string ) ) { sprintf( warning, "failed to extract string for parameter %s\n", name ); mexWarnMsgTxt( warning ); return PFINVALID; } pfput_string( pf, name, string ); antelope_mex_clear_register( 1 ); mxFree( string ); } else if( mxIsStruct( array ) ) { if( mxGetNumberOfDimensions( array ) > 2 ) { sprintf( warning, "structure has too many dimensions for parameter %s\n", name ); mexWarnMsgTxt( warning ); return PFINVALID; } else if( mxGetM( array ) != 1 || mxGetN( array ) != 1 ) { sprintf( warning, "structure has too many elements for parameter %s\n", name ); mexWarnMsgTxt( warning ); return PFINVALID; } N = mxGetNumberOfFields( array ); sub_pf = pfnew( PFARR ); for( i = 0; i < N; i++ ) { fieldname = (char *) mxGetFieldNameByNumber( array, i ); mxfield = mxGetFieldByNumber( array, 0, i ); rc = pfput_mxArray( sub_pf, fieldname, mxfield ); if( rc == PFINVALID ) { pffree( sub_pf ); return PFINVALID; } } switch (pf->type) { case PFFILE: case PFARR: setarr ( pf->value.arr, name, sub_pf ) ; break ; case PFTBL: settbl ( pf->value.tbl, (int) name, sub_pf ) ; break ; default : pffree( sub_pf ); return PFINVALID; } antelope_mex_clear_register( 1 ); } else if( mxIsCell( array ) ) { if( mxGetNumberOfDimensions( array ) > 2 ) { sprintf( warning, "cell array has too many dimensions for parameter %s\n", name ); mexWarnMsgTxt( warning ); return PFINVALID; } M = mxGetM( array ); N = mxGetN( array ); sub_pf = pfnew( PFTBL ); for( i = 0; i < M * N; i++ ) { mxcell = mxGetCell( array, i ); rc = pfput_mxArray( sub_pf, (char *) i, mxcell ); if( rc == PFINVALID ) { pffree( sub_pf ); return PFINVALID; } } switch (pf->type) { case PFFILE: case PFARR: setarr ( pf->value.arr, name, sub_pf ) ; break ; case PFTBL: settbl ( pf->value.tbl, (int) name, sub_pf ) ; break ; default : pffree( sub_pf ); return PFINVALID; } antelope_mex_clear_register( 1 ); } else { return PFINVALID; } return 0; }
/** * parse use_bdtree */ inline bool getopt_use_bdtree(const mxArray* mxUseBdTree) { return mxIsLogicalScalarTrue(mxUseBdTree); }
void parse(mxArray *ma, json_object **jo){ int i = 0; size_t num_el = mxGetNumberOfElements(ma); size_t m = mxGetM(ma); size_t n = mxGetN(ma); json_object *lobj; json_object *tmpobj; mxArray *tmpma; /* was char - convert to string*/ if(mxIsChar(ma)){ char *str = mxArrayToString(ma); *jo = json_object_new_string(str); } /* was struct - convert to object */ else if(mxIsStruct(ma)){ if(num_el == 1){ object(ma, 0, jo); } else{ /* it was a list of objects! */ *jo = json_object_new_array(); if(n == 1){ n = m; m = 1; } for(i = 0; i < num_el; i++){ if(i % m == 0 && m > 1){ lobj = json_object_new_array(); json_object_array_add(*jo,lobj); } object(ma, i, &tmpobj); if(m > 1) json_object_array_add(lobj, tmpobj); else json_object_array_add(*jo, tmpobj); } } } /* was cell array - convert to list */ else if(mxIsCell(ma)){ *jo = json_object_new_array(); if(n == 1){ n = m; m = 1; } for(i = 0; i < num_el; i++){ if(i % m == 0 && m > 1){ lobj = json_object_new_array(); json_object_array_add(*jo,lobj); } tmpma = mxGetCell(ma, i); if(tmpma){ parse(tmpma, &tmpobj); if(m > 1) json_object_array_add(lobj, tmpobj); else json_object_array_add(*jo, tmpobj); } } } /* was numeric or bool - convert to number or list */ else{ /* single number or bool */ if(num_el == 1){ /* mxINT32_CLASS */ if(mxIsComplex(ma)){ mexErrMsgTxt("Data cannot be complex."); } if(mxIsNumeric(ma)){ double dbl = mxGetScalar(ma); numeric(dbl, jo); } else if(mxIsLogical(ma)){ *jo = json_object_new_boolean(mxIsLogicalScalarTrue(ma)); } else{ printf("Type is: %s\n", mxGetClassName(ma)); mexErrMsgTxt("Encountered an unknown type."); } } else{ double *dbl; int *intgr; mxLogical *bl; if(mxIsDouble(ma)){ dbl = mxGetData(ma); } else if(mxIsClass(ma, "mxINT32_CLASS")){ intgr = mxGetData(ma); } else if(mxIsLogical(ma)){ bl = mxGetData(ma); } else{ printf("Type is: %s\n", mxGetClassName(ma)); mexErrMsgTxt("Encountered an unsupported type."); } *jo = json_object_new_array(); /* vector - convert to list */ if(n == 1){ n = m; m = 1; } for(i = 0; i < num_el; i++){ if(i % m == 0 && m > 1){ lobj = json_object_new_array(); json_object_array_add(*jo,lobj); } if(mxIsLogical(ma)) tmpobj = json_object_new_boolean(bl[i]); else if(mxIsDouble(ma)) numeric(dbl[i], &tmpobj); else numeric((double)intgr[i], &tmpobj); if(m > 1) json_object_array_add(lobj, tmpobj); else json_object_array_add(*jo, tmpobj); } } } }
void mexFunction( const int nlhs, mxArray *plhs[], const int nrhs, const mxArray *prhs[]) { /* Check for proper number of arguments. */ if (nrhs != 1) { mexErrMsgIdAndTxt( "MATLAB:Graph:IsConnected:invalidNumInputs", "One input required."); } else if (nlhs > 1) { mexErrMsgIdAndTxt( "MATLAB:Graph:IsConnected:invalidNumOutputs", "At most one output is allowed."); } const mxArray *numberOfNodesArray = mxGetProperty(prhs[0], 0, "numberOfNodes"); if (!mxIsNumeric(numberOfNodesArray) || mxGetNumberOfElements(numberOfNodesArray) != 1) { mexErrMsgIdAndTxt( "MATLAB:Graph:IsConnected:invalidNumberOfNodes", "Number of nodes is not numeric scalar."); } const int numberOfNodes = mxGetScalar(numberOfNodesArray); if (numberOfNodes < 1) { mexErrMsgIdAndTxt( "MATLAB:Graph:IsConnected:emptyGraph", "Graph is empty."); } const mxArray *pAdjacencyMatrix = mxGetProperty(prhs[0], 0, "pAdjacencyMatrix"); if (!mxIsLogical(pAdjacencyMatrix) || mxGetN(pAdjacencyMatrix) != numberOfNodes || mxGetM(pAdjacencyMatrix) != numberOfNodes) { mexErrMsgIdAndTxt("MATLAB:Graph:IsConnected:invalidAdjacencyMatrix", "Adjacency matrix is not logical square matrix"); } const bool *adjacencyMatrix = mxGetLogicals(pAdjacencyMatrix); const mxArray *pIsDirectedArray = mxGetProperty(prhs[0], 0, "pIsDirected"); if (!mxIsLogicalScalar(pIsDirectedArray)) { mexErrMsgIdAndTxt( "MATLAB:Graph:IsConnected:invalidIsDirected", "Direction is not logical scalar"); } const bool isDirected = mxIsLogicalScalarTrue(pIsDirectedArray); bool *reachable = new bool[numberOfNodes]; if (mxIsSparse(pAdjacencyMatrix)) { // Sparse adjacency matrix std::vector<std::vector<mwIndex> > graph(numberOfNodes), rgraph(numberOfNodes); const mwIndex* row = mxGetIr(pAdjacencyMatrix); const mwIndex* col = mxGetJc(pAdjacencyMatrix); const size_t nz = col[mxGetN(pAdjacencyMatrix)]; mwIndex c = 0; for(size_t i = 0; i<nz; ++i) { while(col[c+1]<=i) ++c; if(adjacencyMatrix[i]) { graph[row[i]].push_back(c); rgraph[c].push_back(row[i]); } } memset(reachable, false, numberOfNodes * sizeof(bool)); reachable[0] = true; int nReachable = 1; std::queue<int> nodeQueue; nodeQueue.push(0); while(!nodeQueue.empty() && nReachable < numberOfNodes) { const int i = nodeQueue.front(); nodeQueue.pop(); std::vector<mwIndex>::const_iterator it = graph[i].begin(); for (; it != graph[i].end(); ++it) { if(!reachable[*it]) { reachable[*it] = true; nReachable++; nodeQueue.push(*it); } } } if (!isDirected || nReachable != numberOfNodes) { plhs[0] = mxCreateLogicalScalar(nReachable == numberOfNodes); } else { memset(reachable, false, numberOfNodes * sizeof(bool)); reachable[0] = true; int nReachable2 = 1; nodeQueue = std::queue<int>(); // Clear queue nodeQueue.push(0); while(!nodeQueue.empty() && nReachable2 < numberOfNodes) { const int i = nodeQueue.front(); nodeQueue.pop(); std::vector<mwIndex>::const_iterator it = rgraph[i].begin(); for (; it != rgraph[i].end(); ++it) { if(!reachable[*it]) { mexPrintf("Reachable 2 is %lu\n", *it); reachable[*it] = true; nReachable2++; nodeQueue.push(*it); } } } plhs[0] = mxCreateLogicalScalar(nReachable2 == numberOfNodes); } } else { // Full adjacency matrix memset(reachable, false, numberOfNodes * sizeof(bool)); reachable[0] = true; int nReachable = 1; std::queue<int> nodeQueue; nodeQueue.push(0); while(!nodeQueue.empty() && nReachable < numberOfNodes) { const int i = nodeQueue.front(); nodeQueue.pop(); for (int j=0; j<numberOfNodes; ++j) { if(adjacencyMatrix[i*numberOfNodes+j] && !reachable[j]) { reachable[j] = true; nReachable++; nodeQueue.push(j); } } } if (!isDirected || nReachable != numberOfNodes) { plhs[0] = mxCreateLogicalScalar(nReachable == numberOfNodes); } else { memset(reachable, false, numberOfNodes * sizeof(bool)); reachable[0] = true; int nReachable2 = 1; nodeQueue = std::queue<int>(); // Clear queue nodeQueue.push(0); while(!nodeQueue.empty() && nReachable2 < numberOfNodes) { const int i = nodeQueue.front(); nodeQueue.pop(); for (int j=0; j<numberOfNodes; ++j) { if(adjacencyMatrix[j*numberOfNodes+i] && !reachable[j]) { reachable[j] = true; nReachable2++; nodeQueue.push(j); } } } plhs[0] = mxCreateLogicalScalar(nReachable2 == numberOfNodes); } } delete [] reachable; }