static real_T m_fprintf(const emlrtStack *sp, const char_T varargin_1_data[77],
const int32_T varargin_1_size[2])
{
const mxArray *y;
static const int32_T iv136[2] = { 1, 7 };
const mxArray *m32;
char_T cv168[7];
int32_T i;
static const char_T cv169[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv137[2] = { 1, 22 };
char_T cv170[22];
static const char_T cv171[22] = { 'M', 'A', 'C', '|', ' ', 'G', 'o', 't', ' ',
'm', 'e', 's', 's', 'a', 'g', 'e', ':', ' ', '%', 's', '\\', 'n' };
int32_T u_size[2];
int32_T i29;
char_T u_data[77];
const mxArray *d_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m32 = mxCreateCharArray(2, iv136);
for (i = 0; i < 7; i++) {
cv168[i] = cv169[i];
}
emlrtInitCharArrayR2013a(sp, 7, m32, cv168);
emlrtAssign(&y, m32);
b_y = NULL;
m32 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m32);
c_y = NULL;
m32 = mxCreateCharArray(2, iv137);
for (i = 0; i < 22; i++) {
cv170[i] = cv171[i];
}
emlrtInitCharArrayR2013a(sp, 22, m32, cv170);
emlrtAssign(&c_y, m32);
u_size[0] = 1;
u_size[1] = varargin_1_size[1];
i = varargin_1_size[0] * varargin_1_size[1];
for (i29 = 0; i29 < i; i29++) {
u_data[i29] = varargin_1_data[i29];
}
d_y = NULL;
m32 = mxCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m32, (char_T *)&u_data);
emlrtAssign(&d_y, m32);
st.site = &ew_emlrtRSI;
return c_emlrt_marshallIn(&st, b_feval(&st, y, b_y, c_y, d_y, &n_emlrtMCI),
"feval");
}
static real_T k_fprintf(const emlrtStack *sp, const char_T varargin_1_data[76],
const int32_T varargin_1_size[2])
{
const mxArray *y;
static const int32_T iv134[2] = { 1, 7 };
const mxArray *m31;
char_T cv164[7];
int32_T i;
static const char_T cv165[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv135[2] = { 1, 18 };
char_T cv166[18];
static const char_T cv167[18] = { 'D', 'L', '|', ' ', 'M', 'e', 's', 's', 'a',
'g', 'e', '=', '|', '%', 's', '|', '\\', 'n' };
int32_T u_size[2];
int32_T i28;
char_T u_data[76];
const mxArray *d_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m31 = mxCreateCharArray(2, iv134);
for (i = 0; i < 7; i++) {
cv164[i] = cv165[i];
}
emlrtInitCharArrayR2013a(sp, 7, m31, cv164);
emlrtAssign(&y, m31);
b_y = NULL;
m31 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m31);
c_y = NULL;
m31 = mxCreateCharArray(2, iv135);
for (i = 0; i < 18; i++) {
cv166[i] = cv167[i];
}
emlrtInitCharArrayR2013a(sp, 18, m31, cv166);
emlrtAssign(&c_y, m31);
u_size[0] = 1;
u_size[1] = varargin_1_size[1];
i = varargin_1_size[0] * varargin_1_size[1];
for (i28 = 0; i28 < i; i28++) {
u_data[i28] = varargin_1_data[i28];
}
d_y = NULL;
m31 = mxCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m31, (char_T *)&u_data);
emlrtAssign(&d_y, m31);
st.site = &ew_emlrtRSI;
return c_emlrt_marshallIn(&st, b_feval(&st, y, b_y, c_y, d_y, &n_emlrtMCI),
"feval");
}
static real_T s_fprintf(const emlrtStack *sp, int16_T varargin_1, real_T
varargin_2)
{
const mxArray *y;
static const int32_T iv142[2] = { 1, 7 };
const mxArray *m35;
char_T cv180[7];
int32_T i;
static const char_T cv181[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv143[2] = { 1, 43 };
char_T cv182[43];
static const char_T cv183[43] = { 'T', 'r', 'a', 'n', 's', 'm', 'i', 't', 't',
'i', 'n', 'g', ' ', 't', 'o', ' ', 'n', 'o', 'd', 'e', ':', ' ', '%', 'd',
',', ' ', 'w', 'i', 't', 'h', ' ', 'o', 'f', 'f', 's', 'e', 't', ':', ' ',
'%', 'f', '\\', 'n' };
const mxArray *d_y;
const mxArray *e_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m35 = mxCreateCharArray(2, iv142);
for (i = 0; i < 7; i++) {
cv180[i] = cv181[i];
}
emlrtInitCharArrayR2013a(sp, 7, m35, cv180);
emlrtAssign(&y, m35);
b_y = NULL;
m35 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m35);
c_y = NULL;
m35 = mxCreateCharArray(2, iv143);
for (i = 0; i < 43; i++) {
cv182[i] = cv183[i];
}
emlrtInitCharArrayR2013a(sp, 43, m35, cv182);
emlrtAssign(&c_y, m35);
d_y = NULL;
m35 = mxCreateNumericMatrix(1, 1, mxINT16_CLASS, mxREAL);
*(int16_T *)mxGetData(m35) = varargin_1;
emlrtAssign(&d_y, m35);
e_y = NULL;
m35 = mxCreateDoubleScalar(varargin_2);
emlrtAssign(&e_y, m35);
st.site = &ew_emlrtRSI;
return c_emlrt_marshallIn(&st, c_feval(&st, y, b_y, c_y, d_y, e_y, &n_emlrtMCI),
"feval");
}
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);
}
/* Function Definitions */
void dynamic_size_checks(const emxArray_creal_T *a, const emxArray_creal_T *b)
{
const mxArray *y;
static const int32_T iv32[2] = { 1, 45 };
const mxArray *m5;
char_T cv18[45];
int32_T i;
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 iv33[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' };
if (!(a->size[1] == b->size[0])) {
if (((a->size[0] == 1) && (a->size[1] == 1)) || ((b->size[0] == 1) &&
(b->size[1] == 1))) {
emlrtPushRtStackR2012b(&ih_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m5 = mxCreateCharArray(2, iv32);
for (i = 0; i < 45; i++) {
cv18[i] = cv19[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 45, m5, cv18);
emlrtAssign(&y, m5);
error(message(y, &l_emlrtMCI), &m_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&ih_emlrtRSI, emlrtRootTLSGlobal);
} else {
emlrtPushRtStackR2012b(&hh_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
b_y = NULL;
m5 = mxCreateCharArray(2, iv33);
for (i = 0; i < 21; i++) {
cv20[i] = cv21[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m5, cv20);
emlrtAssign(&b_y, m5);
error(message(b_y, &n_emlrtMCI), &o_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&hh_emlrtRSI, emlrtRootTLSGlobal);
}
}
}
static real_T o_fprintf(const emlrtStack *sp, int16_T varargin_1)
{
const mxArray *y;
static const int32_T iv138[2] = { 1, 7 };
const mxArray *m33;
char_T cv172[7];
int32_T i;
static const char_T cv173[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv139[2] = { 1, 20 };
char_T cv174[20];
static const char_T cv175[20] = { 'M', 'A', 'C', '|', ' ', 'F', 'r', 'o', 'm',
' ', 'N', 'o', 'd', 'e', ':', ' ', '%', 'd', '\\', 'n' };
const mxArray *d_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m33 = mxCreateCharArray(2, iv138);
for (i = 0; i < 7; i++) {
cv172[i] = cv173[i];
}
emlrtInitCharArrayR2013a(sp, 7, m33, cv172);
emlrtAssign(&y, m33);
b_y = NULL;
m33 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m33);
c_y = NULL;
m33 = mxCreateCharArray(2, iv139);
for (i = 0; i < 20; i++) {
cv174[i] = cv175[i];
}
emlrtInitCharArrayR2013a(sp, 20, m33, cv174);
emlrtAssign(&c_y, m33);
d_y = NULL;
m33 = mxCreateNumericMatrix(1, 1, mxINT16_CLASS, mxREAL);
*(int16_T *)mxGetData(m33) = varargin_1;
emlrtAssign(&d_y, m33);
st.site = &ew_emlrtRSI;
return c_emlrt_marshallIn(&st, b_feval(&st, y, b_y, c_y, d_y, &n_emlrtMCI),
"feval");
}
static void eml_warning(void)
{
const mxArray *y;
static const int32_T iv3[2] = { 1, 27 };
const mxArray *m2;
char_T cv4[27];
int32_T i;
static const char_T cv5[27] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 's', 'i', 'n', 'g', 'u', 'l', 'a', 'r', 'M', 'a', 't',
'r', 'i', 'x' };
emlrtPushRtStackR2012b(&lc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m2 = mxCreateCharArray(2, iv3);
for (i = 0; i < 27; i++) {
cv4[i] = cv5[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 27, m2, cv4);
emlrtAssign(&y, m2);
warning(b_message(y, &d_emlrtMCI), &e_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&lc_emlrtRSI, emlrtRootTLSGlobal);
}
/* Function Definitions */
static real_T c_fprintf(const emlrtStack *sp)
{
const mxArray *y;
static const int32_T iv8[2] = { 1, 7 };
const mxArray *m1;
char_T cv14[7];
int32_T i;
static const char_T cv15[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv9[2] = { 1, 50 };
char_T cv16[50];
static const char_T cv17[50] = { 'R', 'e', 'm', 'e', 'm', 'b', 'e', 'r', ' ',
't', 'o', ' ', 'c', 'o', 'm', 'p', 'a', 'r', 'e', ' ', 'o', 'u', 't', 'p',
'u', 't', ' ', 'f', 'i', 'l', 'e', 's', ' ', 'w', 'i', 't', 'h', ' ', 'm',
'd', '5', ' ', 'o', 'r', ' ', 'S', 'H', 'A', '\\', 'n' };
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m1 = mxCreateCharArray(2, iv8);
for (i = 0; i < 7; i++) {
cv14[i] = cv15[i];
}
emlrtInitCharArrayR2013a(sp, 7, m1, cv14);
emlrtAssign(&y, m1);
b_y = NULL;
m1 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m1);
c_y = NULL;
m1 = mxCreateCharArray(2, iv9);
for (i = 0; i < 50; i++) {
cv16[i] = cv17[i];
}
emlrtInitCharArrayR2013a(sp, 50, m1, cv16);
emlrtAssign(&c_y, m1);
st.site = &cb_emlrtRSI;
return e_emlrt_marshallIn(&st, feval(&st, y, b_y, c_y, &r_emlrtMCI), "feval");
}
/* Function Definitions */
void check_forloop_overflow_error(const emlrtStack *sp)
{
const mxArray *y;
static const int32_T iv21[2] = { 1, 34 };
const mxArray *m4;
char_T cv27[34];
int32_T i;
static const char_T cv28[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 iv22[2] = { 1, 23 };
char_T cv29[23];
static const char_T cv30[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;
m4 = mxCreateCharArray(2, iv21);
for (i = 0; i < 34; i++) {
cv27[i] = cv28[i];
}
emlrtInitCharArrayR2013a(sp, 34, m4, cv27);
emlrtAssign(&y, m4);
b_y = NULL;
m4 = mxCreateCharArray(2, iv22);
for (i = 0; i < 23; i++) {
cv29[i] = cv30[i];
}
emlrtInitCharArrayR2013a(sp, 23, m4, cv29);
emlrtAssign(&b_y, m4);
st.site = &vm_emlrtRSI;
b_st.site = &ym_emlrtRSI;
c_error(&st, message(&b_st, y, b_y, &e_emlrtMCI), &f_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);
}
/* Function Definitions */
static real_T c_fprintf(real_T varargin_1)
{
real_T nbytes;
const mxArray *y;
static const int32_T iv46[2] = { 1, 7 };
const mxArray *m6;
char_T cv22[7];
int32_T i;
static const char_T cv23[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
static const int32_T iv47[2] = { 1, 48 };
char_T cv24[48];
static const char_T cv25[48] = { 'E', 'r', 'r', 'o', 'r', ':', ' ', 'm', 'a',
't', 'r', 'i', 'x', ' ', 's', 'q', 'u', 'a', 'r', 'e', ' ', 'r', 'o', 'o',
't', ' ', 'r', 'e', 's', 'i', 'd', 'u', 'a', 'l', ' ', 'n', 'o', 'r', 'm',
' ', 'i', 's', ' ', '%', 'g', '.', '\\', 'n' };
emlrtPushRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m6 = mxCreateCharArray(2, iv46);
for (i = 0; i < 7; i++) {
cv22[i] = cv23[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m6, cv22);
emlrtAssign(&y, m6);
b_y = NULL;
m6 = mxCreateCharArray(2, iv47);
for (i = 0; i < 48; i++) {
cv24[i] = cv25[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 48, m6, cv24);
emlrtAssign(&b_y, m6);
nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
emlrt_marshallOut(varargin_1), &p_emlrtMCI), "feval");
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
return nbytes;
}
static real_T e_fprintf(const emlrtStack *sp)
{
const mxArray *y;
static const int32_T iv10[2] = { 1, 7 };
const mxArray *m2;
char_T cv18[7];
int32_T i;
static const char_T cv19[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv11[2] = { 1, 31 };
char_T cv20[31];
static const char_T cv21[31] = { 'f', 'i', 'l', 'e', 'S', 'o', 'u', 'r', 'c',
'e', 'S', 'i', 'n', 'k', ' ', 'T', 'e', 's', 't', ' ', 'C', 'o', 'm', 'p',
'l', 'e', 't', 'e', 'd', '\\', 'n' };
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m2 = mxCreateCharArray(2, iv10);
for (i = 0; i < 7; i++) {
cv18[i] = cv19[i];
}
emlrtInitCharArrayR2013a(sp, 7, m2, cv18);
emlrtAssign(&y, m2);
b_y = NULL;
m2 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m2);
c_y = NULL;
m2 = mxCreateCharArray(2, iv11);
for (i = 0; i < 31; i++) {
cv20[i] = cv21[i];
}
emlrtInitCharArrayR2013a(sp, 31, m2, cv20);
emlrtAssign(&c_y, m2);
st.site = &cb_emlrtRSI;
return e_emlrt_marshallIn(&st, feval(&st, y, b_y, c_y, &r_emlrtMCI), "feval");
}
static real_T i_fprintf(const emlrtStack *sp)
{
const mxArray *y;
static const int32_T iv84[2] = { 1, 7 };
const mxArray *m17;
char_T cv98[7];
int32_T i;
static const char_T cv99[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv85[2] = { 1, 26 };
char_T cv100[26];
static const char_T cv101[26] = { 'D', 'L', '|', ' ', 'M', 'a', 'x', ' ', 't',
'i', 'm', 'e', 'o', 'u', 't', 's', ' ', 'r', 'e', 'a', 'c', 'h', 'e', 'd',
'\\', 'n' };
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m17 = mxCreateCharArray(2, iv84);
for (i = 0; i < 7; i++) {
cv98[i] = cv99[i];
}
emlrtInitCharArrayR2013a(sp, 7, m17, cv98);
emlrtAssign(&y, m17);
b_y = NULL;
m17 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m17);
c_y = NULL;
m17 = mxCreateCharArray(2, iv85);
for (i = 0; i < 26; i++) {
cv100[i] = cv101[i];
}
emlrtInitCharArrayR2013a(sp, 26, m17, cv100);
emlrtAssign(&c_y, m17);
st.site = &ew_emlrtRSI;
return c_emlrt_marshallIn(&st, feval(&st, y, b_y, c_y, &n_emlrtMCI), "feval");
}
static real_T u_fprintf(const emlrtStack *sp)
{
const mxArray *y;
static const int32_T iv201[2] = { 1, 7 };
const mxArray *m43;
char_T cv249[7];
int32_T i;
static const char_T cv250[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv202[2] = { 1, 32 };
char_T cv251[32];
static const char_T cv252[32] = { 'M', 'A', 'C', '|', ' ', 'T', 'r', 'a', 'n',
's', 'm', 'i', 't', 't', 'i', 'n', 'g', ' ', 'A', 'C', 'K', ' ', 'f', 'o',
'r', ' ', 'd', 'u', 'p', 'e', '\\', 'n' };
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m43 = mxCreateCharArray(2, iv201);
for (i = 0; i < 7; i++) {
cv249[i] = cv250[i];
}
emlrtInitCharArrayR2013a(sp, 7, m43, cv249);
emlrtAssign(&y, m43);
b_y = NULL;
m43 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m43);
c_y = NULL;
m43 = mxCreateCharArray(2, iv202);
for (i = 0; i < 32; i++) {
cv251[i] = cv252[i];
}
emlrtInitCharArrayR2013a(sp, 32, m43, cv251);
emlrtAssign(&c_y, m43);
st.site = &ew_emlrtRSI;
return c_emlrt_marshallIn(&st, feval(&st, y, b_y, c_y, &n_emlrtMCI), "feval");
}
void error(const emlrtStack *sp, const char_T varargin_2_data[1024], const
int32_T varargin_2_size[2])
{
const mxArray *y;
static const int32_T iv103[2] = { 1, 37 };
const mxArray *m18;
char_T cv117[37];
int32_T i;
static const char_T cv118[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 i16;
char_T u_data[1024];
const mxArray *b_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m18 = mxCreateCharArray(2, iv103);
for (i = 0; i < 37; i++) {
cv117[i] = cv118[i];
}
emlrtInitCharArrayR2013a(sp, 37, m18, cv117);
emlrtAssign(&y, m18);
u_size[0] = 1;
u_size[1] = varargin_2_size[1];
i = varargin_2_size[0] * varargin_2_size[1];
for (i16 = 0; i16 < i; i16++) {
u_data[i16] = varargin_2_data[i16];
}
b_y = NULL;
m18 = mxCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m18, (char_T *)&u_data);
emlrtAssign(&b_y, m18);
st.site = &hr_emlrtRSI;
c_error(&st, y, b_y, &r_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);
}
static real_T g_fprintf(const emlrtStack *sp)
{
const mxArray *y;
static const int32_T iv82[2] = { 1, 7 };
const mxArray *m16;
char_T cv94[7];
int32_T i;
static const char_T cv95[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv83[2] = { 1, 21 };
char_T cv96[21];
static const char_T cv97[21] = { 'D', 'L', '|', ' ', 'T', 'i', 'm', 'e', 'o',
'u', 't', ' ', 'o', 'c', 'c', 'u', 'r', 'e', 'd', '\\', 'n' };
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m16 = mxCreateCharArray(2, iv82);
for (i = 0; i < 7; i++) {
cv94[i] = cv95[i];
}
emlrtInitCharArrayR2013a(sp, 7, m16, cv94);
emlrtAssign(&y, m16);
b_y = NULL;
m16 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m16);
c_y = NULL;
m16 = mxCreateCharArray(2, iv83);
for (i = 0; i < 21; i++) {
cv96[i] = cv97[i];
}
emlrtInitCharArrayR2013a(sp, 21, m16, cv96);
emlrtAssign(&c_y, m16);
st.site = &ew_emlrtRSI;
return c_emlrt_marshallIn(&st, feval(&st, y, b_y, c_y, &n_emlrtMCI), "feval");
}
static real_T c_fprintf(const emlrtStack *sp)
{
const mxArray *y;
static const int32_T iv78[2] = { 1, 7 };
const mxArray *m14;
char_T cv86[7];
int32_T i;
static const char_T cv87[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
const mxArray *c_y;
static const int32_T iv79[2] = { 1, 23 };
char_T cv88[23];
static const char_T cv89[23] = { 'D', 'L', '|', ' ', 'D', 'u', 'p', 'l', 'i',
'c', 'a', 't', 'e', ' ', 'M', 'e', 's', 's', 'a', 'g', 'e', '\\', 'n' };
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m14 = mxCreateCharArray(2, iv78);
for (i = 0; i < 7; i++) {
cv86[i] = cv87[i];
}
emlrtInitCharArrayR2013a(sp, 7, m14, cv86);
emlrtAssign(&y, m14);
b_y = NULL;
m14 = mxCreateDoubleScalar(1.0);
emlrtAssign(&b_y, m14);
c_y = NULL;
m14 = mxCreateCharArray(2, iv79);
for (i = 0; i < 23; i++) {
cv88[i] = cv89[i];
}
emlrtInitCharArrayR2013a(sp, 23, m14, cv88);
emlrtAssign(&c_y, m14);
st.site = &ew_emlrtRSI;
return c_emlrt_marshallIn(&st, feval(&st, y, b_y, c_y, &n_emlrtMCI), "feval");
}
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 b_error(const emlrtStack *sp, const char_T varargin_2_data[1024], const
int32_T varargin_2_size[2])
{
const mxArray *y;
static const int32_T iv174[2] = { 1, 41 };
const mxArray *m31;
char_T cv203[41];
int32_T i;
static const char_T cv204[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 i20;
char_T u_data[1024];
const mxArray *b_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m31 = mxCreateCharArray(2, iv174);
for (i = 0; i < 41; i++) {
cv203[i] = cv204[i];
}
emlrtInitCharArrayR2013a(sp, 41, m31, cv203);
emlrtAssign(&y, m31);
u_size[0] = 1;
u_size[1] = varargin_2_size[1];
i = varargin_2_size[0] * varargin_2_size[1];
for (i20 = 0; i20 < i; i20++) {
u_data[i20] = varargin_2_data[i20];
}
b_y = NULL;
m31 = mxCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m31, (char_T *)&u_data);
emlrtAssign(&b_y, m31);
st.site = &acb_emlrtRSI;
d_error(&st, y, b_y, &r_emlrtMCI);
}
static real_T e_fprintf(real_T varargin_1)
{
real_T nbytes;
const mxArray *y;
static const int32_T iv2[2] = { 1, 7 };
const mxArray *m1;
char_T cv4[7];
int32_T i;
static const char_T cv5[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
static const int32_T iv3[2] = { 1, 25 };
char_T cv6[25];
static const char_T cv7[25] = { 'B', 'E', 'R', ' ', 'f', 'o', 'r', ' ', 'p',
'r', 'e', 'a', 'm', 'b', 'l', 'e', ':', ' ', '%', '.', '1', '0', 'f', '\\',
'n' };
emlrtPushRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m1 = mxCreateCharArray(2, iv2);
for (i = 0; i < 7; i++) {
cv4[i] = cv5[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m1, cv4);
emlrtAssign(&y, m1);
b_y = NULL;
m1 = mxCreateCharArray(2, iv3);
for (i = 0; i < 25; i++) {
cv6[i] = cv7[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 25, m1, cv6);
emlrtAssign(&b_y, m1);
nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
emlrt_marshallOut(varargin_1), &emlrtMCI), "feval");
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
return nbytes;
}
void error(const emlrtStack *sp, const char_T varargin_2_data[1024], const
int32_T varargin_2_size[2])
{
const mxArray *y;
static const int32_T iv122[2] = { 1, 37 };
const mxArray *m20;
char_T cv141[37];
int32_T i;
static const char_T cv142[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 i17;
char_T u_data[1024];
const mxArray *b_y;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
y = NULL;
m20 = mxCreateCharArray(2, iv122);
for (i = 0; i < 37; i++) {
cv141[i] = cv142[i];
}
emlrtInitCharArrayR2013a(sp, 37, m20, cv141);
emlrtAssign(&y, m20);
u_size[0] = 1;
u_size[1] = varargin_2_size[1];
i = varargin_2_size[0] * varargin_2_size[1];
for (i17 = 0; i17 < i; i17++) {
u_data[i17] = varargin_2_data[i17];
}
b_y = NULL;
m20 = mxCreateCharArray(2, u_size);
emlrtInitCharArrayR2013a(sp, u_size[1], m20, (char_T *)&u_data);
emlrtAssign(&b_y, m20);
st.site = &acb_emlrtRSI;
d_error(&st, y, b_y, &r_emlrtMCI);
}
/* Function Definitions */
static real_T c_fprintf(real_T varargin_1)
{
real_T nbytes;
const mxArray *y;
static const int32_T iv0[2] = { 1, 7 };
const mxArray *m0;
char_T cv0[7];
int32_T i;
static const char_T cv1[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
static const int32_T iv1[2] = { 1, 21 };
char_T cv2[21];
static const char_T cv3[21] = { 'B', 'E', 'R', ' ', 'f', 'o', 'r', ' ', 'd',
'a', 't', 'a', ':', ' ', '%', '.', '1', '0', 'f', '\\', 'n' };
emlrtPushRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m0 = mxCreateCharArray(2, iv0);
for (i = 0; i < 7; i++) {
cv0[i] = cv1[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m0, cv0);
emlrtAssign(&y, m0);
b_y = NULL;
m0 = mxCreateCharArray(2, iv1);
for (i = 0; i < 21; i++) {
cv2[i] = cv3[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m0, cv2);
emlrtAssign(&b_y, m0);
nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
emlrt_marshallOut(varargin_1), &emlrtMCI), "feval");
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
return nbytes;
}
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);
}
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 check_forloop_overflow_error(void)
{
const mxArray *y;
static const int32_T iv0[2] = { 1, 34 };
const mxArray *m1;
char_T cv0[34];
int32_T i;
static const char_T cv1[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 iv1[2] = { 1, 23 };
char_T cv2[23];
static const char_T cv3[23] = { 'c', 'o', 'd', 'e', 'r', '.', 'i', 'n', 't',
'e', 'r', 'n', 'a', 'l', '.', 'i', 'n', 'd', 'e', 'x', 'I', 'n', 't' };
emlrtPushRtStackR2012b(&h_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m1 = mxCreateCharArray(2, iv0);
for (i = 0; i < 34; i++) {
cv0[i] = cv1[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 34, m1, cv0);
emlrtAssign(&y, m1);
b_y = NULL;
m1 = mxCreateCharArray(2, iv1);
for (i = 0; i < 23; i++) {
cv2[i] = cv3[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 23, m1, cv2);
emlrtAssign(&b_y, m1);
error(message(y, b_y, &b_emlrtMCI), &c_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&h_emlrtRSI, emlrtRootTLSGlobal);
}
/* 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;
}
/* 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];
}
}
