/*
* 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];
}
/*
* The function "mlxMyeye" contains the feval interface for the "myeye"
* M-function from file "c:\matlab6p5\work\myeye.m" (lines 1-2). The feval
* function calls the implementation version of myeye through this function.
* This function processes any input arguments and passes them to the
* implementation version of the function, appearing above.
*/
void mlxMyeye(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: myeye Line: 1 Column: 1 The function \"myeye"
"\" was called with more than the declared number of outputs (1)."),
NULL);
}
if (nrhs > 1) {
mlfError(
mxCreateString(
"Run-time Error: File: myeye Line: 1 Column: 1 The function \"myeye"
"\" was called with more than the declared number of inputs (1)."),
NULL);
}
for (i = 0; i < 1; ++i) {
mplhs[i] = NULL;
}
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] = Mmyeye(nlhs, mprhs[0]);
mlfRestorePreviousContext(0, 1, mprhs[0]);
plhs[0] = mplhs[0];
}
/*
* The function "mlfAxis" contains the normal interface for the "axis"
* M-function from file "d:\matlab6p5p1\toolbox\matlab\graph2d\axis.m" (lines
* 0-0). This function processes any input arguments and passes them to the
* implementation version of the function, appearing above.
*/
mxArray * mlfAxis(mxArray * * ans2, mxArray * * ans3, ...) {
mxArray * varargin = NULL;
int nargout = 1;
mxArray * ans1 = NULL;
mxArray * ans2__ = NULL;
mxArray * ans3__ = NULL;
mlfVarargin(&varargin, ans3, 0);
mlfEnterNewContext(2, -1, ans2, ans3, varargin);
if (ans2 != NULL) {
++nargout;
}
if (ans3 != NULL) {
++nargout;
}
ans1 = Maxis(&ans2__, &ans3__, nargout, varargin);
mlfRestorePreviousContext(2, 0, ans2, ans3);
mxDestroyArray(varargin);
if (ans2 != NULL) {
mclCopyOutputArg(ans2, ans2__);
} else {
mxDestroyArray(ans2__);
}
if (ans3 != NULL) {
mclCopyOutputArg(ans3, ans3__);
} else {
mxDestroyArray(ans3__);
}
return mlfReturnValue(ans1);
}
/*
* The function "mlfNLegend" contains the nargout interface for the "legend"
* M-function from file "d:\matlab6p5p1\toolbox\matlab\graph2d\legend.m" (lines
* 0-0). This interface is only produced if the M-function uses the special
* variable "nargout". The nargout interface allows the number of requested
* outputs to be specified via the nargout argument, as opposed to the normal
* interface which dynamically calculates the number of outputs based on the
* number of non-NULL inputs it receives. This function processes any input
* arguments and passes them to the implementation version of the function,
* appearing above.
*/
mxArray * mlfNLegend(int nargout,
mxArray * * labelhandles,
mxArray * * outH,
mxArray * * outM,
...) {
mxArray * varargin = NULL;
mxArray * leghandle = NULL;
mxArray * labelhandles__ = NULL;
mxArray * outH__ = NULL;
mxArray * outM__ = NULL;
mlfVarargin(&varargin, outM, 0);
mlfEnterNewContext(3, -1, labelhandles, outH, outM, varargin);
leghandle = Mlegend(&labelhandles__, &outH__, &outM__, nargout, varargin);
mlfRestorePreviousContext(3, 0, labelhandles, outH, outM);
mxDestroyArray(varargin);
if (labelhandles != NULL) {
mclCopyOutputArg(labelhandles, labelhandles__);
} else {
mxDestroyArray(labelhandles__);
}
if (outH != NULL) {
mclCopyOutputArg(outH, outH__);
} else {
mxDestroyArray(outH__);
}
if (outM != NULL) {
mclCopyOutputArg(outM, outM__);
} else {
mxDestroyArray(outM__);
}
return mlfReturnValue(leghandle);
}
/*
* The function "mlxGrid" contains the feval interface for the "grid"
* M-function from file "d:\matlab6p5p1\toolbox\matlab\graph2d\grid.m" (lines
* 0-0). The feval function calls the implementation version of grid through
* this function. This function processes any input arguments and passes them
* to the implementation version of the function, appearing above.
*/
void mlxGrid(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
mxArray * mprhs[2];
int i;
if (nlhs > 0) {
mlfError(
mxCreateString(
"Run-time Error: File: grid Line: 1 Column: 1 The function \"grid\""
" was called with more than the declared number of outputs (0)."),
NULL);
}
if (nrhs > 2) {
mlfError(
mxCreateString(
"Run-time Error: File: grid Line: 1 Column: 1 The function \"grid"
"\" was called with more than the declared number of inputs (2)."),
NULL);
}
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]);
Mgrid(mprhs[0], mprhs[1]);
mlfRestorePreviousContext(0, 2, mprhs[0], mprhs[1]);
}
/*
* 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 "mlxIPEMHandleInputArguments" contains the feval interface for
* the "IPEMHandleInputArguments" M-function from file
* "/afs/cmb.ucdavis.edu/share/matlab/janata/models/IPEMToolbox/Common/IPEMHandl
* eInputArguments.m" (lines 0-0). The feval function calls the implementation
* version of IPEMHandleInputArguments through this function. This function
* processes any input arguments and passes them to the implementation version
* of the function, appearing above.
*/
void mlxIPEMHandleInputArguments(int nlhs,
mxArray * plhs[],
int nrhs,
mxArray * prhs[]) {
mxArray * mprhs[3];
mxArray * mplhs[1];
int i;
if (nrhs > 3) {
mlfError(
mxCreateString(
"Run-time Error: File: IPEMHandleInputArguments Line: 1 Co"
"lumn: 1 The function \"IPEMHandleInputArguments\" was cal"
"led with more than the declared number of inputs (3)."),
NULL);
}
for (i = 0; i < 1; ++i) {
mplhs[i] = NULL;
}
for (i = 0; i < 3 && i < nrhs; ++i) {
mprhs[i] = prhs[i];
}
for (; i < 3; ++i) {
mprhs[i] = NULL;
}
mlfEnterNewContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
mplhs[0] = MIPEMHandleInputArguments(nlhs, mprhs[0], mprhs[1], mprhs[2]);
mclAssignVarargoutCell(0, nlhs, plhs, mplhs[0]);
mlfRestorePreviousContext(0, 3, mprhs[0], mprhs[1], mprhs[2]);
}
/*
* The function "mlxAxis" contains the feval interface for the "axis"
* M-function from file "d:\matlab6p5p1\toolbox\matlab\graph2d\axis.m" (lines
* 0-0). The feval function calls the implementation version of axis through
* this function. This function processes any input arguments and passes them
* to the implementation version of the function, appearing above.
*/
void mlxAxis(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
mxArray * mprhs[1];
mxArray * mplhs[3];
int i;
if (nlhs > 3) {
mlfError(
mxCreateString(
"Run-time Error: File: axis Line: 1 Column: 1 The function \"axis\""
" was called with more than the declared number of outputs (3)."),
NULL);
}
for (i = 0; i < 3; ++i) {
mplhs[i] = NULL;
}
mlfEnterNewContext(0, 0);
mprhs[0] = NULL;
mlfAssign(&mprhs[0], mclCreateVararginCell(nrhs, prhs));
mplhs[0] = Maxis(&mplhs[1], &mplhs[2], nlhs, mprhs[0]);
mlfRestorePreviousContext(0, 0);
plhs[0] = mplhs[0];
for (i = 1; i < 3 && i < nlhs; ++i) {
plhs[i] = mplhs[i];
}
for (; i < 3; ++i) {
mxDestroyArray(mplhs[i]);
}
mxDestroyArray(mprhs[0]);
}
/*
* 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 "mlfMyminus" contains the normal interface for the "myminus"
* M-function from file "c:\matlab6p5\work\myminus.m" (lines 1-4). This
* function processes any input arguments and passes them to the implementation
* version of the function, appearing above.
*/
mxArray * mlfMyminus(mxArray * a, mxArray * b) {
int nargout = 1;
mxArray * y = NULL;
mlfEnterNewContext(0, 2, a, b);
y = Mmyminus(nargout, a, b);
mlfRestorePreviousContext(0, 2, a, b);
return mlfReturnValue(y);
}
/*
* The function "mlfMrank" contains the normal interface for the "mrank"
* M-function from file "d:\work\m_build2\mrank.m" (lines 1-6). This function
* processes any input arguments and passes them to the implementation version
* of the function, appearing above.
*/
mxArray * mlfMrank(mxArray * n) {
int nargout = 1;
mxArray * r = NULL;
mlfEnterNewContext(0, 1, n);
r = Mmrank(nargout, n);
mlfRestorePreviousContext(0, 1, n);
return mlfReturnValue(r);
}
/*
* The function "mlfMyeye" contains the normal interface for the "myeye"
* M-function from file "c:\matlab6p5\work\myeye.m" (lines 1-2). This function
* processes any input arguments and passes them to the implementation version
* of the function, appearing above.
*/
mxArray * mlfMyeye(mxArray * x) {
int nargout = 1;
mxArray * y = NULL;
mlfEnterNewContext(0, 1, x);
y = Mmyeye(nargout, x);
mlfRestorePreviousContext(0, 1, x);
return mlfReturnValue(y);
}
/*
* 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 "mlfGasket" contains the normal interface for the "gasket"
* M-function from file "d:\work\squaren\gasket.m" (lines 1-10). This function
* processes any input arguments and passes them to the implementation version
* of the function, appearing above.
*/
mxArray * mlfGasket(mxArray * numPoints) {
int nargout = 1;
mxArray * theImage = NULL;
mlfEnterNewContext(0, 1, numPoints);
theImage = Mgasket(nargout, numPoints);
mlfRestorePreviousContext(0, 1, numPoints);
return mlfReturnValue(theImage);
}
/*
* 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 "mlfVIPEMHandleInputArguments" contains the void interface for
* the "IPEMHandleInputArguments" M-function from file
* "/afs/cmb.ucdavis.edu/share/matlab/janata/models/IPEMToolbox/Common/IPEMHandl
* eInputArguments.m" (lines 0-0). The void interface is only produced if the
* M-function uses the special variable "nargout", and has at least one output.
* The void interface function specifies zero output arguments to the
* implementation version of the function, and in the event that the
* implementation version still returns an output (which, in MATLAB, would be
* assigned to the "ans" variable), it deallocates the output. This function
* processes any input arguments and passes them to the implementation version
* of the function, appearing above.
*/
void mlfVIPEMHandleInputArguments(mxArray * inPassedArgs,
mxArray * inNumFirstOptionalArg,
mxArray * inDefaults) {
mxArray * varargout = NULL;
mlfEnterNewContext(0, 3, inPassedArgs, inNumFirstOptionalArg, inDefaults);
varargout
= MIPEMHandleInputArguments(
0, inPassedArgs, inNumFirstOptionalArg, inDefaults);
mlfRestorePreviousContext(
0, 3, inPassedArgs, inNumFirstOptionalArg, inDefaults);
mxDestroyArray(varargout);
}
/*
* The function "mlfVAxis" contains the void interface for the "axis"
* M-function from file "d:\matlab6p5p1\toolbox\matlab\graph2d\axis.m" (lines
* 0-0). The void interface is only produced if the M-function uses the special
* variable "nargout", and has at least one output. The void interface function
* specifies zero output arguments to the implementation version of the
* function, and in the event that the implementation version still returns an
* output (which, in MATLAB, would be assigned to the "ans" variable), it
* deallocates the output. This function processes any input arguments and
* passes them to the implementation version of the function, appearing above.
*/
void mlfVAxis(mxArray * synthetic_varargin_argument, ...) {
mxArray * varargin = NULL;
mxArray * ans1 = NULL;
mxArray * ans2 = NULL;
mxArray * ans3 = NULL;
mlfVarargin(&varargin, synthetic_varargin_argument, 1);
mlfEnterNewContext(0, -1, varargin);
ans1 = Maxis(&ans2, &ans3, 0, synthetic_varargin_argument);
mlfRestorePreviousContext(0, 0);
mxDestroyArray(varargin);
mxDestroyArray(ans1);
mxDestroyArray(ans2);
}
/*
* The function "mlfIPEMHandleInputArguments" contains the normal interface for
* the "IPEMHandleInputArguments" M-function from file
* "/afs/cmb.ucdavis.edu/share/matlab/janata/models/IPEMToolbox/Common/IPEMHandl
* eInputArguments.m" (lines 0-0). This function processes any input arguments
* and passes them to the implementation version of the function, appearing
* above.
*/
mxArray * mlfIPEMHandleInputArguments(mlfVarargoutList * varargout,
mxArray * inPassedArgs,
mxArray * inNumFirstOptionalArg,
mxArray * inDefaults) {
int nargout = 0;
mlfEnterNewContext(0, 3, inPassedArgs, inNumFirstOptionalArg, inDefaults);
nargout += mclNargout(varargout);
*mlfGetVarargoutCellPtr(varargout)
= MIPEMHandleInputArguments(
nargout, inPassedArgs, inNumFirstOptionalArg, inDefaults);
mlfRestorePreviousContext(
0, 3, inPassedArgs, inNumFirstOptionalArg, inDefaults);
return mlfAssignOutputs(varargout);
}
/*
* The function "mlfVLegend" contains the void interface for the "legend"
* M-function from file "d:\matlab6p5p1\toolbox\matlab\graph2d\legend.m" (lines
* 0-0). The void interface is only produced if the M-function uses the special
* variable "nargout", and has at least one output. The void interface function
* specifies zero output arguments to the implementation version of the
* function, and in the event that the implementation version still returns an
* output (which, in MATLAB, would be assigned to the "ans" variable), it
* deallocates the output. This function processes any input arguments and
* passes them to the implementation version of the function, appearing above.
*/
void mlfVLegend(mxArray * synthetic_varargin_argument, ...) {
mxArray * varargin = NULL;
mxArray * leghandle = NULL;
mxArray * labelhandles = NULL;
mxArray * outH = NULL;
mxArray * outM = NULL;
mlfVarargin(&varargin, synthetic_varargin_argument, 1);
mlfEnterNewContext(0, -1, varargin);
leghandle
= Mlegend(&labelhandles, &outH, &outM, 0, synthetic_varargin_argument);
mlfRestorePreviousContext(0, 0);
mxDestroyArray(varargin);
mxDestroyArray(leghandle);
mxDestroyArray(labelhandles);
mxDestroyArray(outH);
}
/*
* The function "mlxMain" contains the feval interface for the "main"
* M-function from file "d:\work\m_build1\main.m" (lines 1-2). The feval
* function calls the implementation version of main through this function.
* This function processes any input arguments and passes them to the
* implementation version of the function, appearing above.
*/
void mlxMain(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
if (nlhs > 0) {
mlfError(
mxCreateString(
"Run-time Error: File: main Line: 1 Column: 1 The function \"main\""
" was called with more than the declared number of outputs (0)."),
NULL);
}
if (nrhs > 0) {
mlfError(
mxCreateString(
"Run-time Error: File: main Line: 1 Column: 1 The function \"main"
"\" was called with more than the declared number of inputs (0)."),
NULL);
}
mlfEnterNewContext(0, 0);
Mmain();
mlfRestorePreviousContext(0, 0);
}
/*
* 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 "mlfGrid" contains the normal interface for the "grid"
* M-function from file "d:\matlab6p5p1\toolbox\matlab\graph2d\grid.m" (lines
* 0-0). This function processes any input arguments and passes them to the
* implementation version of the function, appearing above.
*/
void mlfGrid(mxArray * arg1, mxArray * arg2) {
mlfEnterNewContext(0, 2, arg1, arg2);
Mgrid(arg1, arg2);
mlfRestorePreviousContext(0, 2, arg1, arg2);
}
/*
* The function "mlfMain" contains the normal interface for the "main"
* M-function from file "d:\work\m_build1\main.m" (lines 1-2). This function
* processes any input arguments and passes them to the implementation version
* of the function, appearing above.
*/
void mlfMain(void) {
mlfEnterNewContext(0, 0);
Mmain();
mlfRestorePreviousContext(0, 0);
}
