void warning(const emlrtStack *sp)
{
int32_T i1;
static const char_T cv1[7] = { 'w', 'a', 'r', 'n', 'i', 'n', 'g' };
char_T u[7];
const mxArray *y;
static const int32_T iv0[2] = { 1, 7 };
const mxArray *m0;
static const char_T cv2[7] = { 'm', 'e', 's', 's', 'a', 'g', 'e' };
char_T b_u[7];
const mxArray *b_y;
static const int32_T iv1[2] = { 1, 7 };
static const char_T msgID[43] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R', 'u',
'T', 'r', 'a', 'n', 's', 'm', 'i', 't', 't', 'e', 'r', ':', 'O', 'u', 't',
'O', 'f', 'R', 'a', 'n', 'g', 'e', 'I', 'n', 't', 'e', 'r', 'p', 'F', 'a',
'c', 't', 'o', 'r' };
char_T c_u[43];
const mxArray *c_y;
static const int32_T iv2[2] = { 1, 43 };
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
for (i1 = 0; i1 < 7; i1++) {
u[i1] = cv1[i1];
}
y = NULL;
m0 = emlrtCreateCharArray(2, iv0);
emlrtInitCharArrayR2013a(sp, 7, m0, &u[0]);
emlrtAssign(&y, m0);
for (i1 = 0; i1 < 7; i1++) {
b_u[i1] = cv2[i1];
}
b_y = NULL;
m0 = emlrtCreateCharArray(2, iv1);
emlrtInitCharArrayR2013a(sp, 7, m0, &b_u[0]);
emlrtAssign(&b_y, m0);
for (i1 = 0; i1 < 43; i1++) {
c_u[i1] = msgID[i1];
}
c_y = NULL;
m0 = emlrtCreateCharArray(2, iv2);
emlrtInitCharArrayR2013a(sp, 43, m0, &c_u[0]);
emlrtAssign(&c_y, m0);
st.site = &fb_emlrtRSI;
b_feval(&st, y, feval(&st, b_y, c_y, &emlrtMCI), &b_emlrtMCI);
}
void b_warning(const emlrtStack *sp)
{
int32_T i11;
static const char_T cv7[7] = { 'w', 'a', 'r', 'n', 'i', 'n', 'g' };
char_T u[7];
const mxArray *y;
static const int32_T iv5[2] = { 1, 7 };
const mxArray *m1;
static const char_T cv8[7] = { 'm', 'e', 's', 's', 'a', 'g', 'e' };
char_T b_u[7];
const mxArray *b_y;
static const int32_T iv6[2] = { 1, 7 };
static const char_T msgID[39] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R', 'u',
'R', 'e', 'c', 'e', 'i', 'v', 'e', 'r', ':', 'O', 'u', 't', 'O', 'f', 'R',
'a', 'n', 'g', 'e', 'D', 'e', 'c', 'i', 'm', 'F', 'a', 'c', 't', 'o', 'r' };
char_T c_u[39];
const mxArray *c_y;
static const int32_T iv7[2] = { 1, 39 };
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
for (i11 = 0; i11 < 7; i11++) {
u[i11] = cv7[i11];
}
y = NULL;
m1 = emlrtCreateCharArray(2, iv5);
emlrtInitCharArrayR2013a(sp, 7, m1, &u[0]);
emlrtAssign(&y, m1);
for (i11 = 0; i11 < 7; i11++) {
b_u[i11] = cv8[i11];
}
b_y = NULL;
m1 = emlrtCreateCharArray(2, iv6);
emlrtInitCharArrayR2013a(sp, 7, m1, &b_u[0]);
emlrtAssign(&b_y, m1);
for (i11 = 0; i11 < 39; i11++) {
c_u[i11] = msgID[i11];
}
c_y = NULL;
m1 = emlrtCreateCharArray(2, iv7);
emlrtInitCharArrayR2013a(sp, 39, m1, &c_u[0]);
emlrtAssign(&c_y, m1);
st.site = &fb_emlrtRSI;
b_feval(&st, y, feval(&st, b_y, c_y, &emlrtMCI), &b_emlrtMCI);
}
void check_forloop_overflow_error(const emlrtStack *sp)
{
const mxArray *y;
static const int32_T iv10[2] = { 1, 34 };
const mxArray *m2;
char_T cv15[34];
int32_T i;
static const char_T cv16[34] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
'l', 'b', 'o', 'x', ':', 'i', 'n', 't', '_', 'f', 'o', 'r', 'l', 'o', 'o',
'p', '_', 'o', 'v', 'e', 'r', 'f', 'l', 'o', 'w' };
const mxArray *b_y;
static const int32_T iv11[2] = { 1, 23 };
char_T cv17[23];
static const char_T cv18[23] = { 'c', 'o', 'd', 'e', 'r', '.', 'i', 'n', 't',
'e', 'r', 'n', 'a', 'l', '.', 'i', 'n', 'd', 'e', 'x', 'I', 'n', 't' };
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = sp;
b_st.tls = sp->tls;
y = NULL;
m2 = emlrtCreateCharArray(2, iv10);
for (i = 0; i < 34; i++) {
cv15[i] = cv16[i];
}
emlrtInitCharArrayR2013a(sp, 34, m2, cv15);
emlrtAssign(&y, m2);
b_y = NULL;
m2 = emlrtCreateCharArray(2, iv11);
for (i = 0; i < 23; i++) {
cv17[i] = cv18[i];
}
emlrtInitCharArrayR2013a(sp, 23, m2, cv17);
emlrtAssign(&b_y, m2);
st.site = &fe_emlrtRSI;
b_st.site = &me_emlrtRSI;
error(&st, message(&b_st, y, b_y, &emlrtMCI), &b_emlrtMCI);
}
void error(const emlrtStack *sp, const char_T varargin_2_data[], const int32_T
varargin_2_size[2])
{
int32_T i16;
static const char_T varargin_1[41] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R',
'u', 'T', 'r', 'a', 'n', 's', 'm', 'i', 't', 't', 'e', 'r', ':', 'T', 'r',
'a', 'n', 's', 'm', 'i', 't', 'U', 'n', 's', 'u', 'c', 'c', 'e', 's', 's',
'f', 'u', 'l' };
char_T u[41];
const mxArray *y;
static const int32_T iv12[2] = { 1, 41 };
const mxArray *m5;
int32_T u_size[2];
int32_T loop_ub;
char_T u_data[1024];
const mxArray *b_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
for (i16 = 0; i16 < 41; i16++) {
u[i16] = varargin_1[i16];
}
y = NULL;
m5 = emlrtCreateCharArray(2, iv12);
emlrtInitCharArrayR2013a(sp, 41, m5, &u[0]);
emlrtAssign(&y, m5);
u_size[0] = 1;
u_size[1] = varargin_2_size[1];
loop_ub = varargin_2_size[0] * varargin_2_size[1];
for (i16 = 0; i16 < loop_ub; i16++) {
u_data[i16] = varargin_2_data[i16];
}
b_y = NULL;
m5 = emlrtCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m5, &u_data[0]);
emlrtAssign(&b_y, m5);
st.site = &db_emlrtRSI;
c_error(&st, y, b_y, &e_emlrtMCI);
}
void error(const emlrtStack *sp, const char_T varargin_2_data[], const int32_T
varargin_2_size[2])
{
const mxArray *y;
static const int32_T iv29[2] = { 1, 41 };
const mxArray *m9;
char_T cv46[41];
int32_T i;
static const char_T cv47[41] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R', 'u',
'T', 'r', 'a', 'n', 's', 'm', 'i', 't', 't', 'e', 'r', ':', 'T', 'r', 'a',
'n', 's', 'm', 'i', 't', 'U', 'n', 's', 'u', 'c', 'c', 'e', 's', 's', 'f',
'u', 'l' };
int32_T u_size[2];
int32_T i11;
char_T u_data[1024];
const mxArray *b_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m9 = emlrtCreateCharArray(2, iv29);
for (i = 0; i < 41; i++) {
cv46[i] = cv47[i];
}
emlrtInitCharArrayR2013a(sp, 41, m9, cv46);
emlrtAssign(&y, m9);
u_size[0] = 1;
u_size[1] = varargin_2_size[1];
i = varargin_2_size[0] * varargin_2_size[1];
for (i11 = 0; i11 < i; i11++) {
u_data[i11] = varargin_2_data[i11];
}
b_y = NULL;
m9 = emlrtCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m9, (char_T *)u_data);
emlrtAssign(&b_y, m9);
st.site = &mb_emlrtRSI;
d_error(&st, y, b_y, &i_emlrtMCI);
}
void eml_warning(const emlrtStack *sp, const char_T varargin_2_data[], const
int32_T varargin_2_size[2])
{
const mxArray *y;
static const int32_T iv37[2] = { 1, 31 };
const mxArray *m15;
char_T cv62[31];
int32_T i;
static const char_T cv63[31] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R', 'u',
'B', 'a', 's', 'e', ':', 'D', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't',
'P', 'r', 'o', 'b', 'l', 'e', 'm' };
int32_T u_size[2];
int32_T i13;
char_T u_data[1024];
const mxArray *b_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m15 = emlrtCreateCharArray(2, iv37);
for (i = 0; i < 31; i++) {
cv62[i] = cv63[i];
}
emlrtInitCharArrayR2013a(sp, 31, m15, cv62);
emlrtAssign(&y, m15);
u_size[0] = 1;
u_size[1] = varargin_2_size[1];
i = varargin_2_size[0] * varargin_2_size[1];
for (i13 = 0; i13 < i; i13++) {
u_data[i13] = varargin_2_data[i13];
}
b_y = NULL;
m15 = emlrtCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m15, (char_T *)u_data);
emlrtAssign(&b_y, m15);
st.site = &rb_emlrtRSI;
warning(&st, message(&st, y, b_y, &emlrtMCI), &b_emlrtMCI);
}
void b_error(const emlrtStack *sp, const char_T varargin_2_data[], const int32_T
varargin_2_size[2])
{
int32_T i19;
static const char_T varargin_1[37] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R',
'u', 'R', 'e', 'c', 'e', 'i', 'v', 'e', 'r', ':', 'R', 'e', 'c', 'e', 'i',
'v', 'e', 'U', 'n', 's', 'u', 'c', 'c', 'e', 's', 's', 'f', 'u', 'l' };
char_T u[37];
const mxArray *y;
static const int32_T iv13[2] = { 1, 37 };
const mxArray *m6;
int32_T u_size[2];
int32_T loop_ub;
char_T u_data[1024];
const mxArray *b_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
for (i19 = 0; i19 < 37; i19++) {
u[i19] = varargin_1[i19];
}
y = NULL;
m6 = emlrtCreateCharArray(2, iv13);
emlrtInitCharArrayR2013a(sp, 37, m6, &u[0]);
emlrtAssign(&y, m6);
u_size[0] = 1;
u_size[1] = varargin_2_size[1];
loop_ub = varargin_2_size[0] * varargin_2_size[1];
for (i19 = 0; i19 < loop_ub; i19++) {
u_data[i19] = varargin_2_data[i19];
}
b_y = NULL;
m6 = emlrtCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m6, &u_data[0]);
emlrtAssign(&b_y, m6);
st.site = &db_emlrtRSI;
c_error(&st, y, b_y, &e_emlrtMCI);
}
void b_error(const emlrtStack *sp, const char_T varargin_2_data[], const int32_T
varargin_2_size[2])
{
const mxArray *y;
static const int32_T iv35[2] = { 1, 37 };
const mxArray *m13;
char_T cv58[37];
int32_T i;
static const char_T cv59[37] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R', 'u',
'R', 'e', 'c', 'e', 'i', 'v', 'e', 'r', ':', 'R', 'e', 'c', 'e', 'i', 'v',
'e', 'U', 'n', 's', 'u', 'c', 'c', 'e', 's', 's', 'f', 'u', 'l' };
int32_T u_size[2];
int32_T i12;
char_T u_data[1024];
const mxArray *b_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m13 = emlrtCreateCharArray(2, iv35);
for (i = 0; i < 37; i++) {
cv58[i] = cv59[i];
}
emlrtInitCharArrayR2013a(sp, 37, m13, cv58);
emlrtAssign(&y, m13);
u_size[0] = 1;
u_size[1] = varargin_2_size[1];
i = varargin_2_size[0] * varargin_2_size[1];
for (i12 = 0; i12 < i; i12++) {
u_data[i12] = varargin_2_data[i12];
}
b_y = NULL;
m13 = emlrtCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m13, (char_T *)u_data);
emlrtAssign(&b_y, m13);
st.site = &mb_emlrtRSI;
d_error(&st, y, b_y, &i_emlrtMCI);
}
/* Function Definitions */
static const mxArray *emlrt_marshallOut(const emlrtStack *sp, const char_T u[6])
{
const mxArray *y;
static const int32_T iv18[2] = { 1, 6 };
const mxArray *m9;
y = NULL;
m9 = emlrtCreateCharArray(2, iv18);
emlrtInitCharArrayR2013a(sp, 6, m9, &u[0]);
emlrtAssign(&y, m9);
return y;
}
static void cgxe_mdl_outputs(InstanceStruct_UXvEHHrxIcmXaLthmwvduD
*moduleInstance)
{
real_T varargin_6[6250];
int32_T k;
dsp_SampleRateConverter_2 *obj;
dspcodegen_FIRDecimator *iobj_0;
dspcodegen_FIRRateConverter *iobj_1;
static char_T cv14[45] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's',
't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e',
'd', 'W', 'h', 'e', 'n', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'd', 'C', 'o',
'd', 'e', 'g', 'e', 'n' };
char_T u[45];
const mxArray *y;
static const int32_T iv21[2] = { 1, 45 };
const mxArray *m4;
static char_T cv15[4] = { 's', 't', 'e', 'p' };
char_T b_u[4];
const mxArray *b_y;
static const int32_T iv22[2] = { 1, 4 };
static char_T cv16[51] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's',
't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e',
'd', 'W', 'h', 'e', 'n', 'L', 'o', 'c', 'k', 'e', 'd', 'R', 'e', 'l', 'e',
'a', 's', 'e', 'd', 'C', 'o', 'd', 'e', 'g', 'e', 'n' };
char_T c_u[51];
const mxArray *c_y;
static const int32_T iv23[2] = { 1, 51 };
static char_T cv17[5] = { 's', 'e', 't', 'u', 'p' };
char_T d_u[5];
const mxArray *d_y;
static const int32_T iv24[2] = { 1, 5 };
static int16_T inputSize[8] = { 6250, 1, 1, 1, 1, 1, 1, 1 };
static char_T cv18[29] = { 'd', 's', 'p', ':', 's', 'y', 's', 't', 'e', 'm',
':', 'S', 'h', 'a', 'r', 'e', 'd', ':', 'n', 'u', 'm', 'C', 'h', 'a', 'n',
'n', 'e', 'l', 's' };
char_T e_u[29];
const mxArray *e_y;
static const int32_T iv25[2] = { 1, 29 };
static real_T dv2[65] = { -0.00042490390801053907, 0.001829921716933601,
-0.0053922845058157441, 0.013158346550611766, -0.0306391449331187,
0.097992165418816057, 0.1494061316020634, -0.036811645611123822,
0.015554560498179271, -0.0065160634201840671, 0.002322039466476993,
-0.00059679513327257766, 7.912220199299E-5, -0.00018023922410876497,
0.00087868330763207075, -0.0027374434497387575, 0.0068640356860943941,
-0.015898279697317719, 0.044393549657968379, 0.18648984591811768,
-0.027710944293488637, 0.011353373510521791, -0.004835216511247617,
0.0017985509582130208, -0.0005034779575003312, 7.1006774722819944E-5, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
7.1006774722819944E-5, -0.0005034779575003312, 0.0017985509582130208,
-0.004835216511247617, 0.011353373510521791, -0.027710944293488637,
0.18648984591811768, 0.044393549657968379, -0.015898279697317719,
0.0068640356860943941, -0.0027374434497387575, 0.00087868330763207075,
-0.00018023922410876497, 7.912220199299E-5, -0.00059679513327257766,
0.002322039466476993, -0.0065160634201840671, 0.015554560498179271,
-0.036811645611123822, 0.1494061316020634, 0.097992165418816057,
-0.0306391449331187, 0.013158346550611766, -0.0053922845058157441,
0.001829921716933601, -0.00042490390801053907 };
static real_T dv3[120] = { -2.7394100013652473E-5, 0.0, 0.00037894068534068619,
-0.0013708823152694639, 0.00268257205568729, -0.0029618195399131889, 0.0,
0.0078609652501006478, -0.019453248977701877, 0.028984307962212054,
-0.026341800053436379, 0.0, 0.059586630047975528, -0.16398784004285519,
0.39970920445885333, 0.74757835469466261, 0.0, -0.076109876780524763,
0.077352679334485558, -0.051701756420330057, 0.021737647121907556, 0.0,
-0.009760644763162624, 0.010147444378648696, -0.0062395788347920046,
0.00223736435719863, 0.0, -0.000578393604977232, 0.00038049397375299542,
-0.00011122314331323368, -7.3471653020902532E-5, 0.0001803558498977357, 0.0,
-0.0010125268340104962, 0.00312437313653832, -0.0054788551201990889,
0.0055792244712591183, 0.0, -0.013309431044135926, 0.031938446310848335,
-0.04692872867557716, 0.043075982682944734, 0.0, -0.11993407734560091,
0.60283398545426792, 0.60283398545426792, -0.11993407734560091, 0.0,
0.043075982682944734, -0.04692872867557716, 0.031938446310848335,
-0.013309431044135926, 0.0, 0.0055792244712591183, -0.0054788551201990889,
0.00312437313653832, -0.0010125268340104962, 0.0, 0.0001803558498977357,
-7.3471653020902532E-5, -0.00011122314331323368, 0.00038049397375299542,
-0.000578393604977232, 0.0, 0.00223736435719863, -0.0062395788347920046,
0.010147444378648696, -0.009760644763162624, 0.0, 0.021737647121907556,
-0.051701756420330057, 0.077352679334485558, -0.076109876780524763, 0.0,
0.74757835469466261, 0.39970920445885333, -0.16398784004285519,
0.059586630047975528, 0.0, -0.026341800053436379, 0.028984307962212054,
-0.019453248977701877, 0.0078609652501006478, 0.0, -0.0029618195399131889,
0.00268257205568729, -0.0013708823152694639, 0.00037894068534068619, 0.0,
-2.7394100013652473E-5, -9.8313238270332086E-5, 0.000486827925108784,
-0.0011378244855056148, 0.001415513014019786, 0.0, -0.0043758948985123938,
0.011375305454062892, -0.017543845054337627, 0.01624272325576193, 0.0,
-0.035239058026866117, 0.086157558252096214, -0.14115130237644263,
0.18386872695653758, 0.8, 0.18386872695653758, -0.14115130237644263,
0.086157558252096214, -0.035239058026866117, 0.0, 0.01624272325576193,
-0.017543845054337627, 0.011375305454062892, -0.0043758948985123938, 0.0,
0.001415513014019786, -0.0011378244855056148, 0.000486827925108784,
-9.8313238270332086E-5, 0.0 };
static int8_T iv26[5] = { 1, 2, 3, 4, 4 };
char_T f_u[45];
const mxArray *f_y;
static const int32_T iv27[2] = { 1, 45 };
static char_T cv19[5] = { 'r', 'e', 's', 'e', 't' };
char_T g_u[5];
const mxArray *g_y;
static const int32_T iv28[2] = { 1, 5 };
char_T h_u[45];
const mxArray *h_y;
static const int32_T iv29[2] = { 1, 45 };
char_T i_u[5];
const mxArray *i_y;
static const int32_T iv30[2] = { 1, 5 };
boolean_T anyInputSizeChanged;
boolean_T exitg1;
char_T j_u[29];
const mxArray *j_y;
static const int32_T iv31[2] = { 1, 29 };
real_T varargout_1[1000];
for (k = 0; k < 6250; k++) {
varargin_6[k] = (*moduleInstance->u0)[k];
}
if (!moduleInstance->sysobj_not_empty) {
obj = &moduleInstance->sysobj;
moduleInstance->sysobj.filt1 = NULL;
moduleInstance->sysobj.filt2 = NULL;
obj->isInitialized = 0;
obj->NumChannels = -1.0;
moduleInstance->sysobj_not_empty = true;
}
obj = &moduleInstance->sysobj;
iobj_0 = &moduleInstance->gobj_1;
iobj_1 = &moduleInstance->gobj_3;
if (moduleInstance->sysobj.isInitialized == 2) {
for (k = 0; k < 45; k++) {
u[k] = cv14[k];
}
y = NULL;
m4 = emlrtCreateCharArray(2, iv21);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m4, &u[0]);
emlrtAssign(&y, m4);
for (k = 0; k < 4; k++) {
b_u[k] = cv15[k];
}
b_y = NULL;
m4 = emlrtCreateCharArray(2, iv22);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 4, m4, &b_u[0]);
emlrtAssign(&b_y, m4);
error(moduleInstance, message(moduleInstance, y, b_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (obj->isInitialized != 1) {
if (obj->isInitialized != 0) {
for (k = 0; k < 51; k++) {
c_u[k] = cv16[k];
}
c_y = NULL;
m4 = emlrtCreateCharArray(2, iv23);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 51, m4, &c_u
[0]);
emlrtAssign(&c_y, m4);
for (k = 0; k < 5; k++) {
d_u[k] = cv17[k];
}
d_y = NULL;
m4 = emlrtCreateCharArray(2, iv24);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 5, m4, &d_u[0]);
emlrtAssign(&d_y, m4);
error(moduleInstance, message(moduleInstance, c_y, d_y, &c_emlrtMCI),
&c_emlrtMCI);
}
obj->isInitialized = 1;
for (k = 0; k < 8; k++) {
obj->inputVarSize1[k] = (uint32_T)inputSize[k];
}
if ((obj->NumChannels != -1.0) && (1.0 != obj->NumChannels)) {
for (k = 0; k < 29; k++) {
e_u[k] = cv18[k];
}
e_y = NULL;
m4 = emlrtCreateCharArray(2, iv25);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 29, m4, &e_u
[0]);
emlrtAssign(&e_y, m4);
error(moduleInstance, b_message(moduleInstance, e_y, &d_emlrtMCI),
&d_emlrtMCI);
}
if (!(obj->filt1 == NULL)) {
emlrtErrorWithMessageIdR2012b(moduleInstance->emlrtRootTLSGlobal,
&b_emlrtRTEI, "EMLRT:runTime:NontunableHandleProp", 0);
}
iobj_0->isInitialized = 0;
/* System object Constructor function: dsp.FIRDecimator */
iobj_0->cSFunObject.P0_IC = 0.0;
for (k = 0; k < 65; k++) {
iobj_0->cSFunObject.P1_FILT[k] = dv2[k];
}
obj->filt1 = iobj_0;
if (!(obj->filt2 == NULL)) {
emlrtErrorWithMessageIdR2012b(moduleInstance->emlrtRootTLSGlobal,
&emlrtRTEI, "EMLRT:runTime:NontunableHandleProp", 0);
}
iobj_1->isInitialized = 0;
/* System object Constructor function: dsp.FIRRateConverter */
for (k = 0; k < 120; k++) {
iobj_1->cSFunObject.P0_FILTER[k] = dv3[k];
}
for (k = 0; k < 4; k++) {
iobj_1->cSFunObject.P1_PolyphaseSelector[k] = k;
}
for (k = 0; k < 5; k++) {
iobj_1->cSFunObject.P2_StartIdx[k] = k;
}
for (k = 0; k < 5; k++) {
iobj_1->cSFunObject.P3_StopIdx[k] = iv26[k];
}
obj->filt2 = iobj_1;
obj->NumChannels = 1.0;
iobj_0 = obj->filt1;
if (iobj_0->isInitialized == 2) {
for (k = 0; k < 45; k++) {
f_u[k] = cv14[k];
}
f_y = NULL;
m4 = emlrtCreateCharArray(2, iv27);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m4, &f_u
[0]);
emlrtAssign(&f_y, m4);
for (k = 0; k < 5; k++) {
g_u[k] = cv19[k];
}
g_y = NULL;
m4 = emlrtCreateCharArray(2, iv28);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 5, m4, &g_u[0]);
emlrtAssign(&g_y, m4);
error(moduleInstance, message(moduleInstance, f_y, g_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (iobj_0->isInitialized == 1) {
/* System object Initialization function: dsp.FIRDecimator */
iobj_0->cSFunObject.W2_CoeffIdx = 52;
iobj_0->cSFunObject.W0_PhaseIdx = 4;
iobj_0->cSFunObject.W4_TapDelayIndex = 48;
iobj_0->cSFunObject.W1_Sums = 0.0;
for (k = 0; k < 60; k++) {
iobj_0->cSFunObject.W3_StatesBuff[k] = 0.0;
}
}
iobj_1 = obj->filt2;
if (iobj_1->isInitialized == 2) {
for (k = 0; k < 45; k++) {
h_u[k] = cv14[k];
}
h_y = NULL;
m4 = emlrtCreateCharArray(2, iv29);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m4, &h_u
[0]);
emlrtAssign(&h_y, m4);
for (k = 0; k < 5; k++) {
i_u[k] = cv19[k];
}
i_y = NULL;
m4 = emlrtCreateCharArray(2, iv30);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 5, m4, &i_u[0]);
emlrtAssign(&i_y, m4);
error(moduleInstance, message(moduleInstance, h_y, i_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (iobj_1->isInitialized == 1) {
/* System object Initialization function: dsp.FIRRateConverter */
iobj_1->cSFunObject.W1_InBufIdx = 0;
for (k = 0; k < 30; k++) {
iobj_1->cSFunObject.W0_InBuf[k] = 0.0;
}
}
}
anyInputSizeChanged = false;
k = 0;
exitg1 = false;
while ((exitg1 == false) && (k < 8)) {
if (obj->inputVarSize1[k] != (uint32_T)inputSize[k]) {
anyInputSizeChanged = true;
for (k = 0; k < 8; k++) {
obj->inputVarSize1[k] = (uint32_T)inputSize[k];
}
exitg1 = true;
} else {
k++;
}
}
if (anyInputSizeChanged && (obj->NumChannels != -1.0) && (1.0 !=
obj->NumChannels)) {
for (k = 0; k < 29; k++) {
j_u[k] = cv18[k];
}
j_y = NULL;
m4 = emlrtCreateCharArray(2, iv31);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 29, m4, &j_u[0]);
emlrtAssign(&j_y, m4);
error(moduleInstance, b_message(moduleInstance, j_y, &d_emlrtMCI),
&d_emlrtMCI);
}
SampleRateConverter_stepImpl(moduleInstance, obj, varargin_6, varargout_1);
for (k = 0; k < 1000; k++) {
(*moduleInstance->b_y0)[k] = varargout_1[k];
}
}
/* Function Definitions */
static void SampleRateConverter_stepImpl(InstanceStruct_UXvEHHrxIcmXaLthmwvduD
*moduleInstance, dsp_SampleRateConverter_2 *obj, real_T u[6250], real_T y[1000])
{
real_T b_y1[1250];
dspcodegen_FIRRateConverter *b_obj;
int32_T nModDFactor;
static char_T cv0[45] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's',
't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e',
'd', 'W', 'h', 'e', 'n', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'd', 'C', 'o',
'd', 'e', 'g', 'e', 'n' };
char_T b_u[45];
const mxArray *b_y;
static const int32_T iv0[2] = { 1, 45 };
const mxArray *m0;
static char_T cv1[4] = { 's', 't', 'e', 'p' };
char_T c_u[4];
const mxArray *c_y;
static const int32_T iv1[2] = { 1, 4 };
static char_T cv2[51] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's',
't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e',
'd', 'W', 'h', 'e', 'n', 'L', 'o', 'c', 'k', 'e', 'd', 'R', 'e', 'l', 'e',
'a', 's', 'e', 'd', 'C', 'o', 'd', 'e', 'g', 'e', 'n' };
char_T d_u[51];
const mxArray *d_y;
static const int32_T iv2[2] = { 1, 51 };
static char_T cv3[5] = { 's', 'e', 't', 'u', 'p' };
char_T e_u[5];
const mxArray *e_y;
static const int32_T iv3[2] = { 1, 5 };
dsp_FIRRateConverter_1 *c_obj;
int32_T outIdx;
int32_T inIdx;
int32_T inBufIdx;
int32_T n;
int32_T outputStartIdx;
real_T acc;
int32_T coefPolyphaseOffset;
int32_T i;
real_T prod;
SystemCore_step(moduleInstance, obj->filt1, u, b_y1);
b_obj = obj->filt2;
if (b_obj->isInitialized == 2) {
for (nModDFactor = 0; nModDFactor < 45; nModDFactor++) {
b_u[nModDFactor] = cv0[nModDFactor];
}
b_y = NULL;
m0 = emlrtCreateCharArray(2, iv0);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m0, &b_u[0]);
emlrtAssign(&b_y, m0);
for (nModDFactor = 0; nModDFactor < 4; nModDFactor++) {
c_u[nModDFactor] = cv1[nModDFactor];
}
c_y = NULL;
m0 = emlrtCreateCharArray(2, iv1);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 4, m0, &c_u[0]);
emlrtAssign(&c_y, m0);
error(moduleInstance, message(moduleInstance, b_y, c_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (b_obj->isInitialized != 1) {
if (b_obj->isInitialized != 0) {
for (nModDFactor = 0; nModDFactor < 51; nModDFactor++) {
d_u[nModDFactor] = cv2[nModDFactor];
}
d_y = NULL;
m0 = emlrtCreateCharArray(2, iv2);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 51, m0, &d_u
[0]);
emlrtAssign(&d_y, m0);
for (nModDFactor = 0; nModDFactor < 5; nModDFactor++) {
e_u[nModDFactor] = cv3[nModDFactor];
}
e_y = NULL;
m0 = emlrtCreateCharArray(2, iv3);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 5, m0, &e_u[0]);
emlrtAssign(&e_y, m0);
error(moduleInstance, message(moduleInstance, d_y, e_y, &c_emlrtMCI),
&c_emlrtMCI);
}
b_obj->isInitialized = 1;
/* System object Initialization function: dsp.FIRRateConverter */
b_obj->cSFunObject.W1_InBufIdx = 0;
for (nModDFactor = 0; nModDFactor < 30; nModDFactor++) {
b_obj->cSFunObject.W0_InBuf[nModDFactor] = 0.0;
}
}
c_obj = &b_obj->cSFunObject;
/* System object Outputs function: dsp.FIRRateConverter */
outIdx = 0;
inIdx = 0;
/* Update inBufIdx and inputChannelOffset for current channel */
inBufIdx = b_obj->cSFunObject.W1_InBufIdx;
for (n = 0; n < 1250; n++) {
nModDFactor = n % 5;
outputStartIdx = c_obj->P2_StartIdx[nModDFactor];
nModDFactor = c_obj->P3_StopIdx[nModDFactor];
/* Read input into inBufArray */
c_obj->W0_InBuf[inBufIdx] = b_y1[inIdx];
inIdx++;
/* Generate outputs (if any) for current input n */
while (outputStartIdx < nModDFactor) {
acc = 0.0;
coefPolyphaseOffset = c_obj->P1_PolyphaseSelector[outputStartIdx] * 30;
for (i = inBufIdx; i < 30; i++) {
prod = c_obj->P0_FILTER[(coefPolyphaseOffset + i) - inBufIdx] *
c_obj->W0_InBuf[i];
acc += prod;
}
for (i = 0; i < inBufIdx; i++) {
prod = c_obj->P0_FILTER[((coefPolyphaseOffset - inBufIdx) + i) + 30] *
c_obj->W0_InBuf[i];
acc += prod;
}
y[outIdx] = acc;
outIdx++;
outputStartIdx++;
}
/* Decrement inBufIdx, wrap if necessary */
if (inBufIdx == 0) {
inBufIdx = 29;
} else {
inBufIdx--;
}
}
/* Update inBufIdx */
b_obj->cSFunObject.W1_InBufIdx = inBufIdx;
}
/* Function Definitions */
void b_mapiPrivate(const emlrtStack *sp, int32_T varargin_1, UsrpErrorCapiEnumT *
varargout_1, char_T varargout_2_data[], int32_T
varargout_2_size[2])
{
int32_T i14;
static const char_T cv14[6] = { 's', 'i', 'l', 'e', 'n', 't' };
char_T u[6];
const mxArray *y;
static const int32_T iv10[2] = { 1, 6 };
const mxArray *m3;
UsrpErrorCapiEnumT errStat_i;
int32_T errStrSize;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
/* */
/* This function unifies handling of interp vs. codegen call as well as */
/* errStat / errStr assignment. */
/* */
/* Copyright 2011-2015 The MathWorks, Inc. */
if (!isSetupsdruCalled) {
for (i14 = 0; i14 < 6; i14++) {
u[i14] = cv14[i14];
}
y = NULL;
m3 = emlrtCreateCharArray(2, iv10);
emlrtInitCharArrayR2013a(sp, 6, m3, &u[0]);
emlrtAssign(&y, m3);
st.site = &eb_emlrtRSI;
setupsdru(&st, sdruroot(&st, &c_emlrtMCI), y, &d_emlrtMCI);
isSetupsdruCalled = true;
}
/* These sizes must match those in C code. */
/* Arbitrary max imposed on ML/SL side */
/* function is being called in interpreted mode */
/* not being found: */
/* eml_allow_enum_inputs; */
/* errStat_i = int32(0); */
varargout_2_size[0] = 1;
memset(&varargout_2_data[0], 0, sizeof(char_T) << 10);
closeDataConnection_c(varargin_1, &errStat_i, &varargout_2_data[0]);
/* errStat = UsrpErrorCapiEnumT(errStat_i); */
errStrSize = strlen(&varargout_2_data[0]);
if (errStrSize <= 1024) {
} else {
emlrtErrorWithMessageIdR2012b(sp, &d_emlrtRTEI,
"Coder:builtins:AssertionFailed", 0);
}
if (1 > errStrSize) {
varargout_2_size[1] = 0;
} else {
varargout_2_size[1] = errStrSize;
}
*varargout_1 = errStat_i;
}
void mapiPrivate(const emlrtStack *sp, const uint8_T varargin_1[12],
BoardIdCapiEnumT varargin_2, const uint8_T varargin_3[15],
DataPortDataTypeCapiEnumT varargin_5, int32_T *varargout_1,
UsrpErrorCapiEnumT *varargout_2, char_T varargout_3_data[],
int32_T varargout_3_size[2])
{
int32_T i13;
static const char_T cv13[6] = { 's', 'i', 'l', 'e', 'n', 't' };
char_T u[6];
const mxArray *y;
static const int32_T iv9[2] = { 1, 6 };
const mxArray *m2;
uint8_T addr_null[13];
char * addr_c;
uint8_T req_null[16];
char * req_c;
int32_T driverApiH;
UsrpErrorCapiEnumT errStat_i;
int32_T errStrSize;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
/* */
/* This function unifies handling of interp vs. codegen call as well as */
/* errStat / errStr assignment. */
/* */
/* Copyright 2011-2015 The MathWorks, Inc. */
if (!isSetupsdruCalled) {
for (i13 = 0; i13 < 6; i13++) {
u[i13] = cv13[i13];
}
y = NULL;
m2 = emlrtCreateCharArray(2, iv9);
emlrtInitCharArrayR2013a(sp, 6, m2, &u[0]);
emlrtAssign(&y, m2);
st.site = &eb_emlrtRSI;
setupsdru(&st, sdruroot(&st, &c_emlrtMCI), y, &d_emlrtMCI);
isSetupsdruCalled = true;
}
/* These sizes must match those in C code. */
/* Arbitrary max imposed on ML/SL side */
/* function is being called in interpreted mode */
/* not being found: */
/* eml_allow_enum_inputs; */
/* errStat_i = int32(0); */
varargout_3_size[0] = 1;
memset(&varargout_3_data[0], 0, sizeof(char_T) << 10);
/* varargin 1 2 3 4 5 6 7 8 9 */
/* addr, boardId, requester, frameLength, dportType, buffMode, buffSize, masterClockRate, channelMapping */
/* varargout 1 2 3 */
/* driverH, errStat, errMsg */
for (i13 = 0; i13 < 12; i13++) {
addr_null[i13] = varargin_1[i13];
}
addr_null[12] = 0;
addr_c = (char *)(addr_null);
for (i13 = 0; i13 < 15; i13++) {
req_null[i13] = varargin_3[i13];
}
req_null[15] = 0;
req_c = (char *)(req_null);
openDataConnection_c(addr_c, varargin_2, req_c, 1408U, varargin_5, false, 0U,
1.0E+8, 1.0, &driverApiH, &errStat_i, &varargout_3_data[0]);
*varargout_1 = driverApiH;
/* Tell coder that addr_null & req_null must be alive and separate throughout the call to cmd_c. */
(void)(addr_null);
(void)(req_null);
/* errStat = UsrpErrorCapiEnumT(errStat_i); */
errStrSize = strlen(&varargout_3_data[0]);
if (errStrSize <= 1024) {
} else {
emlrtErrorWithMessageIdR2012b(sp, &d_emlrtRTEI,
"Coder:builtins:AssertionFailed", 0);
}
if (1 > errStrSize) {
varargout_3_size[1] = 0;
} else {
varargout_3_size[1] = errStrSize;
}
*varargout_2 = errStat_i;
}
void c_warning(const emlrtStack *sp, const char_T varargin_1_data[], const
int32_T varargin_1_size[2])
{
int32_T i21;
static const char_T cv22[7] = { 'w', 'a', 'r', 'n', 'i', 'n', 'g' };
char_T u[7];
const mxArray *y;
static const int32_T iv15[2] = { 1, 7 };
const mxArray *m8;
static const char_T cv23[7] = { 'm', 'e', 's', 's', 'a', 'g', 'e' };
char_T b_u[7];
const mxArray *b_y;
static const int32_T iv16[2] = { 1, 7 };
static const char_T msgID[31] = { 's', 'd', 'r', 'u', ':', 'S', 'D', 'R', 'u',
'B', 'a', 's', 'e', ':', 'D', 'i', 's', 'c', 'o', 'n', 'n', 'e', 'c', 't',
'P', 'r', 'o', 'b', 'l', 'e', 'm' };
char_T c_u[31];
const mxArray *c_y;
static const int32_T iv17[2] = { 1, 31 };
int32_T u_size[2];
int32_T loop_ub;
char_T u_data[1024];
const mxArray *d_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
for (i21 = 0; i21 < 7; i21++) {
u[i21] = cv22[i21];
}
y = NULL;
m8 = emlrtCreateCharArray(2, iv15);
emlrtInitCharArrayR2013a(sp, 7, m8, &u[0]);
emlrtAssign(&y, m8);
for (i21 = 0; i21 < 7; i21++) {
b_u[i21] = cv23[i21];
}
b_y = NULL;
m8 = emlrtCreateCharArray(2, iv16);
emlrtInitCharArrayR2013a(sp, 7, m8, &b_u[0]);
emlrtAssign(&b_y, m8);
for (i21 = 0; i21 < 31; i21++) {
c_u[i21] = msgID[i21];
}
c_y = NULL;
m8 = emlrtCreateCharArray(2, iv17);
emlrtInitCharArrayR2013a(sp, 31, m8, &c_u[0]);
emlrtAssign(&c_y, m8);
u_size[0] = 1;
u_size[1] = varargin_1_size[1];
loop_ub = varargin_1_size[0] * varargin_1_size[1];
for (i21 = 0; i21 < loop_ub; i21++) {
u_data[i21] = varargin_1_data[i21];
}
d_y = NULL;
m8 = emlrtCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m8, &u_data[0]);
emlrtAssign(&d_y, m8);
st.site = &fb_emlrtRSI;
b_feval(&st, y, c_feval(&st, b_y, c_y, d_y, &emlrtMCI), &b_emlrtMCI);
}
/* Function Definitions */
void sendComplexDoubleData(const emlrtStack *sp, int32_T driverApiH, const
creal_T data[1408], const real_T freq[2], const real_T loOffset[2], const
real_T gain[2], real_T interp, uint32_T *underflow, UsrpErrorCapiEnumT
*errStat, char_T errStr_data[], int32_T errStr_size[2])
{
int32_T i15;
static const char_T cv17[6] = { 's', 'i', 'l', 'e', 'n', 't' };
char_T u[6];
const mxArray *y;
static const int32_T iv11[2] = { 1, 6 };
const mxArray *m4;
UsrpErrorCapiEnumT errStat_i;
creal_T b_data[1408];
real_T b_freq[2];
real_T b_loOffset[2];
real_T b_gain[2];
int32_T errStrSize;
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
/* bug: must pass as top-level arg */
/* dportDtype = DataPortDataTypeCapiEnumT.DPortDTypeCDouble; */
/* Copyright 2011-2012 The MathWorks, Inc. */
st.site = &ab_emlrtRSI;
/* */
/* This function unifies handling of interp vs. codegen call as well as */
/* errStat / errStr assignment. */
/* */
/* Copyright 2011-2015 The MathWorks, Inc. */
if (!isSetupsdruCalled) {
for (i15 = 0; i15 < 6; i15++) {
u[i15] = cv17[i15];
}
y = NULL;
m4 = emlrtCreateCharArray(2, iv11);
emlrtInitCharArrayR2013a(&st, 6, m4, &u[0]);
emlrtAssign(&y, m4);
b_st.site = &eb_emlrtRSI;
setupsdru(&b_st, sdruroot(&b_st, &c_emlrtMCI), y, &d_emlrtMCI);
isSetupsdruCalled = true;
}
/* These sizes must match those in C code. */
/* Arbitrary max imposed on ML/SL side */
/* function is being called in interpreted mode */
/* not being found: */
/* eml_allow_enum_inputs; */
/* errStat_i = int32(0); */
errStr_size[0] = 1;
memset(&errStr_data[0], 0, sizeof(char_T) << 10);
memcpy(&b_data[0], &data[0], 1408U * sizeof(creal_T));
for (i15 = 0; i15 < 2; i15++) {
b_freq[i15] = freq[i15];
b_loOffset[i15] = loOffset[i15];
b_gain[i15] = gain[i15];
}
sendData_c(driverApiH, b_data, b_freq, b_loOffset, b_gain, interp, underflow,
&errStat_i, &errStr_data[0]);
/* errStat = UsrpErrorCapiEnumT(errStat_i); */
errStrSize = strlen(&errStr_data[0]);
if (errStrSize <= 1024) {
} else {
emlrtErrorWithMessageIdR2012b(&st, &d_emlrtRTEI,
"Coder:builtins:AssertionFailed", 0);
}
if (1 > errStrSize) {
errStr_size[1] = 0;
} else {
errStr_size[1] = errStrSize;
}
*errStat = errStat_i;
}
static void c_eml_qrsolve(const emlrtStack *sp, const emxArray_real_T *A,
emxArray_real_T *B, emxArray_real_T *Y)
{
emxArray_real_T *b_A;
emxArray_real_T *work;
int32_T mn;
int32_T i51;
int32_T ix;
emxArray_real_T *tau;
emxArray_int32_T *jpvt;
int32_T m;
int32_T n;
int32_T b_mn;
emxArray_real_T *vn1;
emxArray_real_T *vn2;
int32_T k;
boolean_T overflow;
boolean_T b12;
int32_T i;
int32_T i_i;
int32_T nmi;
int32_T mmi;
int32_T pvt;
int32_T iy;
boolean_T b13;
real_T xnorm;
int32_T i52;
real_T atmp;
real_T d16;
boolean_T b14;
boolean_T b_i;
ptrdiff_t n_t;
ptrdiff_t incx_t;
double * xix0_t;
boolean_T exitg1;
const mxArray *y;
static const int32_T iv78[2] = { 1, 8 };
const mxArray *m14;
char_T cv76[8];
static const char_T cv77[8] = { '%', '%', '%', 'd', '.', '%', 'd', 'e' };
char_T cv78[14];
uint32_T unnamed_idx_0;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
emlrtStack e_st;
emlrtStack f_st;
emlrtStack g_st;
emlrtStack h_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &c_st;
d_st.tls = c_st.tls;
e_st.prev = &d_st;
e_st.tls = d_st.tls;
f_st.prev = &e_st;
f_st.tls = e_st.tls;
g_st.prev = &f_st;
g_st.tls = f_st.tls;
h_st.prev = &g_st;
h_st.tls = g_st.tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
emxInit_real_T(sp, &b_A, 2, &m_emlrtRTEI, true);
b_emxInit_real_T(sp, &work, 1, &rb_emlrtRTEI, true);
mn = (int32_T)muDoubleScalarMin(A->size[0], A->size[1]);
st.site = &mc_emlrtRSI;
b_st.site = &nc_emlrtRSI;
c_st.site = &oc_emlrtRSI;
i51 = b_A->size[0] * b_A->size[1];
b_A->size[0] = A->size[0];
b_A->size[1] = A->size[1];
emxEnsureCapacity(&c_st, (emxArray__common *)b_A, i51, (int32_T)sizeof(real_T),
&m_emlrtRTEI);
ix = A->size[0] * A->size[1];
for (i51 = 0; i51 < ix; i51++) {
b_A->data[i51] = A->data[i51];
}
b_emxInit_real_T(&c_st, &tau, 1, &m_emlrtRTEI, true);
b_emxInit_int32_T(&c_st, &jpvt, 2, &m_emlrtRTEI, true);
m = b_A->size[0];
n = b_A->size[1];
b_mn = muIntScalarMin_sint32(b_A->size[0], b_A->size[1]);
i51 = tau->size[0];
tau->size[0] = b_mn;
emxEnsureCapacity(&c_st, (emxArray__common *)tau, i51, (int32_T)sizeof(real_T),
&n_emlrtRTEI);
d_st.site = &mf_emlrtRSI;
e_st.site = &rb_emlrtRSI;
f_st.site = &sb_emlrtRSI;
g_st.site = &tb_emlrtRSI;
eml_signed_integer_colon(&g_st, b_A->size[1], jpvt);
if ((b_A->size[0] == 0) || (b_A->size[1] == 0)) {
} else {
ix = b_A->size[1];
i51 = work->size[0];
work->size[0] = ix;
emxEnsureCapacity(&c_st, (emxArray__common *)work, i51, (int32_T)sizeof
(real_T), &m_emlrtRTEI);
for (i51 = 0; i51 < ix; i51++) {
work->data[i51] = 0.0;
}
b_emxInit_real_T(&c_st, &vn1, 1, &pb_emlrtRTEI, true);
b_emxInit_real_T(&c_st, &vn2, 1, &qb_emlrtRTEI, true);
d_st.site = &tc_emlrtRSI;
ix = b_A->size[1];
i51 = vn1->size[0];
vn1->size[0] = ix;
emxEnsureCapacity(&c_st, (emxArray__common *)vn1, i51, (int32_T)sizeof
(real_T), &pb_emlrtRTEI);
i51 = vn2->size[0];
vn2->size[0] = ix;
emxEnsureCapacity(&c_st, (emxArray__common *)vn2, i51, (int32_T)sizeof
(real_T), &qb_emlrtRTEI);
k = 1;
d_st.site = &nf_emlrtRSI;
overflow = (b_A->size[1] > 2147483646);
if (overflow) {
e_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&e_st);
}
for (ix = 0; ix + 1 <= b_A->size[1]; ix++) {
d_st.site = &sc_emlrtRSI;
vn1->data[ix] = b_eml_xnrm2(&d_st, b_A->size[0], b_A, k);
vn2->data[ix] = vn1->data[ix];
k += b_A->size[0];
}
d_st.site = &rc_emlrtRSI;
if (1 > b_mn) {
b12 = false;
} else {
b12 = (b_mn > 2147483646);
}
if (b12) {
e_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&e_st);
}
for (i = 1; i <= b_mn; i++) {
i_i = (i + (i - 1) * m) - 1;
nmi = n - i;
mmi = m - i;
d_st.site = &of_emlrtRSI;
ix = eml_ixamax(&d_st, 1 + nmi, vn1, i);
pvt = (i + ix) - 2;
if (pvt + 1 != i) {
d_st.site = &pf_emlrtRSI;
e_st.site = &bc_emlrtRSI;
f_st.site = &cc_emlrtRSI;
ix = 1 + m * pvt;
iy = 1 + m * (i - 1);
g_st.site = &dc_emlrtRSI;
if (1 > m) {
b13 = false;
} else {
b13 = (m > 2147483646);
}
if (b13) {
h_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&h_st);
}
for (k = 1; k <= m; k++) {
i51 = b_A->size[0] * b_A->size[1];
xnorm = b_A->data[emlrtDynamicBoundsCheckFastR2012b(ix, 1, i51,
&le_emlrtBCI, &f_st) - 1];
i51 = b_A->size[0] * b_A->size[1];
i52 = b_A->size[0] * b_A->size[1];
b_A->data[emlrtDynamicBoundsCheckFastR2012b(ix, 1, i51, &le_emlrtBCI,
&f_st) - 1] = b_A->data[emlrtDynamicBoundsCheckFastR2012b(iy, 1, i52,
&le_emlrtBCI, &f_st) - 1];
i51 = b_A->size[0] * b_A->size[1];
b_A->data[emlrtDynamicBoundsCheckFastR2012b(iy, 1, i51, &le_emlrtBCI,
&f_st) - 1] = xnorm;
ix++;
iy++;
}
ix = jpvt->data[pvt];
jpvt->data[pvt] = jpvt->data[i - 1];
jpvt->data[i - 1] = ix;
vn1->data[pvt] = vn1->data[i - 1];
vn2->data[pvt] = vn2->data[i - 1];
}
if (i < m) {
d_st.site = &qc_emlrtRSI;
atmp = b_A->data[i_i];
d16 = 0.0;
if (1 + mmi <= 0) {
} else {
e_st.site = &wc_emlrtRSI;
xnorm = b_eml_xnrm2(&e_st, mmi, b_A, i_i + 2);
if (xnorm != 0.0) {
xnorm = muDoubleScalarHypot(b_A->data[i_i], xnorm);
if (b_A->data[i_i] >= 0.0) {
xnorm = -xnorm;
}
if (muDoubleScalarAbs(xnorm) < 1.0020841800044864E-292) {
ix = 0;
do {
ix++;
e_st.site = &xc_emlrtRSI;
b_eml_xscal(&e_st, mmi, 9.9792015476736E+291, b_A, i_i + 2);
xnorm *= 9.9792015476736E+291;
atmp *= 9.9792015476736E+291;
} while (!(muDoubleScalarAbs(xnorm) >= 1.0020841800044864E-292));
e_st.site = &yc_emlrtRSI;
xnorm = b_eml_xnrm2(&e_st, mmi, b_A, i_i + 2);
xnorm = muDoubleScalarHypot(atmp, xnorm);
if (atmp >= 0.0) {
xnorm = -xnorm;
}
d16 = (xnorm - atmp) / xnorm;
e_st.site = &ad_emlrtRSI;
b_eml_xscal(&e_st, mmi, 1.0 / (atmp - xnorm), b_A, i_i + 2);
e_st.site = &bd_emlrtRSI;
if (1 > ix) {
b14 = false;
} else {
b14 = (ix > 2147483646);
}
if (b14) {
f_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&f_st);
}
for (k = 1; k <= ix; k++) {
xnorm *= 1.0020841800044864E-292;
}
atmp = xnorm;
} else {
d16 = (xnorm - b_A->data[i_i]) / xnorm;
atmp = 1.0 / (b_A->data[i_i] - xnorm);
e_st.site = &cd_emlrtRSI;
b_eml_xscal(&e_st, mmi, atmp, b_A, i_i + 2);
atmp = xnorm;
}
}
}
tau->data[i - 1] = d16;
} else {
atmp = b_A->data[i_i];
d_st.site = &pc_emlrtRSI;
tau->data[i - 1] = eml_matlab_zlarfg();
}
b_A->data[i_i] = atmp;
if (i < n) {
atmp = b_A->data[i_i];
b_A->data[i_i] = 1.0;
d_st.site = &qf_emlrtRSI;
eml_matlab_zlarf(&d_st, mmi + 1, nmi, i_i + 1, tau->data[i - 1], b_A, i
+ i * m, m, work);
b_A->data[i_i] = atmp;
}
d_st.site = &rf_emlrtRSI;
if (i + 1 > n) {
b_i = false;
} else {
b_i = (n > 2147483646);
}
if (b_i) {
e_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&e_st);
}
for (ix = i; ix + 1 <= n; ix++) {
if (vn1->data[ix] != 0.0) {
xnorm = muDoubleScalarAbs(b_A->data[(i + b_A->size[0] * ix) - 1]) /
vn1->data[ix];
xnorm = 1.0 - xnorm * xnorm;
if (xnorm < 0.0) {
xnorm = 0.0;
}
atmp = vn1->data[ix] / vn2->data[ix];
atmp = xnorm * (atmp * atmp);
if (atmp <= 1.4901161193847656E-8) {
if (i < m) {
d_st.site = &sf_emlrtRSI;
e_st.site = &uc_emlrtRSI;
if (mmi < 1) {
xnorm = 0.0;
} else {
f_st.site = &vc_emlrtRSI;
g_st.site = &vc_emlrtRSI;
n_t = (ptrdiff_t)(mmi);
g_st.site = &vc_emlrtRSI;
incx_t = (ptrdiff_t)(1);
i51 = b_A->size[0] * b_A->size[1];
i52 = (i + m * ix) + 1;
xix0_t = (double *)(&b_A->data[emlrtDynamicBoundsCheckFastR2012b
(i52, 1, i51, &vb_emlrtBCI, &f_st) - 1]);
xnorm = dnrm2(&n_t, xix0_t, &incx_t);
}
vn1->data[ix] = xnorm;
vn2->data[ix] = vn1->data[ix];
} else {
vn1->data[ix] = 0.0;
vn2->data[ix] = 0.0;
}
} else {
d_st.site = &tf_emlrtRSI;
vn1->data[ix] *= muDoubleScalarSqrt(xnorm);
}
}
}
}
emxFree_real_T(&vn2);
emxFree_real_T(&vn1);
}
atmp = 0.0;
if (mn > 0) {
xnorm = muDoubleScalarMax(A->size[0], A->size[1]) * muDoubleScalarAbs
(b_A->data[0]) * 2.2204460492503131E-16;
k = 0;
exitg1 = false;
while ((!exitg1) && (k <= mn - 1)) {
if (muDoubleScalarAbs(b_A->data[k + b_A->size[0] * k]) <= xnorm) {
st.site = &lc_emlrtRSI;
y = NULL;
m14 = emlrtCreateCharArray(2, iv78);
for (i = 0; i < 8; i++) {
cv76[i] = cv77[i];
}
emlrtInitCharArrayR2013a(&st, 8, m14, cv76);
emlrtAssign(&y, m14);
b_st.site = &tg_emlrtRSI;
emlrt_marshallIn(&b_st, c_sprintf(&b_st, b_sprintf(&b_st, y,
emlrt_marshallOut(14.0), emlrt_marshallOut(6.0), &o_emlrtMCI),
emlrt_marshallOut(xnorm), &p_emlrtMCI), "sprintf", cv78);
st.site = &kc_emlrtRSI;
b_eml_warning(&st, atmp, cv78);
exitg1 = true;
} else {
atmp++;
k++;
}
}
}
unnamed_idx_0 = (uint32_T)A->size[1];
i51 = Y->size[0];
Y->size[0] = (int32_T)unnamed_idx_0;
emxEnsureCapacity(sp, (emxArray__common *)Y, i51, (int32_T)sizeof(real_T),
&m_emlrtRTEI);
ix = (int32_T)unnamed_idx_0;
for (i51 = 0; i51 < ix; i51++) {
Y->data[i51] = 0.0;
}
for (ix = 0; ix < mn; ix++) {
if (tau->data[ix] != 0.0) {
xnorm = B->data[ix];
i51 = A->size[0] + (int32_T)(1.0 - ((1.0 + (real_T)ix) + 1.0));
emlrtForLoopVectorCheckR2012b((1.0 + (real_T)ix) + 1.0, 1.0, A->size[0],
mxDOUBLE_CLASS, i51, &ac_emlrtRTEI, sp);
for (i = 0; i < i51; i++) {
unnamed_idx_0 = ((uint32_T)ix + i) + 2U;
xnorm += b_A->data[((int32_T)unnamed_idx_0 + b_A->size[0] * ix) - 1] *
B->data[(int32_T)unnamed_idx_0 - 1];
}
xnorm *= tau->data[ix];
if (xnorm != 0.0) {
B->data[ix] -= xnorm;
i51 = A->size[0] + (int32_T)(1.0 - ((1.0 + (real_T)ix) + 1.0));
emlrtForLoopVectorCheckR2012b((1.0 + (real_T)ix) + 1.0, 1.0, A->size[0],
mxDOUBLE_CLASS, i51, &yb_emlrtRTEI, sp);
for (i = 0; i < i51; i++) {
unnamed_idx_0 = ((uint32_T)ix + i) + 2U;
B->data[(int32_T)unnamed_idx_0 - 1] -= b_A->data[((int32_T)
unnamed_idx_0 + b_A->size[0] * ix) - 1] * xnorm;
}
}
}
}
emxFree_real_T(&tau);
emlrtForLoopVectorCheckR2012b(1.0, 1.0, atmp, mxDOUBLE_CLASS, (int32_T)atmp,
&xb_emlrtRTEI, sp);
for (i = 0; i < (int32_T)atmp; i++) {
Y->data[jpvt->data[i] - 1] = B->data[i];
}
emlrtForLoopVectorCheckR2012b(atmp, -1.0, 1.0, mxDOUBLE_CLASS, (int32_T)-(1.0
+ (-1.0 - atmp)), &wb_emlrtRTEI, sp);
for (ix = 0; ix < (int32_T)-(1.0 + (-1.0 - atmp)); ix++) {
xnorm = atmp + -(real_T)ix;
Y->data[jpvt->data[(int32_T)xnorm - 1] - 1] = eml_div(Y->data[jpvt->data
[(int32_T)xnorm - 1] - 1], b_A->data[((int32_T)xnorm + b_A->size[0] *
((int32_T)xnorm - 1)) - 1]);
for (i = 0; i < (int32_T)(xnorm - 1.0); i++) {
Y->data[jpvt->data[i] - 1] -= Y->data[jpvt->data[(int32_T)xnorm - 1] - 1] *
b_A->data[i + b_A->size[0] * ((int32_T)xnorm - 1)];
}
}
emxFree_int32_T(&jpvt);
emxFree_real_T(&work);
emxFree_real_T(&b_A);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
}
void reportSDRuStatus(const emlrtStack *sp, UsrpErrorCapiEnumT errStatus, const
char_T errMsg_data[], const int32_T errMsg_size[2])
{
const mxArray *y;
static const int32_T iv16[2] = { 1, 35 };
const mxArray *m7;
char_T cv31[35];
int32_T i;
static const char_T cv32[35] = { 's', 'd', 'r', 'u', ':', 'r', 'e', 'p', 'o',
'r', 't', 'S', 'D', 'R', 'u', 'S', 't', 'a', 't', 'u', 's', ':', 'N', 'o',
't', 'C', 'o', 'm', 'p', 'a', 't', 'i', 'b', 'l', 'e' };
const mxArray *b_y;
static const int32_T iv17[2] = { 1, 12 };
char_T cv33[12];
static const char_T cv34[12] = { '1', '9', '2', '.', '1', '6', '8', '.', '1',
'0', '.', '2' };
const mxArray *c_y;
static const int32_T iv18[2] = { 1, 43 };
char_T cv35[43];
static const char_T cv36[43] = { 'r', 'e', 't', 'u', 'r', 'n', 'e', 'd', ' ',
'b', 'y', ' ', '\'', 'g', 'e', 't', 'S', 'D', 'R', 'u', 'D', 'r', 'i', 'v',
'e', 'r', 'V', 'e', 'r', 's', 'i', 'o', 'n', '\'', ' ', 'f', 'u', 'n', 'c',
't', 'i', 'o', 'n' };
const mxArray *d_y;
static const int32_T iv19[2] = { 1, 35 };
static const char_T cv37[35] = { 's', 'd', 'r', 'u', ':', 'r', 'e', 'p', 'o',
'r', 't', 'S', 'D', 'R', 'u', 'S', 't', 'a', 't', 'u', 's', ':', 'N', 'o',
't', 'R', 'e', 's', 'p', 'o', 'n', 'd', 'i', 'n', 'g' };
const mxArray *e_y;
static const int32_T iv20[2] = { 1, 12 };
const mxArray *f_y;
static const int32_T iv21[2] = { 1, 28 };
char_T cv38[28];
static const char_T cv39[28] = { 's', 'd', 'r', 'u', ':', 'r', 'e', 'p', 'o',
'r', 't', 'S', 'D', 'R', 'u', 'S', 't', 'a', 't', 'u', 's', ':', 'R', 'x',
'B', 'u', 's', 'y' };
const mxArray *g_y;
static const int32_T iv22[2] = { 1, 12 };
const mxArray *h_y;
static const int32_T iv23[2] = { 1, 28 };
static const char_T cv40[28] = { 's', 'd', 'r', 'u', ':', 'r', 'e', 'p', 'o',
'r', 't', 'S', 'D', 'R', 'u', 'S', 't', 'a', 't', 'u', 's', ':', 'T', 'x',
'B', 'u', 's', 'y' };
const mxArray *i_y;
static const int32_T iv24[2] = { 1, 12 };
const mxArray *j_y;
static const int32_T iv25[2] = { 1, 26 };
char_T cv41[26];
static const char_T cv42[26] = { 's', 'd', 'r', 'u', ':', 'r', 'e', 'p', 'o',
'r', 't', 'S', 'D', 'R', 'u', 'S', 't', 'a', 't', 'u', 's', ':', 'B', 'u',
's', 'y' };
const mxArray *k_y;
static const int32_T iv26[2] = { 1, 12 };
const mxArray *l_y;
static const int32_T iv27[2] = { 1, 35 };
static const char_T cv43[35] = { 's', 'd', 'r', 'u', ':', 'r', 'e', 'p', 'o',
'r', 't', 'S', 'D', 'R', 'u', 'S', 't', 'a', 't', 'u', 's', ':', 'U', 'n',
'k', 'n', 'o', 'w', 'n', 'S', 't', 'a', 't', 'u', 's' };
int32_T u_size[2];
int32_T i10;
char_T u_data[1024];
const mxArray *m_y;
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
/* reportSDRuStatus SDRu status reporter */
/* reportSDRuStatus(STATUS,MSG,IP,METHOD) reports the SDRu status based on */
/* the STATUS input. STATUS is a UsrpErrorCapiEnumT type. IP is the IP */
/* address of the USRP(R) radio. METHOD is a UsrpReportMethodEnumT type and */
/* can be Warning, Error , or None. */
/* */
/* USRP(R) is a trademark of National Instruments Corp. */
/* Copyright 2012-2014 The MathWorks, Inc. */
switch (errStatus) {
case UsrpDriverNotCompatible:
st.site = &ib_emlrtRSI;
if (!(errStatus == UsrpDriverNotCompatible)) {
} else {
y = NULL;
m7 = emlrtCreateCharArray(2, iv16);
for (i = 0; i < 35; i++) {
cv31[i] = cv32[i];
}
emlrtInitCharArrayR2013a(&st, 35, m7, cv31);
emlrtAssign(&y, m7);
b_y = NULL;
m7 = emlrtCreateCharArray(2, iv17);
for (i = 0; i < 12; i++) {
cv33[i] = cv34[i];
}
emlrtInitCharArrayR2013a(&st, 12, m7, cv33);
emlrtAssign(&b_y, m7);
c_y = NULL;
m7 = emlrtCreateCharArray(2, iv18);
for (i = 0; i < 43; i++) {
cv35[i] = cv36[i];
}
emlrtInitCharArrayR2013a(&st, 43, m7, cv35);
emlrtAssign(&c_y, m7);
b_st.site = &pb_emlrtRSI;
c_error(&b_st, b_message(&b_st, y, b_y, c_y, &c_emlrtMCI), &c_emlrtMCI);
}
break;
case UsrpDriverNotResponding:
st.site = &hb_emlrtRSI;
if (!(errStatus == UsrpDriverNotResponding)) {
} else {
d_y = NULL;
m7 = emlrtCreateCharArray(2, iv19);
for (i = 0; i < 35; i++) {
cv31[i] = cv37[i];
}
emlrtInitCharArrayR2013a(&st, 35, m7, cv31);
emlrtAssign(&d_y, m7);
e_y = NULL;
m7 = emlrtCreateCharArray(2, iv20);
for (i = 0; i < 12; i++) {
cv33[i] = cv34[i];
}
emlrtInitCharArrayR2013a(&st, 12, m7, cv33);
emlrtAssign(&e_y, m7);
b_st.site = &pb_emlrtRSI;
c_error(&b_st, message(&b_st, d_y, e_y, &c_emlrtMCI), &c_emlrtMCI);
}
break;
case UsrpDriverRxBusy:
st.site = &gb_emlrtRSI;
if (!(errStatus == UsrpDriverRxBusy)) {
} else {
f_y = NULL;
m7 = emlrtCreateCharArray(2, iv21);
for (i = 0; i < 28; i++) {
cv38[i] = cv39[i];
}
emlrtInitCharArrayR2013a(&st, 28, m7, cv38);
emlrtAssign(&f_y, m7);
g_y = NULL;
m7 = emlrtCreateCharArray(2, iv22);
for (i = 0; i < 12; i++) {
cv33[i] = cv34[i];
}
emlrtInitCharArrayR2013a(&st, 12, m7, cv33);
emlrtAssign(&g_y, m7);
b_st.site = &pb_emlrtRSI;
c_error(&b_st, message(&b_st, f_y, g_y, &c_emlrtMCI), &c_emlrtMCI);
}
break;
case UsrpDriverTxBusy:
st.site = &fb_emlrtRSI;
if (!(errStatus == UsrpDriverTxBusy)) {
} else {
h_y = NULL;
m7 = emlrtCreateCharArray(2, iv23);
for (i = 0; i < 28; i++) {
cv38[i] = cv40[i];
}
emlrtInitCharArrayR2013a(&st, 28, m7, cv38);
emlrtAssign(&h_y, m7);
i_y = NULL;
m7 = emlrtCreateCharArray(2, iv24);
for (i = 0; i < 12; i++) {
cv33[i] = cv34[i];
}
emlrtInitCharArrayR2013a(&st, 12, m7, cv33);
emlrtAssign(&i_y, m7);
b_st.site = &pb_emlrtRSI;
c_error(&b_st, message(&b_st, h_y, i_y, &c_emlrtMCI), &c_emlrtMCI);
}
break;
case UsrpDriverBusy:
st.site = &eb_emlrtRSI;
if (!(errStatus == UsrpDriverBusy)) {
} else {
j_y = NULL;
m7 = emlrtCreateCharArray(2, iv25);
for (i = 0; i < 26; i++) {
cv41[i] = cv42[i];
}
emlrtInitCharArrayR2013a(&st, 26, m7, cv41);
emlrtAssign(&j_y, m7);
k_y = NULL;
m7 = emlrtCreateCharArray(2, iv26);
for (i = 0; i < 12; i++) {
cv33[i] = cv34[i];
}
emlrtInitCharArrayR2013a(&st, 12, m7, cv33);
emlrtAssign(&k_y, m7);
b_st.site = &pb_emlrtRSI;
c_error(&b_st, message(&b_st, j_y, k_y, &c_emlrtMCI), &c_emlrtMCI);
}
break;
case UsrpDriverError:
st.site = &db_emlrtRSI;
if (!(errStatus == UsrpDriverError)) {
} else {
l_y = NULL;
m7 = emlrtCreateCharArray(2, iv27);
for (i = 0; i < 35; i++) {
cv31[i] = cv43[i];
}
emlrtInitCharArrayR2013a(&st, 35, m7, cv31);
emlrtAssign(&l_y, m7);
u_size[0] = 1;
u_size[1] = errMsg_size[1];
i = errMsg_size[0] * errMsg_size[1];
for (i10 = 0; i10 < i; i10++) {
u_data[i10] = errMsg_data[i10];
}
m_y = NULL;
m7 = emlrtCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(&st, u_size[1], m7, (char_T *)u_data);
emlrtAssign(&m_y, m7);
b_st.site = &pb_emlrtRSI;
c_error(&b_st, message(&b_st, l_y, m_y, &c_emlrtMCI), &c_emlrtMCI);
}
break;
}
}
/* Function Definitions */
boolean_T all(const emlrtStack *sp, const emxArray_boolean_T *x)
{
boolean_T y;
boolean_T overflow;
const mxArray *b_y;
static const int32_T iv20[2] = { 1, 51 };
const mxArray *m7;
char_T cv22[51];
int32_T i;
static const char_T cv23[51] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
'l', 'b', 'o', 'x', ':', 'e', 'm', 'l', '_', 'a', 'l', 'l', '_', 'o', 'r',
'_', 'a', 'n', 'y', '_', 'a', 'u', 't', 'o', 'D', 'i', 'm', 'I', 'n', 'c',
'o', 'm', 'p', 'a', 't', 'i', 'b', 'i', 'l', 'i', 't', 'y' };
boolean_T exitg1;
int32_T i66;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
st.prev = sp;
st.tls = sp->tls;
st.site = &ve_emlrtRSI;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
b_st.site = &we_emlrtRSI;
if ((x->size[1] == 1) || (x->size[1] != 1)) {
overflow = true;
} else {
overflow = false;
}
b_st.site = &xe_emlrtRSI;
if (overflow) {
} else {
b_y = NULL;
m7 = emlrtCreateCharArray(2, iv20);
for (i = 0; i < 51; i++) {
cv22[i] = cv23[i];
}
emlrtInitCharArrayR2013a(&b_st, 51, m7, cv22);
emlrtAssign(&b_y, m7);
c_st.site = &dh_emlrtRSI;
b_error(&c_st, message(&c_st, b_y, &n_emlrtMCI), &n_emlrtMCI);
}
y = true;
b_st.site = &ye_emlrtRSI;
if (1 > x->size[1]) {
overflow = false;
} else {
overflow = (x->size[1] > 2147483646);
}
if (overflow) {
c_st.site = &ic_emlrtRSI;
check_forloop_overflow_error(&c_st);
}
i = 1;
exitg1 = false;
while ((!exitg1) && (i <= x->size[1])) {
i66 = x->size[1];
if (x->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i66, &re_emlrtBCI, &st)
- 1] == 0) {
y = false;
exitg1 = true;
} else {
i++;
}
}
return y;
}
void b_mpower(const emlrtStack *sp, const real_T a[36], real_T c[36])
{
real_T x[36];
int32_T jBcol;
int32_T ipiv[6];
int8_T p[6];
int32_T k;
int32_T j;
int32_T i;
int32_T kAcol;
real_T n1x;
real_T n1xinv;
real_T rc;
static const char_T rfmt[6] = { '%', '1', '4', '.', '6', 'e' };
char_T u[6];
const mxArray *y;
static const int32_T iv4[2] = { 1, 6 };
const mxArray *m0;
const mxArray *b_y;
char_T cv0[14];
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
emlrtStack e_st;
emlrtStack f_st;
st.prev = sp;
st.tls = sp->tls;
st.site = &l_emlrtRSI;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &c_st;
d_st.tls = c_st.tls;
e_st.prev = &d_st;
e_st.tls = d_st.tls;
f_st.prev = &e_st;
f_st.tls = e_st.tls;
b_st.site = &m_emlrtRSI;
c_st.site = &n_emlrtRSI;
c_st.site = &o_emlrtRSI;
d_st.site = &p_emlrtRSI;
for (jBcol = 0; jBcol < 36; jBcol++) {
c[jBcol] = 0.0;
x[jBcol] = a[jBcol];
}
e_st.site = &r_emlrtRSI;
xgetrf(&e_st, x, ipiv);
for (jBcol = 0; jBcol < 6; jBcol++) {
p[jBcol] = (int8_T)(1 + jBcol);
}
for (k = 0; k < 5; k++) {
if (ipiv[k] > 1 + k) {
jBcol = p[ipiv[k] - 1];
p[ipiv[k] - 1] = p[k];
p[k] = (int8_T)jBcol;
}
}
for (k = 0; k < 6; k++) {
jBcol = p[k] - 1;
c[k + 6 * (p[k] - 1)] = 1.0;
e_st.site = &s_emlrtRSI;
for (j = k; j + 1 < 7; j++) {
if (c[j + 6 * jBcol] != 0.0) {
e_st.site = &t_emlrtRSI;
for (i = j + 1; i + 1 < 7; i++) {
c[i + 6 * jBcol] -= c[j + 6 * jBcol] * x[i + 6 * j];
}
}
}
}
e_st.site = &u_emlrtRSI;
f_st.site = &ib_emlrtRSI;
for (j = 0; j < 6; j++) {
jBcol = 6 * j;
for (k = 5; k >= 0; k += -1) {
kAcol = 6 * k;
if (c[k + jBcol] != 0.0) {
c[k + jBcol] /= x[k + kAcol];
for (i = 0; i + 1 <= k; i++) {
c[i + jBcol] -= c[k + jBcol] * x[i + kAcol];
}
}
}
}
d_st.site = &q_emlrtRSI;
n1x = norm(a);
n1xinv = norm(c);
rc = 1.0 / (n1x * n1xinv);
if ((n1x == 0.0) || (n1xinv == 0.0) || (rc == 0.0)) {
e_st.site = &kb_emlrtRSI;
warning(&e_st);
} else {
if (muDoubleScalarIsNaN(rc) || (rc < 2.2204460492503131E-16)) {
e_st.site = &lb_emlrtRSI;
for (jBcol = 0; jBcol < 6; jBcol++) {
u[jBcol] = rfmt[jBcol];
}
y = NULL;
m0 = emlrtCreateCharArray(2, iv4);
emlrtInitCharArrayR2013a(&e_st, 6, m0, &u[0]);
emlrtAssign(&y, m0);
b_y = NULL;
m0 = emlrtCreateDoubleScalar(rc);
emlrtAssign(&b_y, m0);
f_st.site = &pb_emlrtRSI;
emlrt_marshallIn(&f_st, b_sprintf(&f_st, y, b_y, &c_emlrtMCI), "sprintf",
cv0);
e_st.site = &lb_emlrtRSI;
b_warning(&e_st, cv0);
}
}
}
void drr_151213_XRayInParam(const emlrtStack *sp, const emxArray_boolean_T
*voxel_data, const real_T voxel_size_mm[3], const real_T detector_dimensions[2],
const real_T XRayIntrinsicParam[12], const real_T voxel_corner_min[3], const
real_T T_carm[16], emxArray_real_T *projection)
{
const mxArray *y;
static const int32_T iv0[2] = { 1, 32 };
const mxArray *m0;
char_T cv0[32];
int32_T i;
static const char_T cv1[32] = { 'v', 'o', 'x', 'e', 'l', '_', 'd', 'a', 't',
'a', ' ', 'm', 'u', 's', 't', ' ', 'b', 'e', ' ', '3', '-', 'd', 'i', 'm',
'e', 'n', 's', 'i', 'o', 'n', 'a', 'l' };
int32_T i0;
real_T pixel_size_mm_h;
real_T pixel_size_mm_w;
uint32_T voxDim[3];
real_T voxPlanes__max[3];
real_T source[3];
real_T pixel_size_mmel_wn[3];
real_T pixel_size_mmel_hn[3];
real_T corner[3];
int32_T ih;
int32_T iw;
real_T tstep[3];
real_T tnext[3];
real_T pixel_point_mm[3];
real_T ray_source2pixel[3];
real_T b_voxPlanes__max[3];
real_T b_ray_source2pixel[3];
real_T t_plane_min[3];
real_T t_plane_max[3];
real_T tmax;
int32_T pixel_size_mmIntensity;
boolean_T exitg8;
boolean_T exitg7;
boolean_T exitg6;
real_T t_larger[4];
real_T temp;
boolean_T exitg5;
boolean_T exitg4;
boolean_T exitg3;
real_T t_smaller[4];
int32_T itmp;
boolean_T exitg2;
boolean_T exitg1;
real_T iz;
real_T tx;
real_T ty;
real_T tz;
int32_T i1;
int32_T i2;
int32_T i3;
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
/* % Modificiation Notes */
/* 15.12.04 */
/* - Release 기존의 파일을 참고로 하여 고성영이 수정하였음. */
/* - DRR을 완벽하게 하지 않고, voxel에 한점이라도 만나면 on으로 계산함 */
/* - 계산속도가 향상되었음 */
/* - 젬스에 있는 X-ray와 테스트하여 검증하였음 */
/* 15 12 13 : The function input has been changed to utilize the x-ray */
/* intrinsic parameter provided by GEMSS % 151213 kosy */
/* %function [projection] = drr (voxel_data, voxel_size_mm, detector_dimensions, pixel_size_mm, isocenter_mm, cbct_angles_deg) */
/* Creates a 2D projection at each cbct_angle of voxel_data. the projection */
/* axis is defined by the isocenter to which the source and center of */
/* the detector are aligned. This simulation assumes standard Cone Beam CT */
/* geometry (source to isocenter distance is 100 cm and source to detector */
/* distance is 150cm). */
/* */
/* voxel_data: must be a 3 dimensional matrix (typically of CT data) */
/* voxel_size_mm: a 3 element vector listing the size (in mm) of the voxels */
/* along each dimension */
/* detector_dimension: a 2 element vector listing the dimensions (number of */
/* pixels) in each dimension (u,v) */
/* pixel_size_mm: a number defining the height and width of each pixel */
/* (assumes square pixel) */
/* isocenter_mm: a 3 element vector pointing from the origin (corner) of the */
/* matrix element(1,1,1) to the isocenter */
/* cbct_angles_deg: a list of angles to generate projections */
/* */
/* Retrun Variable */
/* projection: a 3D matrix with the 3rd dimension representing the angle of */
/* roatation */
/* */
/* { */
/* Author: Michael M. Folkerts [email protected] */
/* Institution: UCSD Physics, UTSW Radiation Oncology */
/* Updated: 2014-July. */
/* Notes: Siddon's Incremental algorithm | modified to read in 3D matlab matrix | Simplified Input | No guarantees!! */
/* */
/* References: */
/* R.L. Siddon, */
/* "Fast calculation of the exact radiological path for a three-dimensional CT */
/* array," Medical Physics 12, 252-255 (1985). */
/* */
/* F. Jacobs, E. Sundermann, B. De Sutter, M. Christiaens and I. Lemahieu, */
/* "A fast algorithm to calculate the exact radiological path through a pixel_size_mmel or voxel space," */
/* Journal of Computing and Information Technology 6, 89-94 (1998). */
/* */
/* G. Han, Z. Liang and J. You, */
/* "A fast ray tracing technique for TCT and ECT studies," */
/* IEEE Medical Imaging Conference 1999. */
/* } */
/* function [projection] = drr_good_151204 (voxel_data, voxel_size_mm, detector_dimensions, pixel_size_mm, voxel_corner_min, T_carm) */
/* if(0) */
/* voxel_data = OUTPUTgrid; */
/* voxel_size_mm = voxel_size; */
/* detector_dimensions = detector_dimension; */
/* pixel_size_mm = pixel_size; */
/* isocenter_mm = isocenter; */
/* T_carm: Transformation matrix of C-arm (that is set at the middle of */
/* detector & source) with respect to Voxel coordinates */
/* tic; */
/* this will verify the size: */
if (eml_ndims_varsized(*(int32_T (*)[3])voxel_data->size) != 3) {
st.site = &emlrtRSI;
y = NULL;
m0 = emlrtCreateCharArray(2, iv0);
for (i = 0; i < 32; i++) {
cv0[i] = cv1[i];
}
emlrtInitCharArrayR2013a(&st, 32, m0, cv0);
emlrtAssign(&y, m0);
b_st.site = &b_emlrtRSI;
error(&b_st, y, &emlrtMCI);
}
/* constants: */
/* .0001; */
/* .0001; */
/* sounce to imager(detector) distance */
/* source to axis distance %% RRI set the coordinate at the middle between source and the detector */
/* initialize memory for speed: */
i0 = projection->size[0] * projection->size[1];
pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[0],
&b_emlrtDCI, sp);
projection->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&emlrtDCI, sp);
pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[1],
&d_emlrtDCI, sp);
projection->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&c_emlrtDCI, sp);
emxEnsureCapacity(sp, (emxArray__common *)projection, i0, (int32_T)sizeof
(real_T), &emlrtRTEI);
pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[0],
&b_emlrtDCI, sp);
pixel_size_mm_w = emlrtNonNegativeCheckFastR2012b(detector_dimensions[1],
&d_emlrtDCI, sp);
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h, &emlrtDCI, sp) *
(int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w, &c_emlrtDCI, sp);
for (i0 = 0; i0 < i; i0++) {
projection->data[i0] = 0.0;
}
for (i0 = 0; i0 < 3; i0++) {
voxDim[i0] = (uint32_T)voxel_data->size[i0];
}
/* [size(voxel_data,1), size(voxel_data,2), size(voxel_data,3)]; */
/* voxDim_x = voxDim(1); */
/* voxDim_y = voxDim(2); */
/* voxDim_z = voxDim(3); */
/* difine voxel boundaries: */
/* vector from origin to source */
/* vector from origin to CENTER of detector */
/* extract the key information from the intrinsic parameters % 151213 kosy modi */
pixel_size_mm_h = 1105.0 / XRayIntrinsicParam[0];
pixel_size_mm_w = 1105.0 / XRayIntrinsicParam[4];
/* vector pointing left, parallel to detector */
/* define incremental vectors: */
/* define upper lefthand corner of detector: */
/* corner = detector + ( center_pixel_w*pixel_size_mmel.wn + center_pixel_h*pixel_size_mmel.hn ); */
for (i = 0; i < 3; i++) {
voxPlanes__max[i] = voxel_corner_min[i] + voxel_size_mm[i] * (real_T)
voxDim[i];
/* define up: */
/* up = [0,0,1]; */
/* width of projection image */
/* height of projection image */
/* direction from the detector to the source */
/* end initialization timer: */
/* init_time = toc */
/* start tracing timer: */
/* tic; */
source[i] = 552.5 * T_carm[4 + i] + T_carm[12 + i];
/* define pixel_size_mmel vectors: */
/* length of pixel_size_mmel */
pixel_size_mmel_wn[i] = -pixel_size_mm_w * T_carm[i];
pixel_size_mmel_hn[i] = -pixel_size_mm_h * T_carm[8 + i];
corner[i] = (-552.5 * T_carm[4 + i] + T_carm[12 + i]) +
(detector_dimensions[0] * (pixel_size_mm_w * T_carm[i]) +
detector_dimensions[1] * (pixel_size_mm_h * T_carm[8 + i])) / 2.0;
}
emlrtForLoopVectorCheckR2012b(1.0, 1.0, detector_dimensions[0], mxDOUBLE_CLASS,
(int32_T)detector_dimensions[0], &d_emlrtRTEI,
sp);
ih = 1;
while (ih - 1 <= (int32_T)detector_dimensions[0] - 1) {
/* if(mod(ih,100)==0),fprintf('height:\t%i...\n',ih);end */
emlrtForLoopVectorCheckR2012b(1.0, 1.0, detector_dimensions[1],
mxDOUBLE_CLASS, (int32_T)detector_dimensions[1], &c_emlrtRTEI, sp);
iw = 1;
while (iw - 1 <= (int32_T)detector_dimensions[1] - 1) {
/* pixel_point_mm = corner + (ih-1)*pixel_size_mmel.hp + (iw-1)*pixel_size_mmel.wp; %ray end point */
/* ray to be traced */
/* find parametrized (t) voxel plane (min or max) intersections: */
/* PLANE = P1 + t(P2-P1) */
/* SK added */
/* t_x = (i-x1) / (x2-x1), t_y = (j-y1) / (y2-y1), t_z = (k-z1) / (z2-z1) */
for (i = 0; i < 3; i++) {
pixel_size_mm_h = (corner[i] + ((1.0 + (real_T)(ih - 1)) - 1.0) *
pixel_size_mmel_hn[i]) + ((1.0 + (real_T)(iw - 1)) -
1.0) * pixel_size_mmel_wn[i];
/* ray end point */
pixel_size_mm_w = pixel_size_mm_h - source[i];
tstep[i] = voxel_corner_min[i] - source[i];
tnext[i] = pixel_size_mm_w + 2.2250738585072014E-308;
b_voxPlanes__max[i] = voxPlanes__max[i] - source[i];
b_ray_source2pixel[i] = pixel_size_mm_w + 2.2250738585072014E-308;
pixel_point_mm[i] = pixel_size_mm_h;
ray_source2pixel[i] = pixel_size_mm_w;
}
rdivide(tstep, tnext, t_plane_min);
rdivide(b_voxPlanes__max, b_ray_source2pixel, t_plane_max);
/* compute (parametric) intersection values */
/* tmin = max { min{tx(0), tx(Nx)}, min{ty(0), ty(Ny)], min{tz(0), tz(Nz)}, 0.0 } */
/* tmax = min { max{tx(0), tx(Nx)}, max{ty(0), ty(Ny)], max{tz(0), tz(Nz)}, 1.0 } */
/* t_larger = [ max([t_plane_min(1), t_plane_max(1)]), max([t_plane_min(2), t_plane_max(2)]), max([t_plane_min(3), t_plane_max(3)]), 1.0 ]; */
/* t_smaller = [ min([t_plane_min(1), t_plane_max(1)]), min([t_plane_min(2), t_plane_max(2)]), min([t_plane_min(3), t_plane_max(3)]), 0.0 ]; */
i = 1;
tmax = t_plane_min[0];
if (muDoubleScalarIsNaN(t_plane_min[0])) {
pixel_size_mmIntensity = 2;
exitg8 = false;
while ((!exitg8) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[0])) {
tmax = t_plane_max[0];
exitg8 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[0] > tmax)) {
tmax = t_plane_max[0];
}
i = 1;
pixel_size_mm_h = t_plane_min[1];
if (muDoubleScalarIsNaN(t_plane_min[1])) {
pixel_size_mmIntensity = 2;
exitg7 = false;
while ((!exitg7) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[1])) {
pixel_size_mm_h = t_plane_max[1];
exitg7 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[1] > pixel_size_mm_h)) {
pixel_size_mm_h = t_plane_max[1];
}
i = 1;
pixel_size_mm_w = t_plane_min[2];
if (muDoubleScalarIsNaN(t_plane_min[2])) {
pixel_size_mmIntensity = 2;
exitg6 = false;
while ((!exitg6) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[2])) {
pixel_size_mm_w = t_plane_max[2];
exitg6 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[2] > pixel_size_mm_w)) {
pixel_size_mm_w = t_plane_max[2];
}
t_larger[0] = tmax;
t_larger[1] = pixel_size_mm_h;
t_larger[2] = pixel_size_mm_w;
t_larger[3] = 1.0;
i = 1;
temp = t_plane_min[0];
if (muDoubleScalarIsNaN(t_plane_min[0])) {
pixel_size_mmIntensity = 2;
exitg5 = false;
while ((!exitg5) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[0])) {
temp = t_plane_max[0];
exitg5 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[0] < temp)) {
temp = t_plane_max[0];
}
i = 1;
pixel_size_mm_h = t_plane_min[1];
if (muDoubleScalarIsNaN(t_plane_min[1])) {
pixel_size_mmIntensity = 2;
exitg4 = false;
while ((!exitg4) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[1])) {
pixel_size_mm_h = t_plane_max[1];
exitg4 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[1] < pixel_size_mm_h)) {
pixel_size_mm_h = t_plane_max[1];
}
i = 1;
pixel_size_mm_w = t_plane_min[2];
if (muDoubleScalarIsNaN(t_plane_min[2])) {
pixel_size_mmIntensity = 2;
exitg3 = false;
while ((!exitg3) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[2])) {
pixel_size_mm_w = t_plane_max[2];
exitg3 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[2] < pixel_size_mm_w)) {
pixel_size_mm_w = t_plane_max[2];
}
t_smaller[0] = temp;
t_smaller[1] = pixel_size_mm_h;
t_smaller[2] = pixel_size_mm_w;
t_smaller[3] = 0.0;
i = 1;
itmp = 0;
if (muDoubleScalarIsNaN(temp)) {
pixel_size_mmIntensity = 1;
exitg2 = false;
while ((!exitg2) && (pixel_size_mmIntensity + 1 < 5)) {
i = pixel_size_mmIntensity + 1;
if (!muDoubleScalarIsNaN(t_smaller[pixel_size_mmIntensity])) {
temp = t_smaller[pixel_size_mmIntensity];
itmp = pixel_size_mmIntensity;
exitg2 = true;
} else {
pixel_size_mmIntensity++;
}
}
}
if (i < 4) {
while (i + 1 < 5) {
if (t_smaller[i] > temp) {
temp = t_smaller[i];
itmp = i;
}
i++;
}
}
i = 1;
if (muDoubleScalarIsNaN(tmax)) {
pixel_size_mmIntensity = 2;
exitg1 = false;
while ((!exitg1) && (pixel_size_mmIntensity < 5)) {
i = pixel_size_mmIntensity;
if (!muDoubleScalarIsNaN(t_larger[pixel_size_mmIntensity - 1])) {
tmax = t_larger[pixel_size_mmIntensity - 1];
exitg1 = true;
} else {
pixel_size_mmIntensity++;
}
}
}
if (i < 4) {
while (i + 1 < 5) {
if (t_larger[i] < tmax) {
tmax = t_larger[i];
}
i++;
}
}
for (i0 = 0; i0 < 3; i0++) {
pixel_point_mm[i0] = (real_T)(pixel_point_mm[i0] < source[i0]) * -2.0 +
1.0;
}
if (temp < tmax) {
/* if ray intersects volume */
/* find index for each dimension: */
for (i = 0; i < 3; i++) {
pixel_size_mm_h = muDoubleScalarFloor((((ray_source2pixel[i] * temp +
source[i]) - voxel_corner_min[i]) + 2.2250738585072014E-308) /
voxel_size_mm[i]);
/* (parametric) intersection values... */
/* makes 0 or 1 */
tnext[i] = (voxel_corner_min[i] + ((pixel_size_mm_h +
(pixel_point_mm[i] + 1.0) / 2.0) * voxel_size_mm[i] - source[i])) /
(ray_source2pixel[i] + 2.2250738585072014E-308);
/* parametric value for next plane intersection */
tstep[i] = muDoubleScalarAbs(voxel_size_mm[i] / (ray_source2pixel[i] +
2.2250738585072014E-308));
t_plane_min[i] = pixel_size_mm_h;
}
/* parametric step size */
/* address special cases... */
if (temp == t_plane_max[emlrtDynamicBoundsCheckFastR2012b(itmp + 1, 1, 3,
&c_emlrtBCI, sp) - 1]) {
/* if intersection is a "max" plane */
t_plane_min[itmp] = (real_T)voxDim[itmp] - 1.0;
tnext[itmp] = temp + tstep[itmp];
/* next plane crossing */
} else {
t_plane_min[itmp] = 0.0;
tnext[itmp] = temp + tstep[itmp];
/* next plane crossing */
}
/* voxel index values(add one for matlab): */
pixel_size_mm_h = t_plane_min[0] + 1.0;
pixel_size_mm_w = t_plane_min[1] + 1.0;
iz = t_plane_min[2] + 1.0;
tx = tnext[0];
ty = tnext[1];
tz = tnext[2];
pixel_size_mmIntensity = 0;
/* uncomment to generate P-matrix: */
/* pixel_size_mmNum = 1; */
/* len = norm(ray_source2pixel); % ray length */
while ((temp + 0.0001 < tmax) && (!(pixel_size_mm_h * pixel_size_mm_w *
iz == 0.0))) {
if ((tx < ty) && (tx < tz)) {
/* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */
i0 = voxel_data->size[0];
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&k_emlrtDCI, sp);
itmp = voxel_data->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w,
&l_emlrtDCI, sp);
i2 = voxel_data->size[2];
i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &m_emlrtDCI, sp);
if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0,
&j_emlrtBCI, sp) + voxel_data->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(i1, 1,
itmp, &k_emlrtBCI, sp) - 1)) + voxel_data->size[0] *
voxel_data->size[1] *
(emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2,
&l_emlrtBCI, sp) - 1)) - 1]) {
pixel_size_mmIntensity = 255;
tmax = rtMinusInf;
}
temp = tx;
tx += tstep[0];
pixel_size_mm_h += pixel_point_mm[0];
} else if (ty < tz) {
/* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */
i0 = voxel_data->size[0];
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&h_emlrtDCI, sp);
itmp = voxel_data->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w,
&i_emlrtDCI, sp);
i2 = voxel_data->size[2];
i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &j_emlrtDCI, sp);
if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0,
&g_emlrtBCI, sp) + voxel_data->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(i1, 1,
itmp, &h_emlrtBCI, sp) - 1)) + voxel_data->size[0] *
voxel_data->size[1] *
(emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2,
&i_emlrtBCI, sp) - 1)) - 1]) {
pixel_size_mmIntensity = 255;
tmax = rtMinusInf;
}
temp = ty;
ty += tstep[1];
pixel_size_mm_w += pixel_point_mm[1];
} else {
/* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */
i0 = voxel_data->size[0];
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&e_emlrtDCI, sp);
itmp = voxel_data->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w,
&f_emlrtDCI, sp);
i2 = voxel_data->size[2];
i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &g_emlrtDCI, sp);
if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0,
&d_emlrtBCI, sp) + voxel_data->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(i1, 1,
itmp, &e_emlrtBCI, sp) - 1)) + voxel_data->size[0] *
voxel_data->size[1] *
(emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2,
&f_emlrtBCI, sp) - 1)) - 1]) {
pixel_size_mmIntensity = 255;
tmax = rtMinusInf;
}
temp = tz;
tz += tstep[2];
iz += pixel_point_mm[2];
}
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* end while */
i0 = projection->size[0];
i = projection->size[1];
projection->data[(emlrtDynamicBoundsCheckFastR2012b(ih, 1, i0,
&m_emlrtBCI, sp) + projection->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(iw, 1, i,
&n_emlrtBCI, sp) - 1)) - 1] = pixel_size_mmIntensity;
} else {
/* if no intersections */
i0 = projection->size[0];
i = projection->size[1];
projection->data[(emlrtDynamicBoundsCheckFastR2012b(ih, 1, i0, &emlrtBCI,
sp) + projection->size[0] * (emlrtDynamicBoundsCheckFastR2012b(iw, 1,
i, &b_emlrtBCI, sp) - 1)) - 1] = 0.0;
}
/* if intersections */
/* uncomment to generate P-matrix: */
/* rayCount = rayCount + 1; */
iw++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* width */
/* fprintf('\n'); */
ih++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* height */
/* uncomment to generate P-matrix: */
/* matrix = matrix(1:mtxCount-1,:); */
/* stop trace timer: */
/* trace_time = toc */
/* fprintf('\n') */
/* function */
/* } */
}
/* Function Definitions */
void reportDrivers(const emlrtStack *sp, char_T flatAddrList_data[], int32_T
flatAddrList_size[2])
{
int32_T i20;
static const char_T cv21[6] = { 's', 'i', 'l', 'e', 'n', 't' };
char_T u[6];
const mxArray *y;
static const int32_T iv14[2] = { 1, 6 };
const mxArray *m7;
char_T errStr_data[1024];
UsrpErrorCapiEnumT errStat_i;
int32_T flatAddrListSize;
int32_T errStrSize;
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
/* Copyright 2011-2012 The MathWorks, Inc. */
st.site = &cb_emlrtRSI;
/* */
/* This function unifies handling of interp vs. codegen call as well as */
/* errStat / errStr assignment. */
/* */
/* Copyright 2011-2015 The MathWorks, Inc. */
if (!isSetupsdruCalled) {
for (i20 = 0; i20 < 6; i20++) {
u[i20] = cv21[i20];
}
y = NULL;
m7 = emlrtCreateCharArray(2, iv14);
emlrtInitCharArrayR2013a(&st, 6, m7, &u[0]);
emlrtAssign(&y, m7);
b_st.site = &eb_emlrtRSI;
setupsdru(&b_st, sdruroot(&b_st, &c_emlrtMCI), y, &d_emlrtMCI);
isSetupsdruCalled = true;
}
/* These sizes must match those in C code. */
/* Arbitrary max imposed on ML/SL side */
/* function is being called in interpreted mode */
/* not being found: */
/* eml_allow_enum_inputs; */
/* errStat_i = int32(0); */
memset(&errStr_data[0], 0, sizeof(char_T) << 10);
flatAddrList_size[0] = 1;
memset(&flatAddrList_data[0], 0, sizeof(char_T) << 7);
reportDrivers_c(&flatAddrList_data[0], &errStat_i, &errStr_data[0]);
flatAddrListSize = strlen(&flatAddrList_data[0]);
if (flatAddrListSize <= 128) {
} else {
emlrtErrorWithMessageIdR2012b(&st, &k_emlrtRTEI,
"Coder:builtins:AssertionFailed", 0);
}
if (1 > flatAddrListSize) {
flatAddrList_size[1] = 0;
} else {
flatAddrList_size[1] = flatAddrListSize;
}
/* errStat = UsrpErrorCapiEnumT(errStat_i); */
errStrSize = strlen(&errStr_data[0]);
if (errStrSize <= 1024) {
} else {
emlrtErrorWithMessageIdR2012b(&st, &d_emlrtRTEI,
"Coder:builtins:AssertionFailed", 0);
}
}
void mldivide(const emlrtStack *sp, const emxArray_real_T *A, const
emxArray_real_T *B, emxArray_real_T *Y)
{
const mxArray *y;
static const int32_T iv77[2] = { 1, 21 };
const mxArray *m13;
char_T cv74[21];
int32_T i;
static const char_T cv75[21] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'd', 'i', 'm', 'a', 'g', 'r', 'e', 'e' };
emxArray_real_T *b_B;
emxArray_real_T *r17;
uint32_T unnamed_idx_0;
int32_T loop_ub;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
if (B->size[0] == A->size[0]) {
} else {
y = NULL;
m13 = emlrtCreateCharArray(2, iv77);
for (i = 0; i < 21; i++) {
cv74[i] = cv75[i];
}
emlrtInitCharArrayR2013a(sp, 21, m13, cv74);
emlrtAssign(&y, m13);
st.site = &xf_emlrtRSI;
error(&st, message(&st, y, &bb_emlrtMCI), &bb_emlrtMCI);
}
b_emxInit_real_T(sp, &b_B, 1, &tb_emlrtRTEI, true);
b_emxInit_real_T(sp, &r17, 1, &tb_emlrtRTEI, true);
if ((A->size[0] == 0) || (A->size[1] == 0) || (B->size[0] == 0)) {
unnamed_idx_0 = (uint32_T)A->size[1];
i = Y->size[0];
Y->size[0] = (int32_T)unnamed_idx_0;
emxEnsureCapacity(sp, (emxArray__common *)Y, i, (int32_T)sizeof(real_T),
&tb_emlrtRTEI);
loop_ub = (int32_T)unnamed_idx_0;
for (i = 0; i < loop_ub; i++) {
Y->data[i] = 0.0;
}
} else if (A->size[0] == A->size[1]) {
i = Y->size[0];
Y->size[0] = B->size[0];
emxEnsureCapacity(sp, (emxArray__common *)Y, i, (int32_T)sizeof(real_T),
&tb_emlrtRTEI);
loop_ub = B->size[0];
for (i = 0; i < loop_ub; i++) {
Y->data[i] = B->data[i];
}
st.site = &xf_emlrtRSI;
b_eml_lusolve(&st, A, Y);
} else {
i = b_B->size[0];
b_B->size[0] = B->size[0];
emxEnsureCapacity(sp, (emxArray__common *)b_B, i, (int32_T)sizeof(real_T),
&tb_emlrtRTEI);
loop_ub = B->size[0];
for (i = 0; i < loop_ub; i++) {
b_B->data[i] = B->data[i];
}
st.site = &xf_emlrtRSI;
c_eml_qrsolve(&st, A, b_B, r17);
i = Y->size[0];
Y->size[0] = r17->size[0];
emxEnsureCapacity(sp, (emxArray__common *)Y, i, (int32_T)sizeof(real_T),
&tb_emlrtRTEI);
loop_ub = r17->size[0];
for (i = 0; i < loop_ub; i++) {
Y->data[i] = r17->data[i];
}
}
emxFree_real_T(&r17);
emxFree_real_T(&b_B);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
}
static void cgxe_mdl_terminate(InstanceStruct_UXvEHHrxIcmXaLthmwvduD
*moduleInstance)
{
dsp_SampleRateConverter_2 *obj;
int32_T i2;
static char_T cv20[45] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's',
't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e',
'd', 'W', 'h', 'e', 'n', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'd', 'C', 'o',
'd', 'e', 'g', 'e', 'n' };
char_T u[45];
const mxArray *y;
static const int32_T iv32[2] = { 1, 45 };
const mxArray *m5;
static char_T cv21[8] = { 'i', 's', 'L', 'o', 'c', 'k', 'e', 'd' };
char_T b_u[8];
const mxArray *b_y;
static const int32_T iv33[2] = { 1, 8 };
boolean_T flag;
char_T c_u[45];
const mxArray *c_y;
static const int32_T iv34[2] = { 1, 45 };
static char_T cv22[7] = { 'r', 'e', 'l', 'e', 'a', 's', 'e' };
char_T d_u[7];
const mxArray *d_y;
static const int32_T iv35[2] = { 1, 7 };
dspcodegen_FIRDecimator *b_obj;
char_T e_u[45];
const mxArray *e_y;
static const int32_T iv36[2] = { 1, 45 };
char_T f_u[7];
const mxArray *f_y;
static const int32_T iv37[2] = { 1, 7 };
dspcodegen_FIRRateConverter *c_obj;
char_T g_u[45];
const mxArray *g_y;
static const int32_T iv38[2] = { 1, 45 };
char_T h_u[7];
const mxArray *h_y;
static const int32_T iv39[2] = { 1, 7 };
if (!moduleInstance->sysobj_not_empty) {
obj = &moduleInstance->sysobj;
moduleInstance->sysobj.filt1 = NULL;
moduleInstance->sysobj.filt2 = NULL;
obj->isInitialized = 0;
obj->NumChannels = -1.0;
moduleInstance->sysobj_not_empty = true;
}
obj = &moduleInstance->sysobj;
if (moduleInstance->sysobj.isInitialized == 2) {
for (i2 = 0; i2 < 45; i2++) {
u[i2] = cv20[i2];
}
y = NULL;
m5 = emlrtCreateCharArray(2, iv32);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m5, &u[0]);
emlrtAssign(&y, m5);
for (i2 = 0; i2 < 8; i2++) {
b_u[i2] = cv21[i2];
}
b_y = NULL;
m5 = emlrtCreateCharArray(2, iv33);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 8, m5, &b_u[0]);
emlrtAssign(&b_y, m5);
error(moduleInstance, message(moduleInstance, y, b_y, &c_emlrtMCI),
&c_emlrtMCI);
}
flag = (obj->isInitialized == 1);
if (flag) {
obj = &moduleInstance->sysobj;
if (moduleInstance->sysobj.isInitialized == 2) {
for (i2 = 0; i2 < 45; i2++) {
c_u[i2] = cv20[i2];
}
c_y = NULL;
m5 = emlrtCreateCharArray(2, iv34);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m5, &c_u
[0]);
emlrtAssign(&c_y, m5);
for (i2 = 0; i2 < 7; i2++) {
d_u[i2] = cv22[i2];
}
d_y = NULL;
m5 = emlrtCreateCharArray(2, iv35);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 7, m5, &d_u[0]);
emlrtAssign(&d_y, m5);
error(moduleInstance, message(moduleInstance, c_y, d_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (obj->isInitialized == 1) {
obj->isInitialized = 2;
b_obj = obj->filt1;
if (b_obj->isInitialized == 2) {
for (i2 = 0; i2 < 45; i2++) {
e_u[i2] = cv20[i2];
}
e_y = NULL;
m5 = emlrtCreateCharArray(2, iv36);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m5,
&e_u[0]);
emlrtAssign(&e_y, m5);
for (i2 = 0; i2 < 7; i2++) {
f_u[i2] = cv22[i2];
}
f_y = NULL;
m5 = emlrtCreateCharArray(2, iv37);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 7, m5,
&f_u[0]);
emlrtAssign(&f_y, m5);
error(moduleInstance, message(moduleInstance, e_y, f_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (b_obj->isInitialized == 1) {
b_obj->isInitialized = 2;
/* System object Destructor function: dsp.FIRDecimator */
}
c_obj = obj->filt2;
if (c_obj->isInitialized == 2) {
for (i2 = 0; i2 < 45; i2++) {
g_u[i2] = cv20[i2];
}
g_y = NULL;
m5 = emlrtCreateCharArray(2, iv38);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m5,
&g_u[0]);
emlrtAssign(&g_y, m5);
for (i2 = 0; i2 < 7; i2++) {
h_u[i2] = cv22[i2];
}
h_y = NULL;
m5 = emlrtCreateCharArray(2, iv39);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 7, m5,
&h_u[0]);
emlrtAssign(&h_y, m5);
error(moduleInstance, message(moduleInstance, g_y, h_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (c_obj->isInitialized == 1) {
c_obj->isInitialized = 2;
/* System object Destructor function: dsp.FIRRateConverter */
}
obj->NumChannels = -1.0;
}
}
/* System object Destructor function: dsp.FIRDecimator */
/* System object Destructor function: dsp.FIRDecimator */
/* System object Destructor function: dsp.FIRRateConverter */
/* System object Destructor function: dsp.FIRRateConverter */
}
/* Function Definitions */
void reportDrivers(const emlrtStack *sp, char_T flatAddrList_data[], int32_T
flatAddrList_size[2])
{
const mxArray *y;
static const int32_T iv36[2] = { 1, 6 };
const mxArray *m14;
char_T cv60[6];
int32_T i;
static const char_T cv61[6] = { 's', 'i', 'l', 'e', 'n', 't' };
char_T errStr_data[1024];
UsrpErrorCapiEnumT errStat_i;
const mxArray *b_y;
const mxArray *c_y;
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
/* Copyright 2011-2012 The MathWorks, Inc. */
st.site = &lb_emlrtRSI;
/* */
/* This function unifies handling of interp vs. codegen call as well as */
/* errStat / errStr assignment. */
/* */
/* Copyright 2011-2014 The MathWorks, Inc. */
if (!isSetupsdruCalled) {
y = NULL;
m14 = emlrtCreateCharArray(2, iv36);
for (i = 0; i < 6; i++) {
cv60[i] = cv61[i];
}
emlrtInitCharArrayR2013a(&st, 6, m14, cv60);
emlrtAssign(&y, m14);
b_st.site = &qb_emlrtRSI;
setupsdru(&b_st, sdruroot(&b_st, &f_emlrtMCI), y, &g_emlrtMCI);
isSetupsdruCalled = true;
}
/* These sizes must match those in C code. */
/* Arbitrary max imposed on ML/SL side */
/* function is being called in interpreted mode */
/* not being found: */
/* eml_allow_enum_inputs; */
/* errStat_i = int32(0); */
memset(&errStr_data[0], 0, sizeof(char_T) << 10);
flatAddrList_size[0] = 1;
memset(&flatAddrList_data[0], 0, sizeof(char_T) << 7);
reportDrivers_c(&flatAddrList_data[0], &errStat_i, &errStr_data[0]);
i = strlen(&flatAddrList_data[0]);
if (i <= 128) {
} else {
b_y = NULL;
m14 = emlrtCreateString("Assertion failed.");
emlrtAssign(&b_y, m14);
b_st.site = &ob_emlrtRSI;
c_error(&b_st, b_y, &h_emlrtMCI);
}
if (1 > i) {
i = 0;
} else {
i = emlrtDynamicBoundsCheckFastR2012b(i, 1, 128, &m_emlrtBCI, &st);
}
flatAddrList_size[1] = i;
/* errStat = UsrpErrorCapiEnumT(errStat_i); */
i = strlen(&errStr_data[0]);
if (i <= 1024) {
} else {
c_y = NULL;
m14 = emlrtCreateString("Assertion failed.");
emlrtAssign(&c_y, m14);
b_st.site = &nb_emlrtRSI;
c_error(&b_st, c_y, &e_emlrtMCI);
}
if (1 > i) {
} else {
emlrtDynamicBoundsCheckFastR2012b(i, 1, 1024, &l_emlrtBCI, &st);
}
}
static void SystemCore_step(InstanceStruct_UXvEHHrxIcmXaLthmwvduD
*moduleInstance, dspcodegen_FIRDecimator *obj, real_T varargin_1[6250], real_T
varargout_1[1250])
{
int32_T inputIdx;
static char_T cv4[45] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's',
't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e',
'd', 'W', 'h', 'e', 'n', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'd', 'C', 'o',
'd', 'e', 'g', 'e', 'n' };
char_T u[45];
const mxArray *y;
static const int32_T iv4[2] = { 1, 45 };
const mxArray *m1;
static char_T cv5[4] = { 's', 't', 'e', 'p' };
char_T b_u[4];
const mxArray *b_y;
static const int32_T iv5[2] = { 1, 4 };
dspcodegen_FIRDecimator *b_obj;
static char_T cv6[51] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's',
't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e',
'd', 'W', 'h', 'e', 'n', 'L', 'o', 'c', 'k', 'e', 'd', 'R', 'e', 'l', 'e',
'a', 's', 'e', 'd', 'C', 'o', 'd', 'e', 'g', 'e', 'n' };
char_T c_u[51];
const mxArray *c_y;
static const int32_T iv6[2] = { 1, 51 };
static char_T cv7[5] = { 's', 'e', 't', 'u', 'p' };
char_T d_u[5];
const mxArray *d_y;
static const int32_T iv7[2] = { 1, 5 };
dsp_FIRDecimator_0 *c_obj;
int32_T curTapIdx;
int32_T phaseIdx;
int32_T cffIdx;
int32_T outBufIdx;
int32_T maxWindow;
int32_T iIdx;
int32_T jIdx;
if (obj->isInitialized == 2) {
for (inputIdx = 0; inputIdx < 45; inputIdx++) {
u[inputIdx] = cv4[inputIdx];
}
y = NULL;
m1 = emlrtCreateCharArray(2, iv4);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m1, &u[0]);
emlrtAssign(&y, m1);
for (inputIdx = 0; inputIdx < 4; inputIdx++) {
b_u[inputIdx] = cv5[inputIdx];
}
b_y = NULL;
m1 = emlrtCreateCharArray(2, iv5);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 4, m1, &b_u[0]);
emlrtAssign(&b_y, m1);
error(moduleInstance, message(moduleInstance, y, b_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (obj->isInitialized != 1) {
b_obj = obj;
if (b_obj->isInitialized != 0) {
for (inputIdx = 0; inputIdx < 51; inputIdx++) {
c_u[inputIdx] = cv6[inputIdx];
}
c_y = NULL;
m1 = emlrtCreateCharArray(2, iv6);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 51, m1, &c_u
[0]);
emlrtAssign(&c_y, m1);
for (inputIdx = 0; inputIdx < 5; inputIdx++) {
d_u[inputIdx] = cv7[inputIdx];
}
d_y = NULL;
m1 = emlrtCreateCharArray(2, iv7);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 5, m1, &d_u[0]);
emlrtAssign(&d_y, m1);
error(moduleInstance, message(moduleInstance, c_y, d_y, &c_emlrtMCI),
&c_emlrtMCI);
}
b_obj->isInitialized = 1;
/* System object Initialization function: dsp.FIRDecimator */
b_obj->cSFunObject.W2_CoeffIdx = 52;
b_obj->cSFunObject.W0_PhaseIdx = 4;
b_obj->cSFunObject.W4_TapDelayIndex = 48;
b_obj->cSFunObject.W1_Sums = 0.0;
for (inputIdx = 0; inputIdx < 60; inputIdx++) {
b_obj->cSFunObject.W3_StatesBuff[inputIdx] = 0.0;
}
}
b_obj = obj;
c_obj = &b_obj->cSFunObject;
/* System object Outputs function: dsp.FIRDecimator */
inputIdx = 0;
curTapIdx = b_obj->cSFunObject.W4_TapDelayIndex;
phaseIdx = b_obj->cSFunObject.W0_PhaseIdx;
cffIdx = b_obj->cSFunObject.W2_CoeffIdx;
outBufIdx = 0;
maxWindow = (phaseIdx + 1) * 12;
for (iIdx = 0; iIdx < 6250; iIdx++) {
c_obj->W1_Sums += varargin_1[inputIdx] * c_obj->P1_FILT[cffIdx];
cffIdx++;
for (jIdx = curTapIdx + 1; jIdx < maxWindow; jIdx++) {
c_obj->W1_Sums += c_obj->W3_StatesBuff[jIdx] * c_obj->P1_FILT[cffIdx];
cffIdx++;
}
for (jIdx = maxWindow - 12; jIdx <= curTapIdx; jIdx++) {
c_obj->W1_Sums += c_obj->W3_StatesBuff[jIdx] * c_obj->P1_FILT[cffIdx];
cffIdx++;
}
c_obj->W3_StatesBuff[curTapIdx] = varargin_1[inputIdx];
inputIdx++;
curTapIdx += 12;
if (curTapIdx >= 60) {
curTapIdx -= 60;
}
phaseIdx++;
if (phaseIdx < 5) {
maxWindow += 12;
} else {
c_obj->O0_Y0[outBufIdx] = c_obj->W1_Sums;
outBufIdx++;
c_obj->W1_Sums = 0.0;
phaseIdx = 0;
cffIdx = 0;
curTapIdx--;
if (curTapIdx < 0) {
curTapIdx += 12;
}
maxWindow = 12;
}
}
b_obj->cSFunObject.W4_TapDelayIndex = curTapIdx;
b_obj->cSFunObject.W2_CoeffIdx = cffIdx;
b_obj->cSFunObject.W0_PhaseIdx = phaseIdx;
for (inputIdx = 0; inputIdx < 1250; inputIdx++) {
varargout_1[inputIdx] = b_obj->cSFunObject.O0_Y0[inputIdx];
}
}
static void cgxe_mdl_start(InstanceStruct_UXvEHHrxIcmXaLthmwvduD *moduleInstance)
{
dsp_SampleRateConverter_2 *obj;
dspcodegen_FIRDecimator *iobj_0;
dspcodegen_FIRRateConverter *iobj_1;
int32_T i0;
static char_T cv8[51] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's',
't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e',
'd', 'W', 'h', 'e', 'n', 'L', 'o', 'c', 'k', 'e', 'd', 'R', 'e', 'l', 'e',
'a', 's', 'e', 'd', 'C', 'o', 'd', 'e', 'g', 'e', 'n' };
char_T u[51];
const mxArray *y;
static const int32_T iv8[2] = { 1, 51 };
const mxArray *m2;
static char_T cv9[5] = { 's', 'e', 't', 'u', 'p' };
char_T b_u[5];
const mxArray *b_y;
static const int32_T iv9[2] = { 1, 5 };
static int16_T iv10[8] = { 6250, 1, 1, 1, 1, 1, 1, 1 };
static char_T cv10[29] = { 'd', 's', 'p', ':', 's', 'y', 's', 't', 'e', 'm',
':', 'S', 'h', 'a', 'r', 'e', 'd', ':', 'n', 'u', 'm', 'C', 'h', 'a', 'n',
'n', 'e', 'l', 's' };
char_T c_u[29];
const mxArray *c_y;
static const int32_T iv11[2] = { 1, 29 };
static real_T dv0[65] = { -0.00042490390801053907, 0.001829921716933601,
-0.0053922845058157441, 0.013158346550611766, -0.0306391449331187,
0.097992165418816057, 0.1494061316020634, -0.036811645611123822,
0.015554560498179271, -0.0065160634201840671, 0.002322039466476993,
-0.00059679513327257766, 7.912220199299E-5, -0.00018023922410876497,
0.00087868330763207075, -0.0027374434497387575, 0.0068640356860943941,
-0.015898279697317719, 0.044393549657968379, 0.18648984591811768,
-0.027710944293488637, 0.011353373510521791, -0.004835216511247617,
0.0017985509582130208, -0.0005034779575003312, 7.1006774722819944E-5, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
7.1006774722819944E-5, -0.0005034779575003312, 0.0017985509582130208,
-0.004835216511247617, 0.011353373510521791, -0.027710944293488637,
0.18648984591811768, 0.044393549657968379, -0.015898279697317719,
0.0068640356860943941, -0.0027374434497387575, 0.00087868330763207075,
-0.00018023922410876497, 7.912220199299E-5, -0.00059679513327257766,
0.002322039466476993, -0.0065160634201840671, 0.015554560498179271,
-0.036811645611123822, 0.1494061316020634, 0.097992165418816057,
-0.0306391449331187, 0.013158346550611766, -0.0053922845058157441,
0.001829921716933601, -0.00042490390801053907 };
static real_T dv1[120] = { -2.7394100013652473E-5, 0.0, 0.00037894068534068619,
-0.0013708823152694639, 0.00268257205568729, -0.0029618195399131889, 0.0,
0.0078609652501006478, -0.019453248977701877, 0.028984307962212054,
-0.026341800053436379, 0.0, 0.059586630047975528, -0.16398784004285519,
0.39970920445885333, 0.74757835469466261, 0.0, -0.076109876780524763,
0.077352679334485558, -0.051701756420330057, 0.021737647121907556, 0.0,
-0.009760644763162624, 0.010147444378648696, -0.0062395788347920046,
0.00223736435719863, 0.0, -0.000578393604977232, 0.00038049397375299542,
-0.00011122314331323368, -7.3471653020902532E-5, 0.0001803558498977357, 0.0,
-0.0010125268340104962, 0.00312437313653832, -0.0054788551201990889,
0.0055792244712591183, 0.0, -0.013309431044135926, 0.031938446310848335,
-0.04692872867557716, 0.043075982682944734, 0.0, -0.11993407734560091,
0.60283398545426792, 0.60283398545426792, -0.11993407734560091, 0.0,
0.043075982682944734, -0.04692872867557716, 0.031938446310848335,
-0.013309431044135926, 0.0, 0.0055792244712591183, -0.0054788551201990889,
0.00312437313653832, -0.0010125268340104962, 0.0, 0.0001803558498977357,
-7.3471653020902532E-5, -0.00011122314331323368, 0.00038049397375299542,
-0.000578393604977232, 0.0, 0.00223736435719863, -0.0062395788347920046,
0.010147444378648696, -0.009760644763162624, 0.0, 0.021737647121907556,
-0.051701756420330057, 0.077352679334485558, -0.076109876780524763, 0.0,
0.74757835469466261, 0.39970920445885333, -0.16398784004285519,
0.059586630047975528, 0.0, -0.026341800053436379, 0.028984307962212054,
-0.019453248977701877, 0.0078609652501006478, 0.0, -0.0029618195399131889,
0.00268257205568729, -0.0013708823152694639, 0.00037894068534068619, 0.0,
-2.7394100013652473E-5, -9.8313238270332086E-5, 0.000486827925108784,
-0.0011378244855056148, 0.001415513014019786, 0.0, -0.0043758948985123938,
0.011375305454062892, -0.017543845054337627, 0.01624272325576193, 0.0,
-0.035239058026866117, 0.086157558252096214, -0.14115130237644263,
0.18386872695653758, 0.8, 0.18386872695653758, -0.14115130237644263,
0.086157558252096214, -0.035239058026866117, 0.0, 0.01624272325576193,
-0.017543845054337627, 0.011375305454062892, -0.0043758948985123938, 0.0,
0.001415513014019786, -0.0011378244855056148, 0.000486827925108784,
-9.8313238270332086E-5, 0.0 };
static int8_T iv12[5] = { 1, 2, 3, 4, 4 };
init_simulink_io_address(moduleInstance);
if (!moduleInstance->sysobj_not_empty) {
obj = &moduleInstance->sysobj;
moduleInstance->sysobj.filt1 = NULL;
moduleInstance->sysobj.filt2 = NULL;
obj->isInitialized = 0;
obj->NumChannels = -1.0;
moduleInstance->sysobj_not_empty = true;
}
obj = &moduleInstance->sysobj;
iobj_0 = &moduleInstance->gobj_0;
iobj_1 = &moduleInstance->gobj_2;
if (moduleInstance->sysobj.isInitialized != 0) {
for (i0 = 0; i0 < 51; i0++) {
u[i0] = cv8[i0];
}
y = NULL;
m2 = emlrtCreateCharArray(2, iv8);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 51, m2, &u[0]);
emlrtAssign(&y, m2);
for (i0 = 0; i0 < 5; i0++) {
b_u[i0] = cv9[i0];
}
b_y = NULL;
m2 = emlrtCreateCharArray(2, iv9);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 5, m2, &b_u[0]);
emlrtAssign(&b_y, m2);
error(moduleInstance, message(moduleInstance, y, b_y, &c_emlrtMCI),
&c_emlrtMCI);
}
obj->isInitialized = 1;
for (i0 = 0; i0 < 8; i0++) {
obj->inputVarSize1[i0] = (uint32_T)iv10[i0];
}
if ((obj->NumChannels != -1.0) && (1.0 != obj->NumChannels)) {
for (i0 = 0; i0 < 29; i0++) {
c_u[i0] = cv10[i0];
}
c_y = NULL;
m2 = emlrtCreateCharArray(2, iv11);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 29, m2, &c_u[0]);
emlrtAssign(&c_y, m2);
error(moduleInstance, b_message(moduleInstance, c_y, &d_emlrtMCI),
&d_emlrtMCI);
}
if (!(obj->filt1 == NULL)) {
emlrtErrorWithMessageIdR2012b(moduleInstance->emlrtRootTLSGlobal,
&b_emlrtRTEI, "EMLRT:runTime:NontunableHandleProp", 0);
}
iobj_0->isInitialized = 0;
/* System object Constructor function: dsp.FIRDecimator */
iobj_0->cSFunObject.P0_IC = 0.0;
for (i0 = 0; i0 < 65; i0++) {
iobj_0->cSFunObject.P1_FILT[i0] = dv0[i0];
}
obj->filt1 = iobj_0;
if (!(obj->filt2 == NULL)) {
emlrtErrorWithMessageIdR2012b(moduleInstance->emlrtRootTLSGlobal, &emlrtRTEI,
"EMLRT:runTime:NontunableHandleProp", 0);
}
iobj_1->isInitialized = 0;
/* System object Constructor function: dsp.FIRRateConverter */
for (i0 = 0; i0 < 120; i0++) {
iobj_1->cSFunObject.P0_FILTER[i0] = dv1[i0];
}
for (i0 = 0; i0 < 4; i0++) {
iobj_1->cSFunObject.P1_PolyphaseSelector[i0] = i0;
}
for (i0 = 0; i0 < 5; i0++) {
iobj_1->cSFunObject.P2_StartIdx[i0] = i0;
}
for (i0 = 0; i0 < 5; i0++) {
iobj_1->cSFunObject.P3_StopIdx[i0] = iv12[i0];
}
obj->filt2 = iobj_1;
obj->NumChannels = 1.0;
}
static void cgxe_mdl_initialize(InstanceStruct_UXvEHHrxIcmXaLthmwvduD
*moduleInstance)
{
dsp_SampleRateConverter_2 *obj;
int32_T i1;
static char_T cv11[45] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y', 's',
't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l', 'e',
'd', 'W', 'h', 'e', 'n', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'd', 'C', 'o',
'd', 'e', 'g', 'e', 'n' };
char_T u[45];
const mxArray *y;
static const int32_T iv13[2] = { 1, 45 };
const mxArray *m3;
static char_T cv12[8] = { 'i', 's', 'L', 'o', 'c', 'k', 'e', 'd' };
char_T b_u[8];
const mxArray *b_y;
static const int32_T iv14[2] = { 1, 8 };
boolean_T flag;
char_T c_u[45];
const mxArray *c_y;
static const int32_T iv15[2] = { 1, 45 };
static char_T cv13[5] = { 'r', 'e', 's', 'e', 't' };
char_T d_u[5];
const mxArray *d_y;
static const int32_T iv16[2] = { 1, 5 };
dspcodegen_FIRDecimator *b_obj;
char_T e_u[45];
const mxArray *e_y;
static const int32_T iv17[2] = { 1, 45 };
char_T f_u[5];
const mxArray *f_y;
static const int32_T iv18[2] = { 1, 5 };
dspcodegen_FIRRateConverter *c_obj;
char_T g_u[45];
const mxArray *g_y;
static const int32_T iv19[2] = { 1, 45 };
char_T h_u[5];
const mxArray *h_y;
static const int32_T iv20[2] = { 1, 5 };
if (!moduleInstance->sysobj_not_empty) {
obj = &moduleInstance->sysobj;
moduleInstance->sysobj.filt1 = NULL;
moduleInstance->sysobj.filt2 = NULL;
obj->isInitialized = 0;
obj->NumChannels = -1.0;
moduleInstance->sysobj_not_empty = true;
}
obj = &moduleInstance->sysobj;
if (moduleInstance->sysobj.isInitialized == 2) {
for (i1 = 0; i1 < 45; i1++) {
u[i1] = cv11[i1];
}
y = NULL;
m3 = emlrtCreateCharArray(2, iv13);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m3, &u[0]);
emlrtAssign(&y, m3);
for (i1 = 0; i1 < 8; i1++) {
b_u[i1] = cv12[i1];
}
b_y = NULL;
m3 = emlrtCreateCharArray(2, iv14);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 8, m3, &b_u[0]);
emlrtAssign(&b_y, m3);
error(moduleInstance, message(moduleInstance, y, b_y, &c_emlrtMCI),
&c_emlrtMCI);
}
flag = (obj->isInitialized == 1);
if (flag) {
obj = &moduleInstance->sysobj;
if (moduleInstance->sysobj.isInitialized == 2) {
for (i1 = 0; i1 < 45; i1++) {
c_u[i1] = cv11[i1];
}
c_y = NULL;
m3 = emlrtCreateCharArray(2, iv15);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m3, &c_u
[0]);
emlrtAssign(&c_y, m3);
for (i1 = 0; i1 < 5; i1++) {
d_u[i1] = cv13[i1];
}
d_y = NULL;
m3 = emlrtCreateCharArray(2, iv16);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 5, m3, &d_u[0]);
emlrtAssign(&d_y, m3);
error(moduleInstance, message(moduleInstance, c_y, d_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (obj->isInitialized == 1) {
b_obj = obj->filt1;
if (b_obj->isInitialized == 2) {
for (i1 = 0; i1 < 45; i1++) {
e_u[i1] = cv11[i1];
}
e_y = NULL;
m3 = emlrtCreateCharArray(2, iv17);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m3,
&e_u[0]);
emlrtAssign(&e_y, m3);
for (i1 = 0; i1 < 5; i1++) {
f_u[i1] = cv13[i1];
}
f_y = NULL;
m3 = emlrtCreateCharArray(2, iv18);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 5, m3,
&f_u[0]);
emlrtAssign(&f_y, m3);
error(moduleInstance, message(moduleInstance, e_y, f_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (b_obj->isInitialized == 1) {
/* System object Initialization function: dsp.FIRDecimator */
b_obj->cSFunObject.W2_CoeffIdx = 52;
b_obj->cSFunObject.W0_PhaseIdx = 4;
b_obj->cSFunObject.W4_TapDelayIndex = 48;
b_obj->cSFunObject.W1_Sums = 0.0;
for (i1 = 0; i1 < 60; i1++) {
b_obj->cSFunObject.W3_StatesBuff[i1] = 0.0;
}
}
c_obj = obj->filt2;
if (c_obj->isInitialized == 2) {
for (i1 = 0; i1 < 45; i1++) {
g_u[i1] = cv11[i1];
}
g_y = NULL;
m3 = emlrtCreateCharArray(2, iv19);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 45, m3,
&g_u[0]);
emlrtAssign(&g_y, m3);
for (i1 = 0; i1 < 5; i1++) {
h_u[i1] = cv13[i1];
}
h_y = NULL;
m3 = emlrtCreateCharArray(2, iv20);
emlrtInitCharArrayR2013a(moduleInstance->emlrtRootTLSGlobal, 5, m3,
&h_u[0]);
emlrtAssign(&h_y, m3);
error(moduleInstance, message(moduleInstance, g_y, h_y, &c_emlrtMCI),
&c_emlrtMCI);
}
if (c_obj->isInitialized == 1) {
/* System object Initialization function: dsp.FIRRateConverter */
c_obj->cSFunObject.W1_InBufIdx = 0;
for (i1 = 0; i1 < 30; i1++) {
c_obj->cSFunObject.W0_InBuf[i1] = 0.0;
}
}
}
}
}
/* Function Definitions */
void mpower(const emlrtStack *sp, const emxArray_real_T *a, emxArray_real_T *c)
{
boolean_T b0;
const mxArray *y;
static const int32_T iv11[2] = { 1, 19 };
const mxArray *m3;
char_T cv11[19];
int32_T i;
static const char_T cv12[19] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 's', 'q', 'u', 'a', 'r', 'e' };
const mxArray *b_y;
static const int32_T iv12[2] = { 1, 45 };
char_T cv13[45];
static const char_T cv14[45] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
'l', 'b', 'o', 'x', ':', 'm', 't', 'i', 'm', 'e', 's', '_', 'n', 'o', 'D',
'y', 'n', 'a', 'm', 'i', 'c', 'S', 'c', 'a', 'l', 'a', 'r', 'E', 'x', 'p',
'a', 'n', 's', 'i', 'o', 'n' };
const mxArray *c_y;
static const int32_T iv13[2] = { 1, 21 };
char_T cv15[21];
static const char_T cv16[21] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'i', 'n', 'n', 'e', 'r', 'd', 'i', 'm' };
real_T b_a;
int32_T loop_ub;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
emlrtStack e_st;
emlrtStack f_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = sp;
b_st.tls = sp->tls;
c_st.prev = &st;
c_st.tls = st.tls;
d_st.prev = &c_st;
d_st.tls = c_st.tls;
e_st.prev = &d_st;
e_st.tls = d_st.tls;
f_st.prev = &d_st;
f_st.tls = d_st.tls;
b0 = (1 == a->size[1]);
if (b0) {
} else {
y = NULL;
m3 = emlrtCreateCharArray(2, iv11);
for (i = 0; i < 19; i++) {
cv11[i] = cv12[i];
}
emlrtInitCharArrayR2013a(sp, 19, m3, cv11);
emlrtAssign(&y, m3);
st.site = &ig_emlrtRSI;
b_st.site = &qg_emlrtRSI;
error(&st, message(&b_st, y, &d_emlrtMCI), &e_emlrtMCI);
}
st.site = &eb_emlrtRSI;
c_st.site = &fb_emlrtRSI;
d_st.site = &gb_emlrtRSI;
if (!(a->size[1] == 1)) {
if (a->size[1] == 1) {
b_y = NULL;
m3 = emlrtCreateCharArray(2, iv12);
for (i = 0; i < 45; i++) {
cv13[i] = cv14[i];
}
emlrtInitCharArrayR2013a(&d_st, 45, m3, cv13);
emlrtAssign(&b_y, m3);
e_st.site = &cg_emlrtRSI;
f_st.site = &lg_emlrtRSI;
error(&e_st, message(&f_st, b_y, &f_emlrtMCI), &g_emlrtMCI);
} else {
c_y = NULL;
m3 = emlrtCreateCharArray(2, iv13);
for (i = 0; i < 21; i++) {
cv15[i] = cv16[i];
}
emlrtInitCharArrayR2013a(&d_st, 21, m3, cv15);
emlrtAssign(&c_y, m3);
e_st.site = &dg_emlrtRSI;
f_st.site = &mg_emlrtRSI;
error(&e_st, message(&f_st, c_y, &h_emlrtMCI), &i_emlrtMCI);
}
}
i = c->size[0] * c->size[1];
c->size[0] = 1;
c->size[1] = a->size[1];
emxEnsureCapacity(&c_st, (emxArray__common *)c, i, (int32_T)sizeof(real_T),
&j_emlrtRTEI);
b_a = a->data[0];
loop_ub = a->size[0] * a->size[1];
for (i = 0; i < loop_ub; i++) {
c->data[i] = b_a * a->data[i];
}
}
void b_Acoeff(const emlrtStack *sp, real_T ksi, real_T j, const emxArray_real_T *
x, real_T t, const emxArray_real_T *gridT, emxArray_real_T *vals)
{
emxArray_real_T *b;
emxArray_real_T *r8;
int32_T b_x;
int32_T i;
emxArray_boolean_T *b_t;
real_T c_x;
emxArray_boolean_T *c_t;
emxArray_real_T *z0;
emxArray_real_T *d_x;
emxArray_real_T *e_x;
emxArray_real_T *r9;
int32_T b_b[2];
int32_T f_x[2];
emxArray_real_T *g_x;
emxArray_real_T *r10;
const mxArray *y;
static const int32_T iv16[2] = { 1, 45 };
const mxArray *m6;
char_T cv18[45];
static const char_T cv19[45] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
'l', 'b', 'o', 'x', ':', 'm', 't', 'i', 'm', 'e', 's', '_', 'n', 'o', 'D',
'y', 'n', 'a', 'm', 'i', 'c', 'S', 'c', 'a', 'l', 'a', 'r', 'E', 'x', 'p',
'a', 'n', 's', 'i', 'o', 'n' };
const mxArray *b_y;
static const int32_T iv17[2] = { 1, 21 };
char_T cv20[21];
static const char_T cv21[21] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'i', 'n', 'n', 'e', 'r', 'd', 'i', 'm' };
emxArray_boolean_T *d_t;
real_T h_x;
emxArray_boolean_T *e_t;
emxArray_real_T *i_x;
emxArray_real_T *r11;
emxArray_real_T *j_x;
emxArray_real_T *r12;
emxArray_real_T *z1;
int32_T b_z0[2];
emxArray_real_T *c_z0;
emxArray_real_T *k_x;
const mxArray *c_y;
static const int32_T iv18[2] = { 1, 45 };
const mxArray *d_y;
static const int32_T iv19[2] = { 1, 21 };
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &b_st;
d_st.tls = b_st.tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
emxInit_real_T(sp, &b, 2, &bb_emlrtRTEI, true);
emxInit_real_T(sp, &r8, 2, &bb_emlrtRTEI, true);
/* evaluate the coefficient A at the boundary ksi=0 or ksi=1; */
/* for the index j which describes the time steps timePoints_j, at time t and space */
/* point x */
/* timePoints is a vector describing the time descritized domain */
b_x = gridT->size[1];
i = (int32_T)emlrtIntegerCheckFastR2012b(j, &emlrtDCI, sp);
if (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &d_emlrtBCI,
sp) - 1]) {
b_x = vals->size[0] * vals->size[1];
vals->size[0] = 1;
vals->size[1] = 1;
emxEnsureCapacity(sp, (emxArray__common *)vals, b_x, (int32_T)sizeof(real_T),
&bb_emlrtRTEI);
vals->data[0] = 0.0;
} else {
emxInit_boolean_T(sp, &b_t, 2, &bb_emlrtRTEI, true);
b_x = b_t->size[0] * b_t->size[1];
b_t->size[0] = 1;
b_t->size[1] = 2 + x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)b_t, b_x, (int32_T)sizeof
(boolean_T), &bb_emlrtRTEI);
b_x = gridT->size[1];
i = (int32_T)j;
b_t->data[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x,
&e_emlrtBCI, sp) - 1]);
b_x = gridT->size[1];
i = (int32_T)((uint32_T)j + 1U);
b_t->data[b_t->size[0]] = (t <= gridT->
data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &f_emlrtBCI, sp) - 1]);
i = x->size[1];
for (b_x = 0; b_x < i; b_x++) {
b_t->data[b_t->size[0] * (b_x + 2)] = (x->data[x->size[0] * b_x] == ksi);
}
st.site = &pe_emlrtRSI;
if (all(&st, b_t)) {
b_x = gridT->size[1];
i = (int32_T)j;
emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &c_emlrtBCI, sp);
c_x = (t - gridT->data[(int32_T)j - 1]) / 3.1415926535897931;
st.site = &emlrtRSI;
if (c_x < 0.0) {
b_st.site = &f_emlrtRSI;
eml_error(&b_st);
}
b_x = vals->size[0] * vals->size[1];
vals->size[0] = 1;
vals->size[1] = 1;
emxEnsureCapacity(sp, (emxArray__common *)vals, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
vals->data[0] = muDoubleScalarSqrt(c_x);
} else {
emxInit_boolean_T(sp, &c_t, 2, &bb_emlrtRTEI, true);
b_x = c_t->size[0] * c_t->size[1];
c_t->size[0] = 1;
c_t->size[1] = 2 + x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)c_t, b_x, (int32_T)sizeof
(boolean_T), &bb_emlrtRTEI);
b_x = gridT->size[1];
i = (int32_T)j;
c_t->data[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1,
b_x, &g_emlrtBCI, sp) - 1]);
b_x = gridT->size[1];
i = (int32_T)((uint32_T)j + 1U);
c_t->data[c_t->size[0]] = (t <= gridT->
data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &h_emlrtBCI, sp) - 1]);
i = x->size[1];
for (b_x = 0; b_x < i; b_x++) {
c_t->data[c_t->size[0] * (b_x + 2)] = (x->data[x->size[0] * b_x] != ksi);
}
emxInit_real_T(sp, &z0, 2, &cb_emlrtRTEI, true);
emxInit_real_T(sp, &d_x, 2, &bb_emlrtRTEI, true);
st.site = &qe_emlrtRSI;
if (all(&st, c_t)) {
st.site = &b_emlrtRSI;
b_x = gridT->size[1];
i = (int32_T)j;
c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x,
&m_emlrtBCI, &st) - 1];
if (c_x < 0.0) {
b_st.site = &f_emlrtRSI;
eml_error(&b_st);
}
emxInit_real_T(&st, &e_x, 2, &bb_emlrtRTEI, true);
b_x = e_x->size[0] * e_x->size[1];
e_x->size[0] = 1;
e_x->size[1] = x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)e_x, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = x->size[0] * x->size[1];
for (b_x = 0; b_x < i; b_x++) {
e_x->data[b_x] = x->data[b_x] - ksi;
}
emxInit_real_T(sp, &r9, 2, &bb_emlrtRTEI, true);
b_abs(sp, e_x, r9);
b_x = r8->size[0] * r8->size[1];
r8->size[0] = 1;
r8->size[1] = r9->size[1];
emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = r9->size[0] * r9->size[1];
emxFree_real_T(&e_x);
for (b_x = 0; b_x < i; b_x++) {
r8->data[b_x] = r9->data[b_x];
}
emxFree_real_T(&r9);
rdivide(sp, r8, 2.0 * muDoubleScalarSqrt(c_x), z0);
st.site = &re_emlrtRSI;
mpower(&st, z0, d_x);
b_x = d_x->size[0] * d_x->size[1];
d_x->size[0] = 1;
emxEnsureCapacity(sp, (emxArray__common *)d_x, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = d_x->size[0];
b_x = d_x->size[1];
i *= b_x;
for (b_x = 0; b_x < i; b_x++) {
d_x->data[b_x] = -d_x->data[b_x];
}
b_x = b->size[0] * b->size[1];
b->size[0] = 1;
b->size[1] = d_x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)b, b_x, (int32_T)sizeof(real_T),
&bb_emlrtRTEI);
i = d_x->size[0] * d_x->size[1];
for (b_x = 0; b_x < i; b_x++) {
b->data[b_x] = d_x->data[b_x];
}
for (i = 0; i < d_x->size[1]; i++) {
b->data[i] = muDoubleScalarExp(b->data[i]);
}
st.site = &re_emlrtRSI;
b_mrdivide(&st, b, z0);
for (b_x = 0; b_x < 2; b_x++) {
i = d_x->size[0] * d_x->size[1];
d_x->size[b_x] = z0->size[b_x];
emxEnsureCapacity(sp, (emxArray__common *)d_x, i, (int32_T)sizeof
(real_T), &ab_emlrtRTEI);
}
for (i = 0; i < z0->size[1]; i++) {
d_x->data[i] = scalar_erf(z0->data[i]);
}
b_x = d_x->size[0] * d_x->size[1];
d_x->size[0] = 1;
emxEnsureCapacity(sp, (emxArray__common *)d_x, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = d_x->size[0];
b_x = d_x->size[1];
i *= b_x;
for (b_x = 0; b_x < i; b_x++) {
d_x->data[b_x] *= 1.7724538509055159;
}
for (b_x = 0; b_x < 2; b_x++) {
b_b[b_x] = b->size[b_x];
}
for (b_x = 0; b_x < 2; b_x++) {
f_x[b_x] = d_x->size[b_x];
}
emxInit_real_T(sp, &g_x, 2, &bb_emlrtRTEI, true);
emlrtSizeEqCheck2DFastR2012b(b_b, f_x, &o_emlrtECI, sp);
b_x = g_x->size[0] * g_x->size[1];
g_x->size[0] = 1;
g_x->size[1] = x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)g_x, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = x->size[0] * x->size[1];
for (b_x = 0; b_x < i; b_x++) {
g_x->data[b_x] = x->data[b_x] - ksi;
}
emxInit_real_T(sp, &r10, 2, &bb_emlrtRTEI, true);
b_abs(sp, g_x, r10);
b_x = r8->size[0] * r8->size[1];
r8->size[0] = 1;
r8->size[1] = r10->size[1];
emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = r10->size[0] * r10->size[1];
emxFree_real_T(&g_x);
for (b_x = 0; b_x < i; b_x++) {
r8->data[b_x] = r10->data[b_x];
}
emxFree_real_T(&r10);
rdivide(sp, r8, 3.5449077018110318, vals);
st.site = &re_emlrtRSI;
b_x = b->size[0] * b->size[1];
b->size[0] = 1;
emxEnsureCapacity(&st, (emxArray__common *)b, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = b->size[0];
b_x = b->size[1];
i *= b_x;
for (b_x = 0; b_x < i; b_x++) {
b->data[b_x] -= d_x->data[b_x];
}
b_st.site = &he_emlrtRSI;
if (!(vals->size[1] == 1)) {
if ((vals->size[1] == 1) || (b->size[1] == 1)) {
y = NULL;
m6 = emlrtCreateCharArray(2, iv16);
for (i = 0; i < 45; i++) {
cv18[i] = cv19[i];
}
emlrtInitCharArrayR2013a(&b_st, 45, m6, cv18);
emlrtAssign(&y, m6);
c_st.site = &fh_emlrtRSI;
d_st.site = &vg_emlrtRSI;
b_error(&c_st, message(&d_st, y, &j_emlrtMCI), &k_emlrtMCI);
} else {
b_y = NULL;
m6 = emlrtCreateCharArray(2, iv17);
for (i = 0; i < 21; i++) {
cv20[i] = cv21[i];
}
emlrtInitCharArrayR2013a(&b_st, 21, m6, cv20);
emlrtAssign(&b_y, m6);
c_st.site = &gh_emlrtRSI;
d_st.site = &wg_emlrtRSI;
b_error(&c_st, message(&d_st, b_y, &l_emlrtMCI), &m_emlrtMCI);
}
}
c_x = vals->data[0];
b_x = vals->size[0] * vals->size[1];
vals->size[0] = 1;
vals->size[1] = b->size[1];
emxEnsureCapacity(&st, (emxArray__common *)vals, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = b->size[1];
for (b_x = 0; b_x < i; b_x++) {
vals->data[vals->size[0] * b_x] = c_x * b->data[b->size[0] * b_x];
}
} else {
emxInit_boolean_T(sp, &d_t, 2, &bb_emlrtRTEI, true);
b_x = d_t->size[0] * d_t->size[1];
d_t->size[0] = 1;
d_t->size[1] = 1 + x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)d_t, b_x, (int32_T)sizeof
(boolean_T), &bb_emlrtRTEI);
b_x = gridT->size[1];
i = (int32_T)((uint32_T)j + 1U);
d_t->data[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1,
b_x, &i_emlrtBCI, sp) - 1]);
i = x->size[1];
for (b_x = 0; b_x < i; b_x++) {
d_t->data[d_t->size[0] * (b_x + 1)] = (x->data[x->size[0] * b_x] ==
ksi);
}
st.site = &se_emlrtRSI;
if (all(&st, d_t)) {
b_x = gridT->size[1];
i = (int32_T)j;
emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &b_emlrtBCI, sp);
c_x = (t - gridT->data[(int32_T)j - 1]) / 3.1415926535897931;
b_x = gridT->size[1];
i = (int32_T)(j + 1.0);
emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x, &emlrtBCI, sp);
h_x = (t - gridT->data[(int32_T)(j + 1.0) - 1]) / 3.1415926535897931;
st.site = &c_emlrtRSI;
if (c_x < 0.0) {
b_st.site = &f_emlrtRSI;
eml_error(&b_st);
}
st.site = &c_emlrtRSI;
if (h_x < 0.0) {
b_st.site = &f_emlrtRSI;
eml_error(&b_st);
}
b_x = vals->size[0] * vals->size[1];
vals->size[0] = 1;
vals->size[1] = 1;
emxEnsureCapacity(sp, (emxArray__common *)vals, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
vals->data[0] = muDoubleScalarSqrt(c_x) - muDoubleScalarSqrt(h_x);
} else {
emxInit_boolean_T(sp, &e_t, 2, &bb_emlrtRTEI, true);
b_x = e_t->size[0] * e_t->size[1];
e_t->size[0] = 1;
e_t->size[1] = 1 + x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)e_t, b_x, (int32_T)sizeof
(boolean_T), &bb_emlrtRTEI);
b_x = gridT->size[1];
i = (int32_T)((uint32_T)j + 1U);
e_t->data[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1,
b_x, &j_emlrtBCI, sp) - 1]);
i = x->size[1];
for (b_x = 0; b_x < i; b_x++) {
e_t->data[e_t->size[0] * (b_x + 1)] = (x->data[x->size[0] * b_x] !=
ksi);
}
st.site = &te_emlrtRSI;
if (all(&st, e_t)) {
st.site = &d_emlrtRSI;
b_x = gridT->size[1];
i = (int32_T)j;
c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x,
&k_emlrtBCI, &st) - 1];
if (c_x < 0.0) {
b_st.site = &f_emlrtRSI;
eml_error(&b_st);
}
emxInit_real_T(&st, &i_x, 2, &bb_emlrtRTEI, true);
b_x = i_x->size[0] * i_x->size[1];
i_x->size[0] = 1;
i_x->size[1] = x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)i_x, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = x->size[0] * x->size[1];
for (b_x = 0; b_x < i; b_x++) {
i_x->data[b_x] = x->data[b_x] - ksi;
}
emxInit_real_T(sp, &r11, 2, &bb_emlrtRTEI, true);
b_abs(sp, i_x, r11);
b_x = r8->size[0] * r8->size[1];
r8->size[0] = 1;
r8->size[1] = r11->size[1];
emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = r11->size[0] * r11->size[1];
emxFree_real_T(&i_x);
for (b_x = 0; b_x < i; b_x++) {
r8->data[b_x] = r11->data[b_x];
}
emxFree_real_T(&r11);
rdivide(sp, r8, 2.0 * muDoubleScalarSqrt(c_x), z0);
st.site = &e_emlrtRSI;
b_x = gridT->size[1];
i = (int32_T)((uint32_T)j + 1U);
c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, b_x,
&l_emlrtBCI, &st) - 1];
if (c_x < 0.0) {
b_st.site = &f_emlrtRSI;
eml_error(&b_st);
}
emxInit_real_T(&st, &j_x, 2, &bb_emlrtRTEI, true);
b_x = j_x->size[0] * j_x->size[1];
j_x->size[0] = 1;
j_x->size[1] = x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)j_x, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = x->size[0] * x->size[1];
for (b_x = 0; b_x < i; b_x++) {
j_x->data[b_x] = x->data[b_x] - ksi;
}
emxInit_real_T(sp, &r12, 2, &bb_emlrtRTEI, true);
b_abs(sp, j_x, r12);
b_x = r8->size[0] * r8->size[1];
r8->size[0] = 1;
r8->size[1] = r12->size[1];
emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = r12->size[0] * r12->size[1];
emxFree_real_T(&j_x);
for (b_x = 0; b_x < i; b_x++) {
r8->data[b_x] = r12->data[b_x];
}
emxFree_real_T(&r12);
emxInit_real_T(sp, &z1, 2, &db_emlrtRTEI, true);
rdivide(sp, r8, 2.0 * muDoubleScalarSqrt(c_x), z1);
st.site = &ue_emlrtRSI;
mpower(&st, z0, d_x);
b_x = d_x->size[0] * d_x->size[1];
d_x->size[0] = 1;
emxEnsureCapacity(sp, (emxArray__common *)d_x, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = d_x->size[0];
b_x = d_x->size[1];
i *= b_x;
for (b_x = 0; b_x < i; b_x++) {
d_x->data[b_x] = -d_x->data[b_x];
}
b_x = b->size[0] * b->size[1];
b->size[0] = 1;
b->size[1] = d_x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)b, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = d_x->size[0] * d_x->size[1];
for (b_x = 0; b_x < i; b_x++) {
b->data[b_x] = d_x->data[b_x];
}
for (i = 0; i < d_x->size[1]; i++) {
b->data[i] = muDoubleScalarExp(b->data[i]);
}
st.site = &ue_emlrtRSI;
b_mrdivide(&st, b, z0);
st.site = &ue_emlrtRSI;
mpower(&st, z1, d_x);
b_x = d_x->size[0] * d_x->size[1];
d_x->size[0] = 1;
emxEnsureCapacity(sp, (emxArray__common *)d_x, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = d_x->size[0];
b_x = d_x->size[1];
i *= b_x;
for (b_x = 0; b_x < i; b_x++) {
d_x->data[b_x] = -d_x->data[b_x];
}
b_x = r8->size[0] * r8->size[1];
r8->size[0] = 1;
r8->size[1] = d_x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)r8, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = d_x->size[0] * d_x->size[1];
for (b_x = 0; b_x < i; b_x++) {
r8->data[b_x] = d_x->data[b_x];
}
for (i = 0; i < d_x->size[1]; i++) {
r8->data[i] = muDoubleScalarExp(r8->data[i]);
}
st.site = &ue_emlrtRSI;
b_mrdivide(&st, r8, z1);
for (b_x = 0; b_x < 2; b_x++) {
b_b[b_x] = b->size[b_x];
}
for (b_x = 0; b_x < 2; b_x++) {
b_z0[b_x] = r8->size[b_x];
}
emxInit_real_T(sp, &c_z0, 2, &bb_emlrtRTEI, true);
emlrtSizeEqCheck2DFastR2012b(b_b, b_z0, &m_emlrtECI, sp);
b_x = c_z0->size[0] * c_z0->size[1];
c_z0->size[0] = 1;
c_z0->size[1] = z0->size[1];
emxEnsureCapacity(sp, (emxArray__common *)c_z0, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = z0->size[0] * z0->size[1];
for (b_x = 0; b_x < i; b_x++) {
c_z0->data[b_x] = z0->data[b_x];
}
b_erf(sp, c_z0, z0);
b_erf(sp, z1, d_x);
emxFree_real_T(&c_z0);
emxFree_real_T(&z1);
for (b_x = 0; b_x < 2; b_x++) {
b_z0[b_x] = z0->size[b_x];
}
for (b_x = 0; b_x < 2; b_x++) {
f_x[b_x] = d_x->size[b_x];
}
emlrtSizeEqCheck2DFastR2012b(b_z0, f_x, &n_emlrtECI, sp);
b_x = z0->size[0] * z0->size[1];
z0->size[0] = 1;
emxEnsureCapacity(sp, (emxArray__common *)z0, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = z0->size[0];
b_x = z0->size[1];
i *= b_x;
for (b_x = 0; b_x < i; b_x++) {
z0->data[b_x] = 1.7724538509055159 * (z0->data[b_x] - d_x->
data[b_x]);
}
for (b_x = 0; b_x < 2; b_x++) {
b_b[b_x] = b->size[b_x];
}
for (b_x = 0; b_x < 2; b_x++) {
b_z0[b_x] = z0->size[b_x];
}
emxInit_real_T(sp, &k_x, 2, &bb_emlrtRTEI, true);
emlrtSizeEqCheck2DFastR2012b(b_b, b_z0, &m_emlrtECI, sp);
b_x = k_x->size[0] * k_x->size[1];
k_x->size[0] = 1;
k_x->size[1] = x->size[1];
emxEnsureCapacity(sp, (emxArray__common *)k_x, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = x->size[0] * x->size[1];
for (b_x = 0; b_x < i; b_x++) {
k_x->data[b_x] = x->data[b_x] - ksi;
}
b_abs(sp, k_x, d_x);
rdivide(sp, d_x, 3.5449077018110318, vals);
st.site = &ue_emlrtRSI;
b_x = b->size[0] * b->size[1];
b->size[0] = 1;
emxEnsureCapacity(&st, (emxArray__common *)b, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
i = b->size[0];
b_x = b->size[1];
i *= b_x;
emxFree_real_T(&k_x);
for (b_x = 0; b_x < i; b_x++) {
b->data[b_x] = (b->data[b_x] - r8->data[b_x]) + z0->data[b_x];
}
b_st.site = &he_emlrtRSI;
if (!(vals->size[1] == 1)) {
if ((vals->size[1] == 1) || (b->size[1] == 1)) {
c_y = NULL;
m6 = emlrtCreateCharArray(2, iv18);
for (i = 0; i < 45; i++) {
cv18[i] = cv19[i];
}
emlrtInitCharArrayR2013a(&b_st, 45, m6, cv18);
emlrtAssign(&c_y, m6);
c_st.site = &fh_emlrtRSI;
d_st.site = &vg_emlrtRSI;
b_error(&c_st, message(&d_st, c_y, &j_emlrtMCI), &k_emlrtMCI);
} else {
d_y = NULL;
m6 = emlrtCreateCharArray(2, iv19);
for (i = 0; i < 21; i++) {
cv20[i] = cv21[i];
}
emlrtInitCharArrayR2013a(&b_st, 21, m6, cv20);
emlrtAssign(&d_y, m6);
c_st.site = &gh_emlrtRSI;
d_st.site = &wg_emlrtRSI;
b_error(&c_st, message(&d_st, d_y, &l_emlrtMCI), &m_emlrtMCI);
}
}
c_x = vals->data[0];
b_x = vals->size[0] * vals->size[1];
vals->size[0] = 1;
vals->size[1] = b->size[1];
emxEnsureCapacity(&st, (emxArray__common *)vals, b_x, (int32_T)
sizeof(real_T), &bb_emlrtRTEI);
i = b->size[1];
for (b_x = 0; b_x < i; b_x++) {
vals->data[vals->size[0] * b_x] = c_x * b->data[b->size[0] * b_x];
}
} else {
b_x = vals->size[0] * vals->size[1];
vals->size[0] = 1;
vals->size[1] = 1;
emxEnsureCapacity(sp, (emxArray__common *)vals, b_x, (int32_T)sizeof
(real_T), &bb_emlrtRTEI);
vals->data[0] = 0.0;
}
emxFree_boolean_T(&e_t);
}
emxFree_boolean_T(&d_t);
}
emxFree_boolean_T(&c_t);
emxFree_real_T(&d_x);
emxFree_real_T(&z0);
}
emxFree_boolean_T(&b_t);
}
emxFree_real_T(&r8);
emxFree_real_T(&b);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
}