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 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 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_bga_api(const mxArray *prhs[1], const mxArray *plhs[1]) { real_T (*ft)[7]; emxArray_real_T *gait; emlrtStack st = { NULL, NULL, NULL }; st.tls = emlrtRootTLSGlobal; ft = (real_T (*)[7])mxMalloc(sizeof(real_T [7])); emlrtHeapReferenceStackEnterFcnR2012b(&st); b_emxInit_real_T(&st, &gait, 2, true); prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1); /* Marshall function inputs */ c_emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "gait", gait); /* Invoke the target function */ features_bga(gait, *ft); /* Marshall function outputs */ plhs[0] = d_emlrt_marshallOut(*ft); gait->canFreeData = false; emxFree_real_T(&gait); emlrtHeapReferenceStackLeaveFcnR2012b(&st); }
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); }