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 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);
}
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);
}
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);
}
/*
* 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 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 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);
}
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 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 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 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);
}
/* 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;
}
static real_T e_fprintf(real_T varargin_1)
{
real_T nbytes;
const mxArray *y;
static const int32_T iv2[2] = { 1, 7 };
const mxArray *m1;
char_T cv4[7];
int32_T i;
static const char_T cv5[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
static const int32_T iv3[2] = { 1, 25 };
char_T cv6[25];
static const char_T cv7[25] = { 'B', 'E', 'R', ' ', 'f', 'o', 'r', ' ', 'p',
'r', 'e', 'a', 'm', 'b', 'l', 'e', ':', ' ', '%', '.', '1', '0', 'f', '\\',
'n' };
emlrtPushRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m1 = mxCreateCharArray(2, iv2);
for (i = 0; i < 7; i++) {
cv4[i] = cv5[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m1, cv4);
emlrtAssign(&y, m1);
b_y = NULL;
m1 = mxCreateCharArray(2, iv3);
for (i = 0; i < 25; i++) {
cv6[i] = cv7[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 25, m1, cv6);
emlrtAssign(&b_y, m1);
nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
emlrt_marshallOut(varargin_1), &emlrtMCI), "feval");
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
return nbytes;
}
/* Function Definitions */
static real_T c_fprintf(real_T varargin_1)
{
real_T nbytes;
const mxArray *y;
static const int32_T iv0[2] = { 1, 7 };
const mxArray *m0;
char_T cv0[7];
int32_T i;
static const char_T cv1[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
static const int32_T iv1[2] = { 1, 21 };
char_T cv2[21];
static const char_T cv3[21] = { 'B', 'E', 'R', ' ', 'f', 'o', 'r', ' ', 'd',
'a', 't', 'a', ':', ' ', '%', '.', '1', '0', 'f', '\\', 'n' };
emlrtPushRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m0 = mxCreateCharArray(2, iv0);
for (i = 0; i < 7; i++) {
cv0[i] = cv1[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m0, cv0);
emlrtAssign(&y, m0);
b_y = NULL;
m0 = mxCreateCharArray(2, iv1);
for (i = 0; i < 21; i++) {
cv2[i] = cv3[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m0, cv2);
emlrtAssign(&b_y, m0);
nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
emlrt_marshallOut(varargin_1), &emlrtMCI), "feval");
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
return nbytes;
}
/*
* 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 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);
}
/*
* Arguments : const mxArray *prhs[1]
* const mxArray *plhs[3]
* Return Type : void
*/
void quat2rpy_api(const mxArray *prhs[1], const mxArray *plhs[3])
{
double (*q)[4];
double roll;
double pitch;
double yaw;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
prhs[0] = emlrtProtectR2012b(prhs[0], 0, false, -1);
/* Marshall function inputs */
q = emlrt_marshallIn(&st, emlrtAlias(prhs[0]), "q");
/* Invoke the target function */
quat2rpy(*q, &yaw, &pitch, &roll);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(yaw);
plhs[1] = emlrt_marshallOut(pitch);
plhs[2] = emlrt_marshallOut(roll);
}
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));
}
/*
* 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);
}
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));
}
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);
}
static void info_helper(const mxArray **info)
{
const mxArray *rhs0 = NULL;
const mxArray *lhs0 = NULL;
const mxArray *rhs1 = NULL;
const mxArray *lhs1 = NULL;
emlrtAddField(*info, emlrt_marshallOut(
"[E]/Users/spnba/Dropbox (MIT)/MIT/uygar/code/variations under dev/get_unique_counts.m"),
"context", 0);
emlrtAddField(*info, emlrt_marshallOut("nnz"), "name", 0);
emlrtAddField(*info, emlrt_marshallOut("logical"), "dominantType", 0);
emlrtAddField(*info, emlrt_marshallOut(
"[ILXE]/Applications/MIT/MATLAB_R2015b.app/toolbox/eml/lib/matlab/sparfun/nnz.m"),
"resolved", 0);
emlrtAddField(*info, b_emlrt_marshallOut(1415929542U), "fileTimeLo", 0);
emlrtAddField(*info, b_emlrt_marshallOut(0U), "fileTimeHi", 0);
emlrtAddField(*info, b_emlrt_marshallOut(0U), "mFileTimeLo", 0);
emlrtAddField(*info, b_emlrt_marshallOut(0U), "mFileTimeHi", 0);
emlrtAssign(&rhs0, emlrtCreateCellMatrix(0, 1));
emlrtAssign(&lhs0, emlrtCreateCellMatrix(0, 1));
emlrtAddField(*info, emlrtAliasP(rhs0), "rhs", 0);
emlrtAddField(*info, emlrtAliasP(lhs0), "lhs", 0);
emlrtAddField(*info, emlrt_marshallOut(
"[ILXE]/Applications/MIT/MATLAB_R2015b.app/toolbox/eml/lib/matlab/sparfun/nnz.m!intnnz"),
"context", 1);
emlrtAddField(*info, emlrt_marshallOut("coder.internal.indexPlus"), "name", 1);
emlrtAddField(*info, emlrt_marshallOut("double"), "dominantType", 1);
emlrtAddField(*info, emlrt_marshallOut(
"[ILXE]/Applications/MIT/MATLAB_R2015b.app/toolbox/eml/eml/+coder/+internal/indexPlus.m"),
"resolved", 1);
emlrtAddField(*info, b_emlrt_marshallOut(1372604760U), "fileTimeLo", 1);
emlrtAddField(*info, b_emlrt_marshallOut(0U), "fileTimeHi", 1);
emlrtAddField(*info, b_emlrt_marshallOut(0U), "mFileTimeLo", 1);
emlrtAddField(*info, b_emlrt_marshallOut(0U), "mFileTimeHi", 1);
emlrtAssign(&rhs1, emlrtCreateCellMatrix(0, 1));
emlrtAssign(&lhs1, emlrtCreateCellMatrix(0, 1));
emlrtAddField(*info, emlrtAliasP(rhs1), "rhs", 1);
emlrtAddField(*info, emlrtAliasP(lhs1), "lhs", 1);
emlrtDestroyArray(&rhs0);
emlrtDestroyArray(&lhs0);
emlrtDestroyArray(&rhs1);
emlrtDestroyArray(&lhs1);
}
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);
}
/*
* 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);
}
/*
* 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, ¬es_gt, 2, true);
emxInit_real_T(&st, ¬es_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(¬es_tr);
notes_gt->canFreeData = false;
emxFree_real_T(¬es_gt);
emlrtHeapReferenceStackLeaveFcnR2012b(&st);
}
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);
}
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);
}
/*
* Arguments : const mxArray *prhs[9]
* const mxArray *plhs[2]
* Return Type : void
*/
void gp_RPSSVEP_api(const mxArray *prhs[9], const mxArray *plhs[2])
{
real_T (*GTargets)[3];
real_T yr;
real_T (*ys)[4096];
real_T (*f_interest)[6];
real_T (*canais)[4];
real_T win_type;
real_T overlap;
real_T NFFT;
real_T fs;
real_T class_type;
real_T idx;
emlrtStack st = { NULL, NULL, NULL };
st.tls = emlrtRootTLSGlobal;
GTargets = (real_T (*)[3])mxMalloc(sizeof(real_T [3]));
prhs[1] = emlrtProtectR2012b(prhs[1], 1, false, -1);
prhs[2] = emlrtProtectR2012b(prhs[2], 2, false, -1);
prhs[3] = emlrtProtectR2012b(prhs[3], 3, false, -1);
/* Marshall function inputs */
yr = emlrt_marshallIn(&st, emlrtAliasP(prhs[0]), "yr");
ys = c_emlrt_marshallIn(&st, emlrtAlias(prhs[1]), "ys");
f_interest = e_emlrt_marshallIn(&st, emlrtAlias(prhs[2]), "f_interest");
canais = g_emlrt_marshallIn(&st, emlrtAlias(prhs[3]), "canais");
win_type = emlrt_marshallIn(&st, emlrtAliasP(prhs[4]), "win_type");
overlap = emlrt_marshallIn(&st, emlrtAliasP(prhs[5]), "overlap");
NFFT = emlrt_marshallIn(&st, emlrtAliasP(prhs[6]), "NFFT");
fs = emlrt_marshallIn(&st, emlrtAliasP(prhs[7]), "fs");
class_type = emlrt_marshallIn(&st, emlrtAliasP(prhs[8]), "class_type");
/* Invoke the target function */
gp_RPSSVEP(yr, *ys, *f_interest, *canais, win_type, overlap, NFFT, fs,
class_type, *GTargets, &idx);
/* Marshall function outputs */
plhs[0] = emlrt_marshallOut(*GTargets);
plhs[1] = b_emlrt_marshallOut(idx);
}
/*
* Arguments : const mxArray *prhs[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)[6];
real_T (*m0)[2];
real_T (*P_kk_kk)[25];
real_T (*Q)[25];
real_T (*R)[16];
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 = 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(*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);
}