void GetRegularizationTerm_api(const mxArray * const prhs[2], const mxArray
*plhs[1])
{
emxArray_real_T *regTerm;
real_T N;
real_T order;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, ®Term, 2, &ub_emlrtRTEI, true);
/* Marshall function inputs */
N = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "N");
order = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "order");
/* Invoke the target function */
GetRegularizationTerm(&st, N, order, regTerm);
/* Marshall function outputs */
plhs[0] = e_emlrt_marshallOut(regTerm);
regTerm->canFreeData = false;
emxFree_real_T(®Term);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void Cone_api(const mxArray * const prhs[3], const mxArray *plhs[1])
{
emxArray_real_T *x;
emxArray_real_T *spacePoints;
emxArray_real_T *t;
emxArray_real_T *vals;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &x, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &spacePoints, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &t, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &vals, 2, &ub_emlrtRTEI, true);
/* Marshall function inputs */
e_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x", x);
e_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "spacePoints", spacePoints);
e_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "t", t);
/* Invoke the target function */
Cone(&st, x, spacePoints, t, vals);
/* Marshall function outputs */
plhs[0] = e_emlrt_marshallOut(vals);
vals->canFreeData = false;
emxFree_real_T(&vals);
t->canFreeData = false;
emxFree_real_T(&t);
spacePoints->canFreeData = false;
emxFree_real_T(&spacePoints);
x->canFreeData = false;
emxFree_real_T(&x);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void transceive102_api(transceive102StackData *SD, const mxArray * const prhs[8],
const mxArray *plhs[2])
{
creal_T d2s[1408];
boolean_T ft;
real_T txGain;
real_T rxGain;
real_T centerFreqTx;
real_T centerFreqRx;
real_T intFactor;
real_T decFactor;
uint32_T ns;
creal_T dr[1408];
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "d2s", d2s);
ft = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "ft");
txGain = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "txGain");
rxGain = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "rxGain");
centerFreqTx = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "centerFreqTx");
centerFreqRx = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "centerFreqRx");
intFactor = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "intFactor");
decFactor = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[7]), "decFactor");
/* Invoke the target function */
transceive102(SD, &st, d2s, ft, txGain, rxGain, centerFreqTx, centerFreqRx,
intFactor, decFactor, dr, &ns);
/* Marshall function outputs */
plhs[0] = d_emlrt_marshallOut(&st, dr);
plhs[1] = e_emlrt_marshallOut(ns);
}
void features_bpa_api(const mxArray *prhs[1], const mxArray *plhs[1])
{
real_T (*ft)[3];
emxArray_real_T *post;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
ft = (real_T (*)[3])mxMalloc(sizeof(real_T [3]));
emlrtHeapReferenceStackEnterFcnR2012b(&st);
b_emxInit_real_T(&st, &post, 2, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
c_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "post", post);
/* Invoke the target function */
features_bpa(post, *ft);
/* Marshall function outputs */
plhs[0] = e_emlrt_marshallOut(*ft);
post->canFreeData = false;
emxFree_real_T(&post);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void occflow_api(const mxArray *prhs[18], const mxArray *plhs[4])
{
emxArray_real_T *cgridvec;
emxArray_real_T *cgridvecprev;
emxArray_real_T *context;
emxArray_real_T *nei_idx;
emxArray_real_T *nei_weight;
emxArray_real_T *nei4u_idx;
emxArray_real_T *nei4u_weight;
emxArray_real_T *predvec;
emxArray_real_T *maxvec;
real_T nei_filter_n;
real_T nei4u_filter_n;
real_T occval;
real_T minthreshold;
real_T maxthreshold;
real_T reinitval;
real_T intensifyrate;
real_T nocc_attenuaterate;
real_T unknown_attenuaterate;
real_T sigm_coef;
real_T do_attenuation_first;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &cgridvec, 1, &b_emlrtRTEI, true);
emxInit_real_T(&st, &cgridvecprev, 1, &b_emlrtRTEI, true);
emxInit_real_T1(&st, &context, 2, &b_emlrtRTEI, true);
emxInit_real_T1(&st, &nei_idx, 2, &b_emlrtRTEI, true);
emxInit_real_T1(&st, &nei_weight, 2, &b_emlrtRTEI, true);
emxInit_real_T1(&st, &nei4u_idx, 2, &b_emlrtRTEI, true);
emxInit_real_T1(&st, &nei4u_weight, 2, &b_emlrtRTEI, true);
emxInit_real_T(&st, &predvec, 1, &b_emlrtRTEI, true);
emxInit_real_T(&st, &maxvec, 1, &b_emlrtRTEI, true);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, true, -1);
prhs[2] = emlrtProtectR2012b(prhs[2], 2, true, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "cgridvec", cgridvec);
emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "cgridvecprev", cgridvecprev);
c_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "context", context);
c_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "nei_idx", nei_idx);
c_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "nei_weight", nei_weight);
nei_filter_n = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "nei_filter_n");
c_emlrt_marshallIn(&st, emlrtAlias(prhs[6]), "nei4u_idx", nei4u_idx);
c_emlrt_marshallIn(&st, emlrtAlias(prhs[7]), "nei4u_weight", nei4u_weight);
nei4u_filter_n = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[8]),
"nei4u_filter_n");
occval = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[9]), "occval");
minthreshold = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[10]), "minthreshold");
maxthreshold = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[11]), "maxthreshold");
reinitval = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[12]), "reinitval");
intensifyrate = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[13]), "intensifyrate");
nocc_attenuaterate = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[14]),
"nocc_attenuaterate");
unknown_attenuaterate = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[15]),
"unknown_attenuaterate");
sigm_coef = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[16]), "sigm_coef");
do_attenuation_first = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[17]),
"do_attenuation_first");
/* Invoke the target function */
occflow(&st, cgridvec, cgridvecprev, context, nei_idx, nei_weight,
nei_filter_n, nei4u_idx, nei4u_weight, nei4u_filter_n, occval,
minthreshold, maxthreshold, reinitval, intensifyrate,
nocc_attenuaterate, unknown_attenuaterate, sigm_coef,
do_attenuation_first, predvec, maxvec);
/* Marshall function outputs */
plhs[0] = c_emlrt_marshallOut(predvec);
d_emlrt_marshallOut(cgridvecprev, prhs[1]);
plhs[1] = prhs[1];
e_emlrt_marshallOut(context, prhs[2]);
plhs[2] = prhs[2];
plhs[3] = c_emlrt_marshallOut(maxvec);
maxvec->canFreeData = false;
emxFree_real_T(&maxvec);
predvec->canFreeData = false;
emxFree_real_T(&predvec);
nei4u_weight->canFreeData = false;
emxFree_real_T(&nei4u_weight);
nei4u_idx->canFreeData = false;
emxFree_real_T(&nei4u_idx);
nei_weight->canFreeData = false;
emxFree_real_T(&nei_weight);
nei_idx->canFreeData = false;
emxFree_real_T(&nei_idx);
context->canFreeData = false;
emxFree_real_T(&context);
cgridvecprev->canFreeData = false;
emxFree_real_T(&cgridvecprev);
cgridvec->canFreeData = false;
emxFree_real_T(&cgridvec);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
