/* * function r = rank(A,tol) */ static mxArray * Mrank(int nargout_, mxArray * A, mxArray * tol) { mexLocalFunctionTable save_local_function_table_ = mclSetCurrentLocalFunctionTable(&_local_function_table_rank); int nargin_ = mclNargin(2, A, tol, NULL); mxArray * r = mclGetUninitializedArray(); mxArray * s = mclGetUninitializedArray(); mclCopyArray(&A); mclCopyArray(&tol); /* * %RANK Matrix rank. * % RANK(A) provides an estimate of the number of linearly * % independent rows or columns of a matrix A. * % RANK(A,tol) is the number of singular values of A * % that are larger than tol. * % RANK(A) uses the default tol = max(size(A)) * norm(A) * eps. * * % Copyright 1984-2001 The MathWorks, Inc. * % $Revision: 5.10 $ $Date: 2001/04/15 12:01:33 $ * * s = svd(A); */ mlfAssign(&s, mlfSvd(NULL, NULL, mclVa(A, "A"), NULL)); /* * if nargin==1 */ if (nargin_ == 1) { /* * tol = max(size(A)') * max(s) * eps; */ mlfAssign( &tol, mclMtimes( mclMtimes( mclVe( mlfMax( NULL, mlfCtranspose( mclVe(mlfSize(mclValueVarargout(), mclVa(A, "A"), NULL))), NULL, NULL)), mclVe(mlfMax(NULL, mclVv(s, "s"), NULL, NULL))), _mxarray4_)); /* * end */ } /* * r = sum(s > tol); */ mlfAssign(&r, mlfSum(mclGt(mclVv(s, "s"), mclVa(tol, "tol")), NULL)); mclValidateOutput(r, 1, nargout_, "r", "rank"); mxDestroyArray(s); mxDestroyArray(tol); mxDestroyArray(A); mclSetCurrentLocalFunctionTable(save_local_function_table_); return r; }
/* * The function "mlxPrecise_step" contains the feval interface for the * "precise_step" M-function from file "d:\M6\work\precise_step.m" (lines 0-0). * The feval function calls the implementation version of precise_step through * this function. This function processes any input arguments and passes them * to the implementation version of the function, appearing above. */ void mlxPrecise_step(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) { mxArray * mprhs[1]; mxArray * mplhs[1]; int i; if (nlhs > 1) { mlfError( mxCreateString( "Run-time Error: File: precise_step Line: 1 Column" ": 1 The function \"precise_step\" was called with" " more than the declared number of outputs (1).")); } if (nrhs > 1) { mlfError( mxCreateString( "Run-time Error: File: precise_step Line: 1 Column" ": 1 The function \"precise_step\" was called with" " more than the declared number of inputs (1).")); } for (i = 0; i < 1; ++i) { mplhs[i] = mclGetUninitializedArray(); } for (i = 0; i < 1 && i < nrhs; ++i) { mprhs[i] = prhs[i]; } for (; i < 1; ++i) { mprhs[i] = NULL; } mlfEnterNewContext(0, 1, mprhs[0]); mplhs[0] = Mprecise_step(nlhs, mprhs[0]); mlfRestorePreviousContext(0, 1, mprhs[0]); plhs[0] = mplhs[0]; }
/* * The function "mlxD_int" contains the feval interface for the "d_int" * M-function from file "d:\M6\work\d_int.m" (lines 0-0). The feval function * calls the implementation version of d_int through this function. This * function processes any input arguments and passes them to the implementation * version of the function, appearing above. */ void mlxD_int(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) { mxArray * mprhs[2]; mxArray * mplhs[1]; int i; if (nlhs > 1) { mlfError( mxCreateString( "Run-time Error: File: d_int Line: 1 Column: 1" " The function \"d_int\" was called with more " "than the declared number of outputs (1).")); } if (nrhs > 2) { mlfError( mxCreateString( "Run-time Error: File: d_int Line: 1 Column: 1 The function \"d_int" "\" was called with more than the declared number of inputs (2).")); } for (i = 0; i < 1; ++i) { mplhs[i] = mclGetUninitializedArray(); } for (i = 0; i < 2 && i < nrhs; ++i) { mprhs[i] = prhs[i]; } for (; i < 2; ++i) { mprhs[i] = NULL; } mlfEnterNewContext(0, 2, mprhs[0], mprhs[1]); mplhs[0] = Md_int(nlhs, mprhs[0], mprhs[1]); mlfRestorePreviousContext(0, 2, mprhs[0], mprhs[1]); plhs[0] = mplhs[0]; }
/* * function out = precise_step(inargs) */ static mxArray * Mprecise_step(int nargout_, mxArray * inargs) { mexLocalFunctionTable save_local_function_table_ = mclSetCurrentLocalFunctionTable(&_local_function_table_precise_step); mxArray * out = mclGetUninitializedArray(); mclCopyArray(&inargs); /* * % precise_step defines precise level for my own bussniss. * % * % out = precise_step * % out always return .001 for current. * * if exist('FORCE_PRECISE_STEP') == 1 */ if (mclEqBool(mclVe(mlfExist(_mxarray4_, NULL)), _mxarray6_)) { /* * out = eval('FORCE_PRECISE_STEP'); */ mlfAssign(&out, mlfEval(mclValueVarargout(), _mxarray4_, NULL)); /* * else */ } else { /* * out = .0009; */ mlfAssign(&out, _mxarray7_); /* * end */ } mclValidateOutput(out, 1, nargout_, "out", "precise_step"); mxDestroyArray(inargs); mclSetCurrentLocalFunctionTable(save_local_function_table_); return out; }
/* * The function "mlfRank" contains the normal interface for the "rank" * M-function from file * "/space/lyon/9/pubsw/common/matlab/6.1/toolbox/matlab/matfun/rank.m" (lines * 1-17). This function processes any input arguments and passes them to the * implementation version of the function, appearing above. */ mxArray * mlfRank(mxArray * A, mxArray * tol) { int nargout = 1; mxArray * r = mclGetUninitializedArray(); mlfEnterNewContext(0, 2, A, tol); r = Mrank(nargout, A, tol); mlfRestorePreviousContext(0, 2, A, tol); return mlfReturnValue(r); }
/* * The function "mlfPrecise_step" contains the normal interface for the * "precise_step" M-function from file "d:\M6\work\precise_step.m" (lines 0-0). * This function processes any input arguments and passes them to the * implementation version of the function, appearing above. */ mxArray * mlfPrecise_step(mxArray * inargs) { int nargout = 1; mxArray * out = mclGetUninitializedArray(); mlfEnterNewContext(0, 1, inargs); out = Mprecise_step(nargout, inargs); mlfRestorePreviousContext(0, 1, inargs); return mlfReturnValue(out); }
/* * The function "mlfD_int" contains the normal interface for the "d_int" * M-function from file "d:\M6\work\d_int.m" (lines 0-0). This function * processes any input arguments and passes them to the implementation version * of the function, appearing above. */ mxArray * mlfD_int(mxArray * f, mxArray * int_region) { int nargout = 1; mxArray * out = mclGetUninitializedArray(); mlfEnterNewContext(0, 2, f, int_region); out = Md_int(nargout, f, int_region); mlfRestorePreviousContext(0, 2, f, int_region); return mlfReturnValue(out); }
/* * The function "mlxRank" contains the feval interface for the "rank" * M-function from file * "/space/lyon/9/pubsw/common/matlab/6.1/toolbox/matlab/matfun/rank.m" (lines * 1-17). The feval function calls the implementation version of rank through * this function. This function processes any input arguments and passes them * to the implementation version of the function, appearing above. */ void mlxRank(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) { mxArray * mprhs[2]; mxArray * mplhs[1]; int i; if (nlhs > 1) { mlfError(_mxarray0_); } if (nrhs > 2) { mlfError(_mxarray2_); } for (i = 0; i < 1; ++i) { mplhs[i] = mclGetUninitializedArray(); } for (i = 0; i < 2 && i < nrhs; ++i) { mprhs[i] = prhs[i]; } for (; i < 2; ++i) { mprhs[i] = NULL; } mlfEnterNewContext(0, 2, mprhs[0], mprhs[1]); mplhs[0] = Mrank(nlhs, mprhs[0], mprhs[1]); mlfRestorePreviousContext(0, 2, mprhs[0], mprhs[1]); plhs[0] = mplhs[0]; }
/* * The function "mlxPrecise_step" contains the feval interface for the * "precise_step" M-function from file "d:\M6\work\precise_step.m" (lines * 1-12). The feval function calls the implementation version of precise_step * through this function. This function processes any input arguments and * passes them to the implementation version of the function, appearing above. */ void mlxPrecise_step(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) { mxArray * mprhs[1]; mxArray * mplhs[1]; int i; if (nlhs > 1) { mlfError(_mxarray0_); } if (nrhs > 1) { mlfError(_mxarray2_); } for (i = 0; i < 1; ++i) { mplhs[i] = mclGetUninitializedArray(); } for (i = 0; i < 1 && i < nrhs; ++i) { mprhs[i] = prhs[i]; } for (; i < 1; ++i) { mprhs[i] = NULL; } mlfEnterNewContext(0, 1, mprhs[0]); mplhs[0] = Mprecise_step(nlhs, mprhs[0]); mlfRestorePreviousContext(0, 1, mprhs[0]); plhs[0] = mplhs[0]; }
/* * The function "Md_int" is the MATLAB callback version of the "d_int" function * from file "d:\M6\work\d_int.m". It performs a callback to MATLAB to run the * "d_int" function, and passes any resulting output arguments back to its * calling function. */ static mxArray * Md_int(int nargout_, mxArray * f, mxArray * int_region) { mxArray * out = mclGetUninitializedArray(); mclFevalCallMATLAB( mclNVarargout(nargout_, 0, &out, NULL), "d_int", f, int_region, NULL); return out; }
/* * The function "Mprecise_step" is the MATLAB callback version of the * "precise_step" function from file "d:\M6\work\precise_step.m". It performs a * callback to MATLAB to run the "precise_step" function, and passes any * resulting output arguments back to its calling function. */ static mxArray * Mprecise_step(int nargout_, mxArray * inargs) { mxArray * out = mclGetUninitializedArray(); mclFevalCallMATLAB( mclNVarargout(nargout_, 0, &out, NULL), "precise_step", inargs, NULL); return out; }