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);
}
Beispiel #5
0
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);
}
Beispiel #12
0
/* 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;
}
Beispiel #13
0
/*
 * 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);
}
Beispiel #16
0
  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);
}
Beispiel #17
0
/* 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");
}
Beispiel #18
0
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);
}