Esempi in C++ (Cpp) per emlrt_marshallIn

Esempio n. 1

File: _coder_get_coherence_api.c Progetto: ZijingMao/MatlabIntegretMulApp

/*
 * 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);
}

Esempio n. 2

File: _coder_SpringForce_api.c Progetto: ofirENS/Utils

/*
 * 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);
}

Esempio n. 3

void util_sub_jaccard_index_api(const mxArray * const prhs[2], const mxArray
  *plhs[1])
{
  real_T a;
  real_T b;

  /* Marshall function inputs */
  a = emlrt_marshallIn(emlrtAliasP(prhs[0]), "a");
  b = emlrt_marshallIn(emlrtAliasP(prhs[1]), "b");

  /* Invoke the target function */
  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(util_sub_jaccard_index(a, b));
}

Esempio n. 4

File: _coder_bridge_ufb_api.c Progetto: Erin-Mounts/PDScores

void vadsplitphon_api(const mxArray *prhs[1], const mxArray *plhs[2])
{
  emxArray_real_T *x;
  int32_T i_size[2];
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  mxMalloc(0U);
  mxMalloc(0U);
  emlrtHeapReferenceStackEnterFcnR2012b(&st);
  emxInit_real_T(&st, &x, 1, true);
  prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);

  /* Marshall function inputs */
  emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x", x);

  /* Invoke the target function */
  vadsplitphon(x, i_size);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut();
  plhs[1] = i_emlrt_marshallOut(i_size);
  x->canFreeData = false;
  emxFree_real_T(&x);
  emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}

Esempio n. 5

File: _coder_bridge_ufb_api.c Progetto: Erin-Mounts/PDScores

void mfcc_api(const mxArray *prhs[1], const mxArray *plhs[1])
{
  emxArray_real_T *samples;
  emxArray_real_T *cepstra;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  emlrtHeapReferenceStackEnterFcnR2012b(&st);
  emxInit_real_T(&st, &samples, 1, true);
  b_emxInit_real_T(&st, &cepstra, 2, true);
  prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);

  /* Marshall function inputs */
  emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "samples", samples);

  /* Invoke the target function */
  mfcc(samples, cepstra);

  /* Marshall function outputs */
  plhs[0] = h_emlrt_marshallOut(cepstra);
  cepstra->canFreeData = false;
  emxFree_real_T(&cepstra);
  samples->canFreeData = false;
  emxFree_real_T(&samples);
  emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}

Esempio n. 6

File: _coder_bridge_ufb_api.c Progetto: Erin-Mounts/PDScores

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);
}

Esempio n. 7

File: _coder_bridge_ufb_api.c Progetto: Erin-Mounts/PDScores

void extractaudiophon_api(const mxArray *prhs[1], const mxArray *plhs[2])
{
  emxArray_real_T *rawaudio;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  mxMalloc(0U);
  mxMalloc(0U);
  emlrtHeapReferenceStackEnterFcnR2012b(&st);
  emxInit_real_T(&st, &rawaudio, 1, true);
  prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);

  /* Marshall function inputs */
  emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "rawaudio", rawaudio);

  /* Invoke the target function */
  extractaudiophon(rawaudio);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut();
  plhs[1] = emlrt_marshallOut();
  rawaudio->canFreeData = false;
  emxFree_real_T(&rawaudio);
  emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}

Esempio n. 8

File: _coder_G_api.cpp Progetto: canlab/Lindquist_Dynamic_Correlation

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);
}

Esempio n. 9

File: _coder_makeHistFutTablewithRearrange_api.cpp Progetto: mcenek/BehavioralSpacesFramework

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);
}

Esempio n. 10

File: nsht_legmat_api.c Progetto: AliceB/dMRI_Antipodal_Sampling_Schemes

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);
}

Esempio n. 11

File: _coder_dummy_api.c Progetto: bsaund/SnakePlanning

void dummy_api(const mxArray * const prhs[2], const mxArray *plhs[1])
{
  real_T a;
  real_T b;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;

  /* Marshall function inputs */
  a = emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "a");
  b = emlrt_marshallIn(&st, emlrtAliasP(prhs[1]), "b");

  /* Invoke the target function */
  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(dummy(a, b));
}

Esempio n. 12

File: _coder_JenkinsCompare_api.c Progetto: VoiceOvers/JenkinsDetect

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);
}

Esempio n. 13

File: julia_v4_1_api.c Progetto: ParkedTom/HPC-2014

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);
}

Esempio n. 14

File: BERCalculationSIMO_api.c Progetto: npanti/pdd_horlin_ma2

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);
}

Esempio n. 15

File: _coder_transceive102_api.c Progetto: genesys80211b/DTx_visual

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);
}

Esempio n. 16

File: _coder_bridge_ufb_api.c Progetto: Erin-Mounts/PDScores

void fastdfa_api(const mxArray *prhs[1], const mxArray *plhs[3])
{
  emxArray_real_T *x;
  emxArray_real_T *intervals;
  emxArray_real_T *flucts;
  real_T alpha;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;
  emlrtHeapReferenceStackEnterFcnR2012b(&st);
  emxInit_real_T(&st, &x, 1, true);
  emxInit_real_T(&st, &intervals, 1, true);
  emxInit_real_T(&st, &flucts, 1, true);
  prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);

  /* Marshall function inputs */
  emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x", x);

  /* Invoke the target function */
  fastdfa(x, &alpha, intervals, flucts);

  /* Marshall function outputs */
  plhs[0] = b_emlrt_marshallOut(alpha);
  plhs[1] = c_emlrt_marshallOut(intervals);
  plhs[2] = c_emlrt_marshallOut(flucts);
  flucts->canFreeData = false;
  emxFree_real_T(&flucts);
  intervals->canFreeData = false;
  emxFree_real_T(&intervals);
  x->canFreeData = false;
  emxFree_real_T(&x);
  emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}

Esempio n. 17

File: BWbetaNloop_api.c Progetto: ganguli-lab/Complex_Synapse

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);
}

Esempio n. 18

File: _coder_bridge_ufb_api.c Progetto: Erin-Mounts/PDScores

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);
}

Esempio n. 19

File: _coder_classifyNotes_api.c Progetto: lingxiaoyang/singing-transcription-GA-HMM

/*
 * 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);
}

Esempio n. 20

void util_sub_normalized_dot_product_api(const mxArray * const prhs[2], const
  mxArray *plhs[1])
{
  int32_T a_size[1];
  real_T a_data[100];
  int32_T b_size[1];
  real_T b_data[100];
  real_T result;

  /* Marshall function inputs */
  emlrt_marshallIn(emlrtAliasP(prhs[0]), "a", a_data, a_size);
  emlrt_marshallIn(emlrtAliasP(prhs[1]), "b", b_data, b_size);

  /* Invoke the target function */
  result = util_sub_normalized_dot_product(a_data, a_size, b_data, b_size);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(result);
}

Esempio n. 21

File: lg1_api.c Progetto: Sable/mclab-www

void lg1_api(const mxArray * const prhs[1])
{
  real_T scale;

  /* Marshall function inputs */
  scale = emlrt_marshallIn(emlrtAliasP(prhs[0]), "scale");

  /* Invoke the target function */
  lg1(scale);
}

Esempio n. 22

File: _coder_lambert_api.c Progetto: Arrowstar/ksptot

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);
}

Esempio n. 23

File: _coder_ekf_update_api.c Progetto: eryeden/CG-Estimator

/*
 * Arguments    : const mxArray *prhs[7]
 *                const mxArray *plhs[2]
 * Return Type  : void
 */
void ekf_update_api(const mxArray *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]));
  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);
  prhs[5] = emlrtProtectR2012b(prhs[5], 5, false, -1);

  /* Marshall function inputs */
  x_kk_kk = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x_kk_kk");
  zm_k = emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "zm_k");
  m0 = c_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "m0");
  P_kk_kk = e_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "P_kk_kk");
  Q = e_emlrt_marshallIn(&st, emlrtAlias(prhs[4]), "Q");
  R = g_emlrt_marshallIn(&st, emlrtAlias(prhs[5]), "R");
  dt = i_emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "dt");

  /* Invoke the target function */
  ekf_update(*x_kk_kk, *zm_k, *m0, *P_kk_kk, *Q, *R, dt, *x_k_k, *P_k_k);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(*x_k_k);
  plhs[1] = b_emlrt_marshallOut(*P_k_k);
}

Esempio n. 24

File: _coder_bridge_ufb_api.c Progetto: Erin-Mounts/PDScores

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);
}

Esempio n. 25

File: _coder_bridge_ufb_api.c Progetto: Erin-Mounts/PDScores

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);
}

Esempio n. 26

File: _coder_test_api.c Progetto: michille78/program_xyz

/*
 * Arguments    : const mxArray * const prhs[1]
 *                const mxArray *plhs[1]
 * Return Type  : void
 */
void test_api(const mxArray * const prhs[1], const mxArray *plhs[1])
{
  double b;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;

  /* Marshall function inputs */
  b = emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "b");

  /* Invoke the target function */
  b = test(b);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(b);
}

Esempio n. 27

File: _coder_cic_fixpt_api.c Progetto: AliZeineddine93/CIC_Filter_Study

void cic_fixpt_api(const mxArray * const prhs[1], const mxArray *plhs[1])
{
  int16_T x;
  int64_T y;
  emlrtStack st = { NULL, NULL, NULL };

  st.tls = emlrtRootTLSGlobal;

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

  /* Invoke the target function */
  y = cic_fixpt(&st, x);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(&st, y);
}

Esempio n. 28

File: _coder_PPB_ann_api.c Progetto: MengyuanZhu/PPB

void PPB_ann_api(const mxArray *prhs[1], const mxArray *plhs[1])
{
  real_T (*x1)[16];
  real_T b_y1;
  emlrtStack st = { NULL, NULL, NULL };

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

  /* Marshall function inputs */
  x1 = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "x1");

  /* Invoke the target function */
  b_y1 = PPB_ann(*x1);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(b_y1);
}

Esempio n. 29

File: _coder_digit_nn_predict_api.c Progetto: Kd-bT/Digit-Recognition-App

/*
 * Arguments    : const mxArray *prhs[1]
 *                const mxArray *plhs[1]
 * Return Type  : void
 */
void digit_nn_predict_api(const mxArray *prhs[1], const mxArray *plhs[1])
{
  real_T (*X)[784];
  real_T p;
  emlrtStack st = { NULL, NULL, NULL };

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

  /* Marshall function inputs */
  X = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "X");

  /* Invoke the target function */
  p = digit_nn_predict(*X);

  /* Marshall function outputs */
  plhs[0] = emlrt_marshallOut(p);
}

Esempio n. 30

File: fprintf.c Progetto: kingdwd/Summer2014

/* Function Definitions */
static real_T c_fprintf(real_T varargin_1)
{
  real_T nbytes;
  const mxArray *y;
  static const int32_T iv46[2] = { 1, 7 };

  const mxArray *m6;
  char_T cv22[7];
  int32_T i;
  static const char_T cv23[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };

  const mxArray *b_y;
  static const int32_T iv47[2] = { 1, 48 };

  char_T cv24[48];
  static const char_T cv25[48] = { 'E', 'r', 'r', 'o', 'r', ':', ' ', 'm', 'a',
    't', 'r', 'i', 'x', ' ', 's', 'q', 'u', 'a', 'r', 'e', ' ', 'r', 'o', 'o',
    't', ' ', 'r', 'e', 's', 'i', 'd', 'u', 'a', 'l', ' ', 'n', 'o', 'r', 'm',
    ' ', 'i', 's', ' ', '%', 'g', '.', '\\', 'n' };

  emlrtPushRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
  emlrt_synchGlobalsToML();
  y = NULL;
  m6 = mxCreateCharArray(2, iv46);
  for (i = 0; i < 7; i++) {
    cv22[i] = cv23[i];
  }

  emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m6, cv22);
  emlrtAssign(&y, m6);
  b_y = NULL;
  m6 = mxCreateCharArray(2, iv47);
  for (i = 0; i < 48; i++) {
    cv24[i] = cv25[i];
  }

  emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 48, m6, cv24);
  emlrtAssign(&b_y, m6);
  nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
    emlrt_marshallOut(varargin_1), &p_emlrtMCI), "feval");
  emlrt_synchGlobalsFromML();
  emlrtPopRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
  return nbytes;
}