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, ®Term, 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(®Term);
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);
}
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);
}
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");
}
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);
}
/*
* 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;
}
/* 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;
}
/* 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, ¬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);
}
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");
}
/*
* 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 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);
}
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);
}
/*
* 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);
}
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");
}
