/*
* Arguments : const mxArray *prhs[3]
* const mxArray *plhs[2]
* Return Type : void
*/
void get_coherence_api(const mxArray *prhs[3], const mxArray *plhs[2])
{
real_T (*mscxy)[513];
real_T (*frequency_list)[513];
real_T (*x)[768];
real_T (*y)[768];
real_T fs;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
mscxy = (real_T (*)[513])mxMalloc(sizeof(real_T [513]));
frequency_list = (real_T (*)[513])mxMalloc(sizeof(real_T [513]));
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
/* Marshall function inputs */
x = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x");
y = emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "y");
fs = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "fs");
/* Invoke the target function */
get_coherence(*x, *y, fs, *mscxy, *frequency_list);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(*mscxy);
plhs[1] = b_emlrt_marshallOut(*frequency_list);
}
/*
* Arguments : const mxArray *prhs[5]
* const mxArray *plhs[1]
* Return Type : void
*/
void SpringForce_api(const mxArray *prhs[5], const mxArray *plhs[1])
{
emxArray_real_T *particleDist;
emxArray_real_T *springConst;
emxArray_boolean_T *connectivityMap;
emxArray_real_T *minParticleDist;
emxArray_real_T *fixedParticleNum;
emxArray_real_T *force;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &particleDist, 2, true);
emxInit_real_T(&st, &springConst, 2, true);
emxInit_boolean_T(&st, &connectivityMap, 2, true);
emxInit_real_T(&st, &minParticleDist, 2, true);
emxInit_real_T(&st, &fixedParticleNum, 2, true);
emxInit_real_T(&st, &force, 2, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1);
prhs[3] = emlrtProtectR2012b(prhs[3], 3, false, -1);
prhs[4] = emlrtProtectR2012b(prhs[4], 4, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "particleDist", particleDist);
emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "springConst", springConst);
c_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "connectivityMap",
connectivityMap);
emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "minParticleDist", minParticleDist);
e_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "fixedParticleNum",
fixedParticleNum);
/* Invoke the target function */
SpringForce(particleDist, springConst, connectivityMap, minParticleDist,
fixedParticleNum, force);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(force);
force->canFreeData = false;
emxFree_real_T(&force);
fixedParticleNum->canFreeData = false;
emxFree_real_T(&fixedParticleNum);
minParticleDist->canFreeData = false;
emxFree_real_T(&minParticleDist);
connectivityMap->canFreeData = false;
emxFree_boolean_T(&connectivityMap);
springConst->canFreeData = false;
emxFree_real_T(&springConst);
particleDist->canFreeData = false;
emxFree_real_T(&particleDist);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void util_sub_jaccard_index_api(const mxArray * const prhs[2], const mxArray
*plhs[1])
{
real_T a;
real_T b;
/* Marshall function inputs */
a = emlrt_marshallIn(emlrtAliasP(prhs[0]), "a");
b = emlrt_marshallIn(emlrtAliasP(prhs[1]), "b");
/* Invoke the target function */
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(util_sub_jaccard_index(a, b));
}
void vadsplitphon_api(const mxArray *prhs[1], const mxArray *plhs[2])
{
emxArray_real_T *x;
int32_T i_size[2];
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
mxMalloc(0U);
mxMalloc(0U);
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &x, 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 */
vadsplitphon(x, i_size);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut();
plhs[1] = i_emlrt_marshallOut(i_size);
x->canFreeData = false;
emxFree_real_T(&x);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void mfcc_api(const mxArray *prhs[1], const mxArray *plhs[1])
{
emxArray_real_T *samples;
emxArray_real_T *cepstra;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &samples, 1, true);
b_emxInit_real_T(&st, &cepstra, 2, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "samples", samples);
/* Invoke the target function */
mfcc(samples, cepstra);
/* Marshall function outputs */
plhs[0] = h_emlrt_marshallOut(cepstra);
cepstra->canFreeData = false;
emxFree_real_T(&cepstra);
samples->canFreeData = false;
emxFree_real_T(&samples);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void features_bvav2_api(const mxArray *prhs[2], const mxArray *plhs[1])
{
real_T (*ft)[13];
emxArray_real_T *audio;
real_T srate;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
ft = (real_T (*)[13])mxMalloc(sizeof(real_T [13]));
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &audio, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "audio", audio);
srate = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "srate");
/* Invoke the target function */
features_bvav2(audio, srate, *ft);
/* Marshall function outputs */
plhs[0] = g_emlrt_marshallOut(*ft);
audio->canFreeData = false;
emxFree_real_T(&audio);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void extractaudiophon_api(const mxArray *prhs[1], const mxArray *plhs[2])
{
emxArray_real_T *rawaudio;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
mxMalloc(0U);
mxMalloc(0U);
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &rawaudio, 1, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "rawaudio", rawaudio);
/* Invoke the target function */
extractaudiophon(rawaudio);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut();
plhs[1] = emlrt_marshallOut();
rawaudio->canFreeData = false;
emxFree_real_T(&rawaudio);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void G_api(const mxArray * const prhs[3], const mxArray *plhs[1])
{
emxArray_real_T *Y0;
emxArray_real_T *vecS0;
real_T (*para)[2];
real_T g;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &Y0, 2, &l_emlrtRTEI, true);
emxInit_real_T1(&st, &vecS0, 1, &l_emlrtRTEI, true);
/* Marshall function inputs */
para = emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[0]), "para");
c_emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[1]), "Y0", Y0);
e_emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[2]), "vecS0", vecS0);
/* Invoke the target function */
g = G(&st, *para, Y0, vecS0);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(g);
vecS0->canFreeData = false;
emxFree_real_T(&vecS0);
Y0->canFreeData = false;
emxFree_real_T(&Y0);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void makeHistFutTablewithRearrange_api(const mxArray * const prhs[4], const
mxArray *plhs[1])
{
emxArray_uint8_T *testm;
emxArray_real_T *rmat;
emxArray_real_T *y;
real_T range;
real_T dims;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_uint8_T(&st, &testm, 2, &h_emlrtRTEI, true);
emxInit_real_T1(&st, &rmat, 1, &h_emlrtRTEI, true);
emxInit_real_T(&st, &y, 2, &h_emlrtRTEI, true);
/* Marshall function inputs */
emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[0]), "testm", testm);
range = c_emlrt_marshallIn(&st, emlrtAliasP((const mxArray *)prhs[1]), "range");
dims = c_emlrt_marshallIn(&st, emlrtAliasP((const mxArray *)prhs[2]), "dims");
e_emlrt_marshallIn(&st, emlrtAlias((const mxArray *)prhs[3]), "rmat", rmat);
/* Invoke the target function */
makeHistFutTablewithRearrange(&st, testm, range, dims, rmat, y);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(y);
y->canFreeData = false;
emxFree_real_T(&y);
rmat->canFreeData = false;
emxFree_real_T(&rmat);
testm->canFreeData = false;
emxFree_uint8_T(&testm);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void nsht_legmat_api(const mxArray * const prhs[3], const mxArray *plhs[2])
{
emxArray_real_T *thetas;
emxArray_real_T *P;
emxArray_real_T *Sc;
real_T L;
real_T m;
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
emxInit_real_T(&thetas, 2, &b_emlrtRTEI, TRUE);
emxInit_real_T(&P, 2, &b_emlrtRTEI, TRUE);
emxInit_real_T(&Sc, 2, &b_emlrtRTEI, TRUE);
/* Marshall function inputs */
emlrt_marshallIn(emlrtAlias(prhs[0]), "thetas", thetas);
L = c_emlrt_marshallIn(emlrtAliasP(prhs[1]), "L");
m = c_emlrt_marshallIn(emlrtAliasP(prhs[2]), "m");
/* Invoke the target function */
nsht_legmat(thetas, L, m, P, Sc);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(P);
plhs[1] = emlrt_marshallOut(Sc);
Sc->canFreeData = FALSE;
emxFree_real_T(&Sc);
P->canFreeData = FALSE;
emxFree_real_T(&P);
thetas->canFreeData = FALSE;
emxFree_real_T(&thetas);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
void dummy_api(const mxArray * const prhs[2], const mxArray *plhs[1])
{
real_T a;
real_T b;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
/* Marshall function inputs */
a = emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "a");
b = emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "b");
/* Invoke the target function */
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(dummy(a, b));
}
void JenkinsCompare_api(JenkinsCompareStackData *SD, const mxArray * const prhs
[2], const mxArray *plhs[1])
{
emxArray_real_T *y;
real_T (*x)[78596];
real_T sampleRate;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, &y, 2, &gb_emlrtRTEI, true);
/* Marshall function inputs */
x = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x");
sampleRate = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "sampleRate");
/* Invoke the target function */
JenkinsCompare(SD, &st, *x, sampleRate, y);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(y);
y->canFreeData = false;
emxFree_real_T(&y);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void julia_v4_1_api(const mxArray * const prhs[3], const mxArray *plhs[2])
{
emxArray_creal_T *vz;
emxArray_real_T *iter;
creal_T c;
real_T maxiter;
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
emxInit_creal_T(&vz, 2, &c_emlrtRTEI, TRUE);
emxInit_real_T(&iter, 2, &c_emlrtRTEI, TRUE);
/* Marshall function inputs */
emlrt_marshallIn(emlrtAliasP(prhs[0]), "vz", vz);
c = c_emlrt_marshallIn(emlrtAliasP(prhs[1]), "c");
maxiter = e_emlrt_marshallIn(emlrtAliasP(prhs[2]), "maxiter");
/* Invoke the target function */
julia_v4_1(vz, c, maxiter, iter);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(iter);
plhs[1] = b_emlrt_marshallOut(vz);
iter->canFreeData = FALSE;
emxFree_real_T(&iter);
emxFree_creal_T(&vz);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
void BERCalculationSIMO_api(const mxArray * const prhs[2], const mxArray *plhs[1])
{
emxArray_real_T *bitsRX;
real_T type;
const mxArray *tmp;
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
emxInit_real_T(&bitsRX, 1, &b_emlrtRTEI, TRUE);
/* Marshall function inputs */
c_emlrt_marshallIn(emlrtAlias(prhs[0]), "bitsRX", bitsRX);
type = emlrt_marshallIn(emlrtAliasP(prhs[1]), "type");
/* Marshall in global variables */
tmp = mexGetVariable("global", "d");
if (tmp) {
e_emlrt_marshallIn(tmp, "d", &d);
d_dirty = 0U;
}
/* Invoke the target function */
type = BERCalculationSIMO(bitsRX, type);
/* Marshall out global variables */
mexPutVariable("global", "d", b_emlrt_marshallOut(&d));
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(type);
bitsRX->canFreeData = FALSE;
emxFree_real_T(&bitsRX);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
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 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 BWbetaNloop_api(const mxArray *prhs[2], const mxArray *plhs[1])
{
emxArray_real_T *beta;
emxArray_real_T *updater;
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
emxInit_real_T(&beta, 2, TRUE);
b_emxInit_real_T(&updater, 3, TRUE);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, TRUE, -1);
/* Marshall function inputs */
emlrt_marshallIn(emlrtAlias(prhs[0]), "beta", beta);
c_emlrt_marshallIn(emlrtAlias(prhs[1]), "updater", updater);
/* Invoke the target function */
BWbetaNloop(beta, updater);
/* Marshall function outputs */
emlrt_marshallOut(beta, prhs[0]);
plhs[0] = prhs[0];
updater->canFreeData = FALSE;
emxFree_real_T(&updater);
beta->canFreeData = FALSE;
emxFree_real_T(&beta);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
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);
}
/*
* Arguments : const mxArray *prhs[7]
* const mxArray *plhs[1]
* Return Type : void
*/
void classifyNotes_api(const mxArray *prhs[7], const mxArray *plhs[1])
{
emxArray_real_T *notes_gt;
emxArray_real_T *notes_tr;
struct0_T Results;
real_T onset_lim;
real_T dur_percent_range;
real_T min_dur_dist;
real_T f0_range_in_cents;
real_T hopsize;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
emxInit_real_T(&st, ¬es_gt, 2, true);
emxInit_real_T(&st, ¬es_tr, 2, true);
emxInitStruct_struct0_T(&st, &Results, 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]), "notes_gt", notes_gt);
emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "notes_tr", notes_tr);
onset_lim = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "onset_lim");
dur_percent_range = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]),
"dur_percent_range");
min_dur_dist = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "min_dur_dist");
f0_range_in_cents = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]),
"f0_range_in_cents");
hopsize = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "hopsize");
/* Invoke the target function */
classifyNotes(notes_gt, notes_tr, onset_lim, dur_percent_range, min_dur_dist,
f0_range_in_cents, hopsize, &Results);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(&Results);
emxFreeStruct_struct0_T(&Results);
notes_tr->canFreeData = false;
emxFree_real_T(¬es_tr);
notes_gt->canFreeData = false;
emxFree_real_T(¬es_gt);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void util_sub_normalized_dot_product_api(const mxArray * const prhs[2], const
mxArray *plhs[1])
{
int32_T a_size[1];
real_T a_data[100];
int32_T b_size[1];
real_T b_data[100];
real_T result;
/* Marshall function inputs */
emlrt_marshallIn(emlrtAliasP(prhs[0]), "a", a_data, a_size);
emlrt_marshallIn(emlrtAliasP(prhs[1]), "b", b_data, b_size);
/* Invoke the target function */
result = util_sub_normalized_dot_product(a_data, a_size, b_data, b_size);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(result);
}
void lg1_api(const mxArray * const prhs[1])
{
real_T scale;
/* Marshall function inputs */
scale = emlrt_marshallIn(emlrtAliasP(prhs[0]), "scale");
/* Invoke the target function */
lg1(scale);
}
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);
}
/*
* Arguments : const mxArray *prhs[7]
* const mxArray *plhs[2]
* Return Type : void
*/
void ekf_update_api(const mxArray *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]));
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1);
prhs[3] = emlrtProtectR2012b(prhs[3], 3, false, -1);
prhs[4] = emlrtProtectR2012b(prhs[4], 4, false, -1);
prhs[5] = emlrtProtectR2012b(prhs[5], 5, false, -1);
/* Marshall function inputs */
x_kk_kk = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x_kk_kk");
zm_k = emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "zm_k");
m0 = c_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "m0");
P_kk_kk = e_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "P_kk_kk");
Q = e_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "Q");
R = g_emlrt_marshallIn(&st, emlrtAlias(prhs[5]), "R");
dt = i_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "dt");
/* Invoke the target function */
ekf_update(*x_kk_kk, *zm_k, *m0, *P_kk_kk, *Q, *R, dt, *x_k_k, *P_k_k);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(*x_k_k);
plhs[1] = b_emlrt_marshallOut(*P_k_k);
}
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 features_ufb_api(const mxArray *prhs[7], const mxArray *plhs[1])
{
emxArray_real_T *ftvec;
emxArray_real_T *wvec;
emxArray_real_T *ilog;
emxArray_real_T *ftmin;
emxArray_real_T *ftmax;
real_T fbmin;
real_T fbmax;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
emlrtHeapReferenceStackEnterFcnR2012b(&st);
b_emxInit_real_T(&st, &ftvec, 2, true);
emxInit_real_T(&st, &wvec, 1, true);
b_emxInit_real_T(&st, &ilog, 2, true);
b_emxInit_real_T(&st, &ftmin, 2, true);
b_emxInit_real_T(&st, &ftmax, 2, true);
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1);
prhs[3] = emlrtProtectR2012b(prhs[3], 3, false, -1);
prhs[4] = emlrtProtectR2012b(prhs[4], 4, false, -1);
/* Marshall function inputs */
i_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "ftvec", ftvec);
emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "wvec", wvec);
i_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "ilog", ilog);
i_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "ftmin", ftmin);
i_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "ftmax", ftmax);
fbmin = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "fbmin");
fbmax = g_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "fbmax");
/* Invoke the target function */
fbmin = features_ufb(ftvec, wvec, ilog, ftmin, ftmax, fbmin, fbmax);
/* Marshall function outputs */
plhs[0] = b_emlrt_marshallOut(fbmin);
ftmax->canFreeData = false;
emxFree_real_T(&ftmax);
ftmin->canFreeData = false;
emxFree_real_T(&ftmin);
ilog->canFreeData = false;
emxFree_real_T(&ilog);
wvec->canFreeData = false;
emxFree_real_T(&wvec);
ftvec->canFreeData = false;
emxFree_real_T(&ftvec);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
/*
* Arguments : const mxArray * const prhs[1]
* const mxArray *plhs[1]
* Return Type : void
*/
void test_api(const mxArray * const prhs[1], const mxArray *plhs[1])
{
double b;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
/* Marshall function inputs */
b = emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "b");
/* Invoke the target function */
b = test(b);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(b);
}
void cic_fixpt_api(const mxArray * const prhs[1], const mxArray *plhs[1])
{
int16_T x;
int64_T y;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
/* Marshall function inputs */
x = emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "x");
/* Invoke the target function */
y = cic_fixpt(&st, x);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(&st, y);
}
void PPB_ann_api(const mxArray *prhs[1], const mxArray *plhs[1])
{
real_T (*x1)[16];
real_T b_y1;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
x1 = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x1");
/* Invoke the target function */
b_y1 = PPB_ann(*x1);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(b_y1);
}
/*
* Arguments : const mxArray *prhs[1]
* const mxArray *plhs[1]
* Return Type : void
*/
void digit_nn_predict_api(const mxArray *prhs[1], const mxArray *plhs[1])
{
real_T (*X)[784];
real_T p;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
X = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "X");
/* Invoke the target function */
p = digit_nn_predict(*X);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(p);
}
/* Function Definitions */
static real_T c_fprintf(real_T varargin_1)
{
real_T nbytes;
const mxArray *y;
static const int32_T iv46[2] = { 1, 7 };
const mxArray *m6;
char_T cv22[7];
int32_T i;
static const char_T cv23[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
static const int32_T iv47[2] = { 1, 48 };
char_T cv24[48];
static const char_T cv25[48] = { 'E', 'r', 'r', 'o', 'r', ':', ' ', 'm', 'a',
't', 'r', 'i', 'x', ' ', 's', 'q', 'u', 'a', 'r', 'e', ' ', 'r', 'o', 'o',
't', ' ', 'r', 'e', 's', 'i', 'd', 'u', 'a', 'l', ' ', 'n', 'o', 'r', 'm',
' ', 'i', 's', ' ', '%', 'g', '.', '\\', 'n' };
emlrtPushRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m6 = mxCreateCharArray(2, iv46);
for (i = 0; i < 7; i++) {
cv22[i] = cv23[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m6, cv22);
emlrtAssign(&y, m6);
b_y = NULL;
m6 = mxCreateCharArray(2, iv47);
for (i = 0; i < 48; i++) {
cv24[i] = cv25[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 48, m6, cv24);
emlrtAssign(&b_y, m6);
nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
emlrt_marshallOut(varargin_1), &p_emlrtMCI), "feval");
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
return nbytes;
}