/* * 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); }
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 PlotResults_api(const mxArray * const prhs[4]) { emxArray_real_T *t; emxArray_real_T *sigIn; emxArray_real_T *u; emxArray_real_T *r; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; emlrtHeapReferenceStackEnterFcnR2012b(&st); emxInit_real_T(&st, &t, 2, &ub_emlrtRTEI, true); emxInit_real_T(&st, &sigIn, 2, &ub_emlrtRTEI, true); emxInit_real_T(&st, &u, 2, &ub_emlrtRTEI, true); b_emxInit_real_T(&st, &r, 1, &ub_emlrtRTEI, true); /* Marshall function inputs */ e_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "t", t); e_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "sigIn", sigIn); g_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "u", u); i_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "r", r); /* Invoke the target function */ PlotResults(&st, t, sigIn, u, r); r->canFreeData = false; emxFree_real_T(&r); u->canFreeData = false; emxFree_real_T(&u); sigIn->canFreeData = false; emxFree_real_T(&sigIn); t->canFreeData = false; emxFree_real_T(&t); emlrtHeapReferenceStackLeaveFcnR2012b(&st); }
void Done_api(const mxArray * const prhs[5], const mxArray *plhs[1]) { emxArray_real_T *spacePoints; emxArray_real_T *timePoints; emxArray_real_T *f; real_T k; real_T t; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; emlrtHeapReferenceStackEnterFcnR2012b(&st); emxInit_real_T(&st, &spacePoints, 2, &ub_emlrtRTEI, true); emxInit_real_T(&st, &timePoints, 2, &ub_emlrtRTEI, true); emxInit_real_T(&st, &f, 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); g_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "f", f); /* Invoke the target function */ k = Done(&st, k, spacePoints, t, timePoints, f); /* Marshall function outputs */ plhs[0] = emlrt_marshallOut(k); f->canFreeData = false; emxFree_real_T(&f); timePoints->canFreeData = false; emxFree_real_T(&timePoints); spacePoints->canFreeData = false; emxFree_real_T(&spacePoints); 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 BoneStar_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 */ BoneStar(&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 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 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); }
/* * 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 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); }
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 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 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 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 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 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 Ccoeff_api(const mxArray * const prhs[4], const mxArray *plhs[1]) { emxArray_real_T *x; emxArray_real_T *vals; real_T k; real_T t; real_T spacePoints; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; emlrtHeapReferenceStackEnterFcnR2012b(&st); emxInit_real_T(&st, &x, 2, &ub_emlrtRTEI, true); emxInit_real_T(&st, &vals, 2, &ub_emlrtRTEI, true); /* Marshall function inputs */ k = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "k"); e_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "x", x); t = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "t"); spacePoints = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "spacePoints"); /* Invoke the target function */ Ccoeff(&st, k, x, t, spacePoints, vals); /* Marshall function outputs */ plhs[0] = d_emlrt_marshallOut(vals); vals->canFreeData = false; emxFree_real_T(&vals); x->canFreeData = false; emxFree_real_T(&x); 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 Bcoeff_api(const mxArray * const prhs[5], const mxArray *plhs[1]) { emxArray_real_T *timePoints; real_T ksi; real_T j; real_T x; real_T t; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; emlrtHeapReferenceStackEnterFcnR2012b(&st); emxInit_real_T(&st, &timePoints, 2, &ub_emlrtRTEI, true); /* Marshall function inputs */ ksi = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "ksi"); j = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "j"); x = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "x"); t = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "t"); e_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "timePoints", timePoints); /* Invoke the target function */ ksi = Bcoeff(&st, ksi, j, x, t, timePoints); /* Marshall function outputs */ plhs[0] = emlrt_marshallOut(ksi); timePoints->canFreeData = false; emxFree_real_T(&timePoints); emlrtHeapReferenceStackLeaveFcnR2012b(&st); }
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); }
static boolean_T l_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const emlrtMsgIdentifier *parentId) { boolean_T y; y = r_emlrt_marshallIn(sp, emlrtAlias(u), parentId); emlrtDestroyArray(&u); return y; }
/* Function Definitions */ real_T b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const emlrtMsgIdentifier *parentId) { real_T y; y = n_emlrt_marshallIn(sp, emlrtAlias(u), parentId); emlrtDestroyArray(&u); return y; }
/* * Arguments : const emlrtStack *sp * const mxArray *u * const emlrtMsgIdentifier *parentId * Return Type : double (*)[4] */ static double (*b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const emlrtMsgIdentifier *parentId))[4] { double (*y)[4]; y = c_emlrt_marshallIn(sp, emlrtAlias(u), parentId); emlrtDestroyArray(&u); return y; }
/* Function Definitions */ static real_T (*b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const emlrtMsgIdentifier *parentId))[2] { real_T (*y)[2]; y = g_emlrt_marshallIn(sp, emlrtAlias(u), parentId); emlrtDestroyArray(&u); return y; }
/* Function Definitions */ static real_T b_emlrt_marshallIn(const mxArray *u, const emlrtMsgIdentifier *parentId) { real_T y; y = c_emlrt_marshallIn(emlrtAlias(u), parentId); emlrtDestroyArray(&u); return y; }
static void e_emlrt_marshallIn(const emlrtStack *sp, const mxArray *timePoints, const char_T *identifier, emxArray_real_T *y) { emlrtMsgIdentifier thisId; thisId.fIdentifier = identifier; thisId.fParent = NULL; f_emlrt_marshallIn(sp, emlrtAlias(timePoints), &thisId, y); emlrtDestroyArray(&timePoints); }
/* * Arguments : const emlrtStack *sp * const mxArray *engKinMat_engKinInx_wayInx * const char_T *identifier * emxArray_real_T *y * Return Type : void */ static void e_emlrt_marshallIn(const emlrtStack *sp, const mxArray *engKinMat_engKinInx_wayInx, const char_T *identifier, emxArray_real_T *y) { emlrtMsgIdentifier thisId; thisId.fIdentifier = identifier; thisId.fParent = NULL; f_emlrt_marshallIn(sp, emlrtAlias(engKinMat_engKinInx_wayInx), &thisId, y); emlrtDestroyArray(&engKinMat_engKinInx_wayInx); }
static void i_emlrt_marshallIn(const emlrtStack *sp, const mxArray *r, const char_T *identifier, emxArray_real_T *y) { emlrtMsgIdentifier thisId; thisId.fIdentifier = identifier; thisId.fParent = NULL; j_emlrt_marshallIn(sp, emlrtAlias(r), &thisId, y); emlrtDestroyArray(&r); }