void Bcoeff_api(const mxArray * const prhs[5], const mxArray *plhs[1])
{
  emxArray_real_T *timePoints;
  real_T ksi;
  real_T j;
  real_T x;
  real_T t;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  emlrtHeapReferenceStackEnterFcnR2012b(&st);
  emxInit_real_T(&st, &timePoints, 2, &ub_emlrtRTEI, true);

  /* Marshall function inputs */
  ksi = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "ksi");
  j = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "j");
  x = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "x");
  t = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "t");
  e_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "timePoints", timePoints);

  /* Invoke the target function */
  ksi = Bcoeff(&st, ksi, j, x, t, timePoints);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(ksi);
  timePoints->canFreeData = false;
  emxFree_real_T(&timePoints);
  emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void 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 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 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 GetRegularizationTerm_api(const mxArray * const prhs[2], const mxArray
  *plhs[1])
{
  emxArray_real_T *regTerm;
  real_T N;
  real_T order;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  emlrtHeapReferenceStackEnterFcnR2012b(&st);
  emxInit_real_T(&st, &regTerm, 2, &ub_emlrtRTEI, true);

  /* Marshall function inputs */
  N = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "N");
  order = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "order");

  /* Invoke the target function */
  GetRegularizationTerm(&st, N, order, regTerm);

  /* Marshall function outputs */
  plhs[0] = e_emlrt_marshallOut(regTerm);
  regTerm->canFreeData = false;
  emxFree_real_T(&regTerm);
  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 nsht_legmat_api(const mxArray * const prhs[3], const mxArray *plhs[2])
{
  emxArray_real_T *thetas;
  emxArray_real_T *P;
  emxArray_real_T *Sc;
  real_T L;
  real_T m;
  emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
  emxInit_real_T(&thetas, 2, &b_emlrtRTEI, TRUE);
  emxInit_real_T(&P, 2, &b_emlrtRTEI, TRUE);
  emxInit_real_T(&Sc, 2, &b_emlrtRTEI, TRUE);

  /* Marshall function inputs */
  emlrt_marshallIn(emlrtAlias(prhs[0]), "thetas", thetas);
  L = c_emlrt_marshallIn(emlrtAliasP(prhs[1]), "L");
  m = c_emlrt_marshallIn(emlrtAliasP(prhs[2]), "m");

  /* Invoke the target function */
  nsht_legmat(thetas, L, m, P, Sc);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(P);
  plhs[1] = emlrt_marshallOut(Sc);
  Sc->canFreeData = FALSE;
  emxFree_real_T(&Sc);
  P->canFreeData = FALSE;
  emxFree_real_T(&P);
  thetas->canFreeData = FALSE;
  emxFree_real_T(&thetas);
  emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
void 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 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);
}
Example #10
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);
}
Example #11
0
static real_T m_fprintf(const emlrtStack *sp, const char_T varargin_1_data[77],
  const int32_T varargin_1_size[2])
{
  const mxArray *y;
  static const int32_T iv136[2] = { 1, 7 };

  const mxArray *m32;
  char_T cv168[7];
  int32_T i;
  static const char_T cv169[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  const mxArray *c_y;
  static const int32_T iv137[2] = { 1, 22 };

  char_T cv170[22];
  static const char_T cv171[22] = { 'M', 'A', 'C', '|', ' ', 'G', 'o', 't', ' ',
    'm', 'e', 's', 's', 'a', 'g', 'e', ':', ' ', '%', 's', '\\', 'n' };

  int32_T u_size[2];
  int32_T i29;
  char_T u_data[77];
  const mxArray *d_y;
  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  y = NULL;
  m32 = mxCreateCharArray(2, iv136);
  for (i = 0; i < 7; i++) {
    cv168[i] = cv169[i];
  }

  emlrtInitCharArrayR2013a(sp, 7, m32, cv168);
  emlrtAssign(&y, m32);
  b_y = NULL;
  m32 = mxCreateDoubleScalar(1.0);
  emlrtAssign(&b_y, m32);
  c_y = NULL;
  m32 = mxCreateCharArray(2, iv137);
  for (i = 0; i < 22; i++) {
    cv170[i] = cv171[i];
  }

  emlrtInitCharArrayR2013a(sp, 22, m32, cv170);
  emlrtAssign(&c_y, m32);
  u_size[0] = 1;
  u_size[1] = varargin_1_size[1];
  i = varargin_1_size[0] * varargin_1_size[1];
  for (i29 = 0; i29 < i; i29++) {
    u_data[i29] = varargin_1_data[i29];
  }

  d_y = NULL;
  m32 = mxCreateCharArray(2, u_size);
  emlrtInitCharArrayR2013a(sp, u_size[1], m32, (char_T *)&u_data);
  emlrtAssign(&d_y, m32);
  st.site = &ew_emlrtRSI;
  return c_emlrt_marshallIn(&st, b_feval(&st, y, b_y, c_y, d_y, &n_emlrtMCI),
    "feval");
}
Example #12
0
static real_T k_fprintf(const emlrtStack *sp, const char_T varargin_1_data[76],
  const int32_T varargin_1_size[2])
{
  const mxArray *y;
  static const int32_T iv134[2] = { 1, 7 };

  const mxArray *m31;
  char_T cv164[7];
  int32_T i;
  static const char_T cv165[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  const mxArray *c_y;
  static const int32_T iv135[2] = { 1, 18 };

  char_T cv166[18];
  static const char_T cv167[18] = { 'D', 'L', '|', ' ', 'M', 'e', 's', 's', 'a',
    'g', 'e', '=', '|', '%', 's', '|', '\\', 'n' };

  int32_T u_size[2];
  int32_T i28;
  char_T u_data[76];
  const mxArray *d_y;
  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  y = NULL;
  m31 = mxCreateCharArray(2, iv134);
  for (i = 0; i < 7; i++) {
    cv164[i] = cv165[i];
  }

  emlrtInitCharArrayR2013a(sp, 7, m31, cv164);
  emlrtAssign(&y, m31);
  b_y = NULL;
  m31 = mxCreateDoubleScalar(1.0);
  emlrtAssign(&b_y, m31);
  c_y = NULL;
  m31 = mxCreateCharArray(2, iv135);
  for (i = 0; i < 18; i++) {
    cv166[i] = cv167[i];
  }

  emlrtInitCharArrayR2013a(sp, 18, m31, cv166);
  emlrtAssign(&c_y, m31);
  u_size[0] = 1;
  u_size[1] = varargin_1_size[1];
  i = varargin_1_size[0] * varargin_1_size[1];
  for (i28 = 0; i28 < i; i28++) {
    u_data[i28] = varargin_1_data[i28];
  }

  d_y = NULL;
  m31 = mxCreateCharArray(2, u_size);
  emlrtInitCharArrayR2013a(sp, u_size[1], m31, (char_T *)&u_data);
  emlrtAssign(&d_y, m31);
  st.site = &ew_emlrtRSI;
  return c_emlrt_marshallIn(&st, b_feval(&st, y, b_y, c_y, d_y, &n_emlrtMCI),
    "feval");
}
void JenkinsCompare_api(JenkinsCompareStackData *SD, const mxArray * const prhs
  [2], const mxArray *plhs[1])
{
  emxArray_real_T *y;
  real_T (*x)[78596];
  real_T sampleRate;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  emlrtHeapReferenceStackEnterFcnR2012b(&st);
  emxInit_real_T(&st, &y, 2, &gb_emlrtRTEI, true);

  /* Marshall function inputs */
  x = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x");
  sampleRate = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "sampleRate");

  /* Invoke the target function */
  JenkinsCompare(SD, &st, *x, sampleRate, y);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(y);
  y->canFreeData = false;
  emxFree_real_T(&y);
  emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
void 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);
}
/*
 * Arguments    : const mxArray *prhs[3]
 *                const mxArray *plhs[2]
 * Return Type  : void
 */
void get_coherence_api(const mxArray *prhs[3], const mxArray *plhs[2])
{
  real_T (*mscxy)[513];
  real_T (*frequency_list)[513];
  real_T (*x)[768];
  real_T (*y)[768];
  real_T fs;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  mscxy = (real_T (*)[513])mxMalloc(sizeof(real_T [513]));
  frequency_list = (real_T (*)[513])mxMalloc(sizeof(real_T [513]));
  prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
  prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);

  /* Marshall function inputs */
  x = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x");
  y = emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "y");
  fs = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "fs");

  /* Invoke the target function */
  get_coherence(*x, *y, fs, *mscxy, *frequency_list);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(*mscxy);
  plhs[1] = b_emlrt_marshallOut(*frequency_list);
}
void BWbetaNloop_api(const mxArray *prhs[2], const mxArray *plhs[1])
{
  emxArray_real_T *beta;
  emxArray_real_T *updater;
  emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
  emxInit_real_T(&beta, 2, TRUE);
  b_emxInit_real_T(&updater, 3, TRUE);
  prhs[0] = emlrtProtectR2012b(prhs[0], 0, TRUE, -1);

  /* Marshall function inputs */
  emlrt_marshallIn(emlrtAlias(prhs[0]), "beta", beta);
  c_emlrt_marshallIn(emlrtAlias(prhs[1]), "updater", updater);

  /* Invoke the target function */
  BWbetaNloop(beta, updater);

  /* Marshall function outputs */
  emlrt_marshallOut(beta, prhs[0]);
  plhs[0] = prhs[0];
  updater->canFreeData = FALSE;
  emxFree_real_T(&updater);
  beta->canFreeData = FALSE;
  emxFree_real_T(&beta);
  emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
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);
}
Example #18
0
/*
 * Arguments    : const emlrtStack *sp
 *                const mxArray *u
 *                const emlrtMsgIdentifier *parentId
 * Return Type  : double
 */
static double b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  emlrtMsgIdentifier *parentId)
{
  double y;
  y = c_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
  emlrtDestroyArray(&u);
  return y;
}
Example #19
0
/* Function Definitions */
static real_T (*b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  emlrtMsgIdentifier *parentId))[16]
{
  real_T (*y)[16];
  y = c_emlrt_marshallIn(sp, emlrtAlias(u), parentId);
  emlrtDestroyArray(&u);
  return y;
}
Example #20
0
/* Function Definitions */
static real_T b_emlrt_marshallIn(const mxArray *u, const emlrtMsgIdentifier
  *parentId)
{
  real_T y;
  y = c_emlrt_marshallIn(emlrtAlias(u), parentId);
  emlrtDestroyArray(&u);
  return y;
}
/* Function Definitions */
static int16_T b_emlrt_marshallIn(const emlrtStack *sp, const mxArray *u, const
  emlrtMsgIdentifier *parentId)
{
  int16_T y;
  emlrtCheckFiR2012b(sp, parentId, u, false, 0U, 0, eml_mx, b_eml_mx);
  y = c_emlrt_marshallIn(emlrtAlias(u));
  emlrtDestroyArray(&u);
  return y;
}
/*
 * Arguments    : const mxArray *prhs[7]
 *                const mxArray *plhs[1]
 * Return Type  : void
 */
void classifyNotes_api(const mxArray *prhs[7], const mxArray *plhs[1])
{
  emxArray_real_T *notes_gt;
  emxArray_real_T *notes_tr;
  struct0_T Results;
  real_T onset_lim;
  real_T dur_percent_range;
  real_T min_dur_dist;
  real_T f0_range_in_cents;
  real_T hopsize;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  emlrtHeapReferenceStackEnterFcnR2012b(&st);
  emxInit_real_T(&st, &notes_gt, 2, true);
  emxInit_real_T(&st, &notes_tr, 2, true);
  emxInitStruct_struct0_T(&st, &Results, 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]), "notes_gt", notes_gt);
  emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "notes_tr", notes_tr);
  onset_lim = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "onset_lim");
  dur_percent_range = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]),
    "dur_percent_range");
  min_dur_dist = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "min_dur_dist");
  f0_range_in_cents = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[5]),
    "f0_range_in_cents");
  hopsize = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "hopsize");

  /* Invoke the target function */
  classifyNotes(notes_gt, notes_tr, onset_lim, dur_percent_range, min_dur_dist,
                f0_range_in_cents, hopsize, &Results);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(&Results);
  emxFreeStruct_struct0_T(&Results);
  notes_tr->canFreeData = false;
  emxFree_real_T(&notes_tr);
  notes_gt->canFreeData = false;
  emxFree_real_T(&notes_gt);
  emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
Example #23
0
static real_T s_fprintf(const emlrtStack *sp, int16_T varargin_1, real_T
  varargin_2)
{
  const mxArray *y;
  static const int32_T iv142[2] = { 1, 7 };

  const mxArray *m35;
  char_T cv180[7];
  int32_T i;
  static const char_T cv181[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  const mxArray *c_y;
  static const int32_T iv143[2] = { 1, 43 };

  char_T cv182[43];
  static const char_T cv183[43] = { 'T', 'r', 'a', 'n', 's', 'm', 'i', 't', 't',
    'i', 'n', 'g', ' ', 't', 'o', ' ', 'n', 'o', 'd', 'e', ':', ' ', '%', 'd',
    ',', ' ', 'w', 'i', 't', 'h', ' ', 'o', 'f', 'f', 's', 'e', 't', ':', ' ',
    '%', 'f', '\\', 'n' };

  const mxArray *d_y;
  const mxArray *e_y;
  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  y = NULL;
  m35 = mxCreateCharArray(2, iv142);
  for (i = 0; i < 7; i++) {
    cv180[i] = cv181[i];
  }

  emlrtInitCharArrayR2013a(sp, 7, m35, cv180);
  emlrtAssign(&y, m35);
  b_y = NULL;
  m35 = mxCreateDoubleScalar(1.0);
  emlrtAssign(&b_y, m35);
  c_y = NULL;
  m35 = mxCreateCharArray(2, iv143);
  for (i = 0; i < 43; i++) {
    cv182[i] = cv183[i];
  }

  emlrtInitCharArrayR2013a(sp, 43, m35, cv182);
  emlrtAssign(&c_y, m35);
  d_y = NULL;
  m35 = mxCreateNumericMatrix(1, 1, mxINT16_CLASS, mxREAL);
  *(int16_T *)mxGetData(m35) = varargin_1;
  emlrtAssign(&d_y, m35);
  e_y = NULL;
  m35 = mxCreateDoubleScalar(varargin_2);
  emlrtAssign(&e_y, m35);
  st.site = &ew_emlrtRSI;
  return c_emlrt_marshallIn(&st, c_feval(&st, y, b_y, c_y, d_y, e_y, &n_emlrtMCI),
    "feval");
}
Example #24
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);
}
Example #26
0
void lambert_api(const mxArray *prhs[5], const mxArray *plhs[4])
{
  real_T (*V1)[3];
  real_T (*V2)[3];
  real_T (*extremal_distances)[2];
  real_T (*r1vec)[3];
  real_T (*r2vec)[3];
  real_T tf;
  real_T m;
  real_T muC;
  real_T exitflag;
  emlrtStack st = { NULL,              /* site */
    NULL,                              /* tls */
    NULL                               /* prev */
  };

  st.tls = emlrtRootTLSGlobal;
  V1 = (real_T (*)[3])mxMalloc(sizeof(real_T [3]));
  V2 = (real_T (*)[3])mxMalloc(sizeof(real_T [3]));
  extremal_distances = (real_T (*)[2])mxMalloc(sizeof(real_T [2]));
  prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
  prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);

  /* Marshall function inputs */
  r1vec = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "r1vec");
  r2vec = emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "r2vec");
  tf = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "tf");
  m = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[3]), "m");
  muC = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "muC");

  /* Invoke the target function */
  lambert(&st, *r1vec, *r2vec, tf, m, muC, *V1, *V2, *extremal_distances,
          &exitflag);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(*V1);
  plhs[1] = emlrt_marshallOut(*V2);
  plhs[2] = b_emlrt_marshallOut(*extremal_distances);
  plhs[3] = c_emlrt_marshallOut(exitflag);
}
Example #27
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);
}
Example #28
0
/*
 * Arguments    : const mxArray *prhs[3]
 *                const mxArray *plhs[1]
 * Return Type  : void
 */
void Csetminmax_api(const mxArray *prhs[3], const mxArray *plhs[1])
{
  real_T (*value)[1302];
  real_T lowlim;
  real_T uplim;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  prhs[0] = emlrtProtectR2012b(prhs[0], 0, true, -1);

  /* Marshall function inputs */
  value = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "value");
  lowlim = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "lowlim");
  uplim = c_emlrt_marshallIn(&st, emlrtAliasP(prhs[2]), "uplim");

  /* Invoke the target function */
  Csetminmax(*value, lowlim, uplim);

  /* Marshall function outputs */
  emlrt_marshallOut(*value, prhs[0]);
  plhs[0] = prhs[0];
}
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);
}
Example #30
0
static real_T o_fprintf(const emlrtStack *sp, int16_T varargin_1)
{
  const mxArray *y;
  static const int32_T iv138[2] = { 1, 7 };

  const mxArray *m33;
  char_T cv172[7];
  int32_T i;
  static const char_T cv173[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  const mxArray *c_y;
  static const int32_T iv139[2] = { 1, 20 };

  char_T cv174[20];
  static const char_T cv175[20] = { 'M', 'A', 'C', '|', ' ', 'F', 'r', 'o', 'm',
    ' ', 'N', 'o', 'd', 'e', ':', ' ', '%', 'd', '\\', 'n' };

  const mxArray *d_y;
  emlrtStack st;
  st.prev = sp;
  st.tls = sp->tls;
  y = NULL;
  m33 = mxCreateCharArray(2, iv138);
  for (i = 0; i < 7; i++) {
    cv172[i] = cv173[i];
  }

  emlrtInitCharArrayR2013a(sp, 7, m33, cv172);
  emlrtAssign(&y, m33);
  b_y = NULL;
  m33 = mxCreateDoubleScalar(1.0);
  emlrtAssign(&b_y, m33);
  c_y = NULL;
  m33 = mxCreateCharArray(2, iv139);
  for (i = 0; i < 20; i++) {
    cv174[i] = cv175[i];
  }

  emlrtInitCharArrayR2013a(sp, 20, m33, cv174);
  emlrtAssign(&c_y, m33);
  d_y = NULL;
  m33 = mxCreateNumericMatrix(1, 1, mxINT16_CLASS, mxREAL);
  *(int16_T *)mxGetData(m33) = varargin_1;
  emlrtAssign(&d_y, m33);
  st.site = &ew_emlrtRSI;
  return c_emlrt_marshallIn(&st, b_feval(&st, y, b_y, c_y, d_y, &n_emlrtMCI),
    "feval");
}