void fastdfa_api(const mxArray *prhs[1], const mxArray *plhs[3])
{
emxArray_real_T *x;
emxArray_real_T *intervals;
emxArray_real_T *flucts;
real_T alpha;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &x, 1, true);
emxInit_real_T(&st, &intervals, 1, true);
emxInit_real_T(&st, &flucts, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x", x);
/* Invoke the target function */
fastdfa(x, &alpha, intervals, flucts);
/* Marshall function outputs */
plhs[0] = b_emlrt_marshallOut(alpha);
plhs[1] = c_emlrt_marshallOut(intervals);
plhs[2] = c_emlrt_marshallOut(flucts);
flucts->canFreeData = false;
emxFree_real_T(&flucts);
intervals->canFreeData = false;
emxFree_real_T(&intervals);
x->canFreeData = false;
emxFree_real_T(&x);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void swipep_api(const mxArray *prhs[8], const mxArray *plhs[3])
{
emxArray_real_T *x;
emxArray_real_T *p;
emxArray_real_T *t;
emxArray_real_T *s;
real_T fs;
real_T (*plim)[2];
real_T dt;
real_T dlog2p;
real_T dERBs;
real_T woverlap;
real_T sTHR;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &x, 1, true);
emxInit_real_T(&st, &p, 1, true);
emxInit_real_T(&st, &t, 1, true);
emxInit_real_T(&st, &s, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x", x);
fs = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "fs");
plim = k_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "plim");
dt = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "dt");
dlog2p = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "dlog2p");
dERBs = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "dERBs");
woverlap = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "woverlap");
sTHR = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[7]), "sTHR");
/* Invoke the target function */
swipep(x, fs, *plim, dt, dlog2p, dERBs, woverlap, sTHR, p, t, s);
/* Marshall function outputs */
plhs[0] = c_emlrt_marshallOut(p);
plhs[1] = c_emlrt_marshallOut(t);
plhs[2] = c_emlrt_marshallOut(s);
s->canFreeData = false;
emxFree_real_T(&s);
t->canFreeData = false;
emxFree_real_T(&t);
p->canFreeData = false;
emxFree_real_T(&p);
x->canFreeData = false;
emxFree_real_T(&x);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void Bone_api(const mxArray * const prhs[4], const mxArray *plhs[1])
{
real_T (*vals)[2];
emxArray_real_T *spacePoints;
emxArray_real_T *timePoints;
real_T k;
real_T t;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
vals = (real_T (*)[2])mxMalloc(sizeof(real_T [2]));
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &spacePoints, 2, &ub_emlrtRTEI, true);
emxInit_real_T(&st, &timePoints, 2, &ub_emlrtRTEI, true);
/* Marshall function inputs */
k = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "k");
e_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "spacePoints", spacePoints);
t = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "t");
e_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "timePoints", timePoints);
/* Invoke the target function */
Bone(&st, k, spacePoints, t, timePoints, *vals);
/* Marshall function outputs */
plhs[0] = c_emlrt_marshallOut(*vals);
timePoints->canFreeData = false;
emxFree_real_T(&timePoints);
spacePoints->canFreeData = false;
emxFree_real_T(&spacePoints);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void ekf_update_api(const mxArray * const prhs[7], const mxArray *plhs[2])
{
real_T (*x_k_k)[5];
real_T (*P_k_k)[25];
real_T (*x_kk_kk)[5];
real_T (*zm_k)[5];
real_T (*m0)[2];
real_T (*P_kk_kk)[25];
real_T (*Q)[25];
real_T (*R)[36];
real_T dt;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
x_k_k = (real_T (*)[5])mxMalloc(sizeof(real_T [5]));
P_k_k = (real_T (*)[25])mxMalloc(sizeof(real_T [25]));
/* Marshall function inputs */
x_kk_kk = c_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x_kk_kk");
zm_k = c_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "zm_k");
m0 = e_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "m0");
P_kk_kk = g_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "P_kk_kk");
Q = g_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "Q");
R = i_emlrt_marshallIn(&st, emlrtAlias(prhs[5]), "R");
dt = k_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "dt");
/* Invoke the target function */
ekf_update(&st, *x_kk_kk, *zm_k, *m0, *P_kk_kk, *Q, *R, dt, *x_k_k, *P_k_k);
/* Marshall function outputs */
plhs[0] = c_emlrt_marshallOut(*x_k_k);
plhs[1] = d_emlrt_marshallOut(*P_k_k);
}
void lomb_api(const mxArray *prhs[4], const mxArray *plhs[3])
{
emxArray_real_T *t;
emxArray_real_T *h;
emxArray_real_T *f;
emxArray_real_T *P;
emxArray_real_T *prob;
real_T ofac;
real_T hifac;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &t, 1, true);
emxInit_real_T(&st, &h, 1, true);
emxInit_real_T(&st, &f, 1, true);
emxInit_real_T(&st, &P, 1, true);
emxInit_real_T(&st, &prob, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "t", t);
emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "h", h);
ofac = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "ofac");
hifac = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "hifac");
/* Invoke the target function */
lomb(t, h, ofac, hifac, f, P, prob);
/* Marshall function outputs */
plhs[0] = c_emlrt_marshallOut(f);
plhs[1] = c_emlrt_marshallOut(P);
plhs[2] = c_emlrt_marshallOut(prob);
prob->canFreeData = false;
emxFree_real_T(&prob);
P->canFreeData = false;
emxFree_real_T(&P);
f->canFreeData = false;
emxFree_real_T(&f);
h->canFreeData = false;
emxFree_real_T(&h);
t->canFreeData = false;
emxFree_real_T(&t);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void lambert_api(const mxArray *prhs[5], const mxArray *plhs[4])
{
real_T (*V1)[3];
real_T (*V2)[3];
real_T (*extremal_distances)[2];
real_T (*r1vec)[3];
real_T (*r2vec)[3];
real_T tf;
real_T m;
real_T muC;
real_T exitflag;
emlrtStack st = { NULL, /* site */
NULL, /* tls */
NULL /* prev */
};
st.tls = emlrtRootTLSGlobal;
V1 = (real_T (*)[3])mxMalloc(sizeof(real_T [3]));
V2 = (real_T (*)[3])mxMalloc(sizeof(real_T [3]));
extremal_distances = (real_T (*)[2])mxMalloc(sizeof(real_T [2]));
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
/* Marshall function inputs */
r1vec = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "r1vec");
r2vec = emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "r2vec");
tf = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "tf");
m = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "m");
muC = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "muC");
/* Invoke the target function */
lambert(&st, *r1vec, *r2vec, tf, m, muC, *V1, *V2, *extremal_distances,
&exitflag);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(*V1);
plhs[1] = emlrt_marshallOut(*V2);
plhs[2] = b_emlrt_marshallOut(*extremal_distances);
plhs[3] = c_emlrt_marshallOut(exitflag);
}
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);
}
