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 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 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 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 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 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 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 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 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 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); }
/* Function Definitions */ static real_T b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const emlrtMsgIdentifier *parentId) { real_T y; y = e_emlrt_marshallIn(sp, emlrtAlias(u), parentId); emlrtDestroyArray(&u); return y; }
/* * 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 Dcoeff_api(const mxArray * const prhs[6], const mxArray *plhs[1]) { emxArray_real_T *y; emxArray_real_T *x; emxArray_real_T *timePoints; emxArray_real_T *f; real_T j; real_T t; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; emlrtHeapReferenceStackEnterFcnR2012b(&st); emxInit_real_T(&st, &y, 2, &ub_emlrtRTEI, true); emxInit_real_T(&st, &x, 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 */ e_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "y", y); j = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "j"); e_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "x", x); t = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "t"); e_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "timePoints", timePoints); e_emlrt_marshallIn(&st, emlrtAlias(prhs[5]), "f", f); /* Invoke the target function */ j = Dcoeff(&st, y, j, x, t, timePoints, f); /* Marshall function outputs */ plhs[0] = emlrt_marshallOut(j); f->canFreeData = false; emxFree_real_T(&f); timePoints->canFreeData = false; emxFree_real_T(&timePoints); x->canFreeData = false; emxFree_real_T(&x); y->canFreeData = false; emxFree_real_T(&y); 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 testMACRouter_api(testMACRouterStackData *SD, emlrtStack *sp, const mxArray * const prhs[2]) { real_T (*offsets)[3]; real_T nodeNum; /* Marshall function inputs */ offsets = e_emlrt_marshallIn(sp, emlrtAlias(prhs[0]), "offsets"); nodeNum = c_emlrt_marshallIn(sp, emlrtAliasP(prhs[1]), "nodeNum"); /* Invoke the target function */ testMACRouter(SD, sp, *offsets, nodeNum); }
/* Function Definitions */ static real_T c_fprintf(const emlrtStack *sp) { const mxArray *y; static const int32_T iv8[2] = { 1, 7 }; const mxArray *m1; char_T cv14[7]; int32_T i; static const char_T cv15[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' }; const mxArray *b_y; const mxArray *c_y; static const int32_T iv9[2] = { 1, 50 }; char_T cv16[50]; static const char_T cv17[50] = { 'R', 'e', 'm', 'e', 'm', 'b', 'e', 'r', ' ', 't', 'o', ' ', 'c', 'o', 'm', 'p', 'a', 'r', 'e', ' ', 'o', 'u', 't', 'p', 'u', 't', ' ', 'f', 'i', 'l', 'e', 's', ' ', 'w', 'i', 't', 'h', ' ', 'm', 'd', '5', ' ', 'o', 'r', ' ', 'S', 'H', 'A', '\\', 'n' }; emlrtStack st; st.prev = sp; st.tls = sp->tls; y = NULL; m1 = mxCreateCharArray(2, iv8); for (i = 0; i < 7; i++) { cv14[i] = cv15[i]; } emlrtInitCharArrayR2013a(sp, 7, m1, cv14); emlrtAssign(&y, m1); b_y = NULL; m1 = mxCreateDoubleScalar(1.0); emlrtAssign(&b_y, m1); c_y = NULL; m1 = mxCreateCharArray(2, iv9); for (i = 0; i < 50; i++) { cv16[i] = cv17[i]; } emlrtInitCharArrayR2013a(sp, 50, m1, cv16); emlrtAssign(&c_y, m1); st.site = &cb_emlrtRSI; return e_emlrt_marshallIn(&st, feval(&st, y, b_y, c_y, &r_emlrtMCI), "feval"); }
static real_T e_fprintf(const emlrtStack *sp) { const mxArray *y; static const int32_T iv10[2] = { 1, 7 }; const mxArray *m2; char_T cv18[7]; int32_T i; static const char_T cv19[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' }; const mxArray *b_y; const mxArray *c_y; static const int32_T iv11[2] = { 1, 31 }; char_T cv20[31]; static const char_T cv21[31] = { 'f', 'i', 'l', 'e', 'S', 'o', 'u', 'r', 'c', 'e', 'S', 'i', 'n', 'k', ' ', 'T', 'e', 's', 't', ' ', 'C', 'o', 'm', 'p', 'l', 'e', 't', 'e', 'd', '\\', 'n' }; emlrtStack st; st.prev = sp; st.tls = sp->tls; y = NULL; m2 = mxCreateCharArray(2, iv10); for (i = 0; i < 7; i++) { cv18[i] = cv19[i]; } emlrtInitCharArrayR2013a(sp, 7, m2, cv18); emlrtAssign(&y, m2); b_y = NULL; m2 = mxCreateDoubleScalar(1.0); emlrtAssign(&b_y, m2); c_y = NULL; m2 = mxCreateCharArray(2, iv11); for (i = 0; i < 31; i++) { cv20[i] = cv21[i]; } emlrtInitCharArrayR2013a(sp, 31, m2, cv20); emlrtAssign(&c_y, m2); st.site = &cb_emlrtRSI; return e_emlrt_marshallIn(&st, feval(&st, y, b_y, c_y, &r_emlrtMCI), "feval"); }
/* * Arguments : const mxArray *prhs[9] * const mxArray *plhs[2] * Return Type : void */ void gp_RPSSVEP_api(const mxArray *prhs[9], const mxArray *plhs[2]) { real_T (*GTargets)[3]; real_T yr; real_T (*ys)[4096]; real_T (*f_interest)[6]; real_T (*canais)[4]; real_T win_type; real_T overlap; real_T NFFT; real_T fs; real_T class_type; real_T idx; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; GTargets = (real_T (*)[3])mxMalloc(sizeof(real_T [3])); prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1); prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1); prhs[3] = emlrtProtectR2012b(prhs[3], 3, false, -1); /* Marshall function inputs */ yr = emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "yr"); ys = c_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "ys"); f_interest = e_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "f_interest"); canais = g_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "canais"); win_type = emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "win_type"); overlap = emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "overlap"); NFFT = emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "NFFT"); fs = emlrt_marshallIn(&st, emlrtAliasP(prhs[7]), "fs"); class_type = emlrt_marshallIn(&st, emlrtAliasP(prhs[8]), "class_type"); /* Invoke the target function */ gp_RPSSVEP(yr, *ys, *f_interest, *canais, win_type, overlap, NFFT, fs, class_type, *GTargets, &idx); /* Marshall function outputs */ plhs[0] = emlrt_marshallOut(*GTargets); plhs[1] = b_emlrt_marshallOut(idx); }
void goodJsym_api(const mxArray * const prhs[3], const mxArray *plhs[1]) { real_T (*A0)[40]; real_T (*var1)[6]; real_T (*var2)[5]; real_T zz; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; A0 = (real_T (*)[40])mxMalloc(sizeof(real_T [40])); /* Marshall function inputs */ var1 = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "var1"); var2 = c_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "var2"); zz = e_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "zz"); /* Invoke the target function */ goodJsym(&st, *var1, *var2, zz, *A0); /* Marshall function outputs */ plhs[0] = b_emlrt_marshallOut(*A0); }
void TestBemHeatEq_optimized_api(const mxArray * const prhs[4], const mxArray *plhs[2]) { emxArray_real_T *sigIn; emxArray_real_T *u; emxArray_real_T *r; real_T regOrder; real_T lambda; boolean_T plotFlag; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; emlrtHeapReferenceStackEnterFcnR2012b(&st); 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]), "sigIn", sigIn); regOrder = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "regOrder"); lambda = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "lambda"); plotFlag = k_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "plotFlag"); /* Invoke the target function */ TestBemHeatEq_optimized(&st, sigIn, regOrder, lambda, plotFlag, u, r); /* Marshall function outputs */ plhs[0] = f_emlrt_marshallOut(u); plhs[1] = g_emlrt_marshallOut(r); r->canFreeData = false; emxFree_real_T(&r); u->canFreeData = false; emxFree_real_T(&u); sigIn->canFreeData = false; emxFree_real_T(&sigIn); emlrtHeapReferenceStackLeaveFcnR2012b(&st); }
void features_bta_api(const mxArray *prhs[1], const mxArray *plhs[1]) { real_T (*ft)[2]; emxArray_real_T *tap; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; ft = (real_T (*)[2])mxMalloc(sizeof(real_T [2])); emlrtHeapReferenceStackEnterFcnR2012b(&st); b_emxInit_real_T(&st, &tap, 2, true); prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1); /* Marshall function inputs */ e_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "tap", tap); /* Invoke the target function */ features_bta(tap, *ft); /* Marshall function outputs */ plhs[0] = f_emlrt_marshallOut(*ft); tap->canFreeData = false; emxFree_real_T(&tap); emlrtHeapReferenceStackLeaveFcnR2012b(&st); }
/* Function Definitions */ static void b_emlrt_marshallIn(const mxArray *u, const emlrtMsgIdentifier *parentId, emxArray_real_T *y) { e_emlrt_marshallIn(emlrtAlias(u), parentId, y); emlrtDestroyArray(&u); }
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); }
/* * Arguments : const mxArray *prhs[15] * const mxArray *plhs[7] * Return Type : void */ void clcOptTrj_tmp_api(const mxArray *prhs[15], const mxArray *plhs[7]) { emxArray_real_T *engKinNumVec_wayInx; emxArray_real_T *engKinMat_engKinInx_wayInx; emxArray_real_T *engKinOptVec; emxArray_real_T *batEngDltOptVec; emxArray_real_T *fulEngDltOptVec; emxArray_real_T *staVec; emxArray_real_T *psiEngKinOptVec; real_T disFlg; real_T wayStp; real_T wayNum; real_T wayInxBeg; real_T wayInxEnd; real_T staEnd; real_T engKinNum; real_T engKinEndInxVal; real_T staNum; real_T (*optPreInxTn3)[52800]; real_T (*batFrcOptTn3)[52800]; real_T (*fulEngOptTn3)[52800]; real_T (*cos2goActMat)[66]; real_T engKinEndInx; real_T fulEngOpt; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; emlrtHeapReferenceStackEnterFcnR2012b(&st); emxInit_real_T(&st, &engKinNumVec_wayInx, 1, true); b_emxInit_real_T(&st, &engKinMat_engKinInx_wayInx, 2, true); emxInit_real_T(&st, &engKinOptVec, 1, true); emxInit_real_T(&st, &batEngDltOptVec, 1, true); emxInit_real_T(&st, &fulEngDltOptVec, 1, true); emxInit_real_T(&st, &staVec, 1, true); emxInit_real_T(&st, &psiEngKinOptVec, 1, true); prhs[9] = emlrtProtectR2012b(prhs[9], 9, false, -1); prhs[10] = emlrtProtectR2012b(prhs[10], 10, false, -1); prhs[11] = emlrtProtectR2012b(prhs[11], 11, false, -1); prhs[12] = emlrtProtectR2012b(prhs[12], 12, false, -1); prhs[13] = emlrtProtectR2012b(prhs[13], 13, false, -1); prhs[14] = emlrtProtectR2012b(prhs[14], 14, false, -1); /* Marshall function inputs */ disFlg = emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "disFlg"); wayStp = emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "wayStp"); wayNum = emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "wayNum"); wayInxBeg = emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "wayInxBeg"); wayInxEnd = emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "wayInxEnd"); staEnd = emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "staEnd"); engKinNum = emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "engKinNum"); engKinEndInxVal = emlrt_marshallIn(&st, emlrtAliasP(prhs[7]), "engKinEndInxVal"); staNum = emlrt_marshallIn(&st, emlrtAliasP(prhs[8]), "staNum"); c_emlrt_marshallIn(&st, emlrtAlias(prhs[9]), "engKinNumVec_wayInx", engKinNumVec_wayInx); e_emlrt_marshallIn(&st, emlrtAlias(prhs[10]), "engKinMat_engKinInx_wayInx", engKinMat_engKinInx_wayInx); optPreInxTn3 = g_emlrt_marshallIn(&st, emlrtAlias(prhs[11]), "optPreInxTn3"); batFrcOptTn3 = g_emlrt_marshallIn(&st, emlrtAlias(prhs[12]), "batFrcOptTn3"); fulEngOptTn3 = g_emlrt_marshallIn(&st, emlrtAlias(prhs[13]), "fulEngOptTn3"); cos2goActMat = i_emlrt_marshallIn(&st, emlrtAlias(prhs[14]), "cos2goActMat"); /* Invoke the target function */ clcOptTrj_tmp(disFlg, wayStp, wayNum, wayInxBeg, wayInxEnd, staEnd, engKinNum, engKinEndInxVal, staNum, engKinNumVec_wayInx, engKinMat_engKinInx_wayInx, *optPreInxTn3, *batFrcOptTn3, *fulEngOptTn3, *cos2goActMat, engKinOptVec, batEngDltOptVec, fulEngDltOptVec, staVec, psiEngKinOptVec, &fulEngOpt, &engKinEndInx); /* Marshall function outputs */ plhs[0] = emlrt_marshallOut(engKinOptVec); plhs[1] = emlrt_marshallOut(batEngDltOptVec); plhs[2] = emlrt_marshallOut(fulEngDltOptVec); plhs[3] = emlrt_marshallOut(staVec); plhs[4] = emlrt_marshallOut(psiEngKinOptVec); plhs[5] = b_emlrt_marshallOut(fulEngOpt); plhs[6] = b_emlrt_marshallOut(engKinEndInx); psiEngKinOptVec->canFreeData = false; emxFree_real_T(&psiEngKinOptVec); staVec->canFreeData = false; emxFree_real_T(&staVec); fulEngDltOptVec->canFreeData = false; emxFree_real_T(&fulEngDltOptVec); batEngDltOptVec->canFreeData = false; emxFree_real_T(&batEngDltOptVec); engKinOptVec->canFreeData = false; emxFree_real_T(&engKinOptVec); engKinMat_engKinInx_wayInx->canFreeData = false; emxFree_real_T(&engKinMat_engKinInx_wayInx); engKinNumVec_wayInx->canFreeData = false; emxFree_real_T(&engKinNumVec_wayInx); emlrtHeapReferenceStackLeaveFcnR2012b(&st); }
/* * Arguments : const mxArray *prhs[19] * const mxArray *plhs[4] * Return Type : void */ void clcDP_olyHyb_tmp_api(const mxArray *prhs[19], const mxArray *plhs[4]) { emxArray_real_T *engKinNumVec_wayInx; emxArray_real_T *slpVec_wayInx; emxArray_real_T *engKinMat_engKinInx_wayInx; static struct0_T FZG; emxArray_real_T *optPreInxTn3; emxArray_real_T *batFrcOptTn3; emxArray_real_T *fulEngOptTn3; emxArray_real_T *cos2goActMat; real_T disFlg; real_T wayStp; real_T batEngStp; real_T batEngBeg; real_T batPwrAux; real_T psiBatEng; real_T psiTim; real_T staChgPenCosVal; real_T wayInxBeg; real_T wayInxEnd; real_T engKinBegInx; real_T engKinNum; real_T staNum; real_T wayNum; real_T staBeg; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; emlrtHeapReferenceStackEnterFcnR2012b(&st); emxInit_real_T(&st, &engKinNumVec_wayInx, 1, true); emxInit_real_T(&st, &slpVec_wayInx, 1, true); b_emxInit_real_T(&st, &engKinMat_engKinInx_wayInx, 2, true); emxInitStruct_struct0_T(&st, &FZG, true); c_emxInit_real_T(&st, &optPreInxTn3, 3, true); c_emxInit_real_T(&st, &batFrcOptTn3, 3, true); c_emxInit_real_T(&st, &fulEngOptTn3, 3, true); b_emxInit_real_T(&st, &cos2goActMat, 2, true); prhs[15] = emlrtProtectR2012b(prhs[15], 15, false, -1); prhs[16] = emlrtProtectR2012b(prhs[16], 16, false, -1); prhs[17] = emlrtProtectR2012b(prhs[17], 17, false, -1); /* Marshall function inputs */ disFlg = emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "disFlg"); wayStp = emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "wayStp"); batEngStp = emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "batEngStp"); batEngBeg = emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "batEngBeg"); batPwrAux = emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "batPwrAux"); psiBatEng = emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "psiBatEng"); psiTim = emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "psiTim"); staChgPenCosVal = emlrt_marshallIn(&st, emlrtAliasP(prhs[7]), "staChgPenCosVal"); wayInxBeg = emlrt_marshallIn(&st, emlrtAliasP(prhs[8]), "wayInxBeg"); wayInxEnd = emlrt_marshallIn(&st, emlrtAliasP(prhs[9]), "wayInxEnd"); engKinBegInx = emlrt_marshallIn(&st, emlrtAliasP(prhs[10]), "engKinBegInx"); engKinNum = emlrt_marshallIn(&st, emlrtAliasP(prhs[11]), "engKinNum"); staNum = emlrt_marshallIn(&st, emlrtAliasP(prhs[12]), "staNum"); wayNum = emlrt_marshallIn(&st, emlrtAliasP(prhs[13]), "wayNum"); staBeg = emlrt_marshallIn(&st, emlrtAliasP(prhs[14]), "staBeg"); c_emlrt_marshallIn(&st, emlrtAlias(prhs[15]), "engKinNumVec_wayInx", engKinNumVec_wayInx); c_emlrt_marshallIn(&st, emlrtAlias(prhs[16]), "slpVec_wayInx", slpVec_wayInx); e_emlrt_marshallIn(&st, emlrtAlias(prhs[17]), "engKinMat_engKinInx_wayInx", engKinMat_engKinInx_wayInx); g_emlrt_marshallIn(&st, emlrtAliasP(prhs[18]), "FZG", &FZG); /* Invoke the target function */ clcDP_olyHyb_tmp(disFlg, wayStp, batEngStp, batEngBeg, batPwrAux, psiBatEng, psiTim, staChgPenCosVal, wayInxBeg, wayInxEnd, engKinBegInx, engKinNum, staNum, wayNum, staBeg, engKinNumVec_wayInx, slpVec_wayInx, engKinMat_engKinInx_wayInx, &FZG, optPreInxTn3, batFrcOptTn3, fulEngOptTn3, cos2goActMat); /* Marshall function outputs */ plhs[0] = emlrt_marshallOut(optPreInxTn3); plhs[1] = emlrt_marshallOut(batFrcOptTn3); plhs[2] = emlrt_marshallOut(fulEngOptTn3); plhs[3] = b_emlrt_marshallOut(cos2goActMat); cos2goActMat->canFreeData = false; emxFree_real_T(&cos2goActMat); fulEngOptTn3->canFreeData = false; emxFree_real_T(&fulEngOptTn3); batFrcOptTn3->canFreeData = false; emxFree_real_T(&batFrcOptTn3); optPreInxTn3->canFreeData = false; emxFree_real_T(&optPreInxTn3); emxFreeStruct_struct0_T(&FZG); engKinMat_engKinInx_wayInx->canFreeData = false; emxFree_real_T(&engKinMat_engKinInx_wayInx); slpVec_wayInx->canFreeData = false; emxFree_real_T(&slpVec_wayInx); engKinNumVec_wayInx->canFreeData = false; emxFree_real_T(&engKinNumVec_wayInx); emlrtHeapReferenceStackLeaveFcnR2012b(&st); }