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 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 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 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); }
/* 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; }
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 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); }
/* * 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); }
/* * 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); }
/* Function Definitions */ static void b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const emlrtMsgIdentifier *parentId, creal_T y[1408]) { g_emlrt_marshallIn(sp, emlrtAlias(u), parentId, y); emlrtDestroyArray(&u); }
/* * 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); }
/* Function Definitions */ static void b_emlrt_marshallIn(const mxArray *u, const emlrtMsgIdentifier *parentId, emxArray_creal_T *y) { g_emlrt_marshallIn(emlrtAlias(u), parentId, y); emlrtDestroyArray(&u); }
/* Function Definitions */ static void b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const emlrtMsgIdentifier *parentId, emxArray_uint8_T *y) { g_emlrt_marshallIn(sp, emlrtAlias(u), parentId, y); emlrtDestroyArray(&u); }