/* Function Definitions */
void PHYTransmit(testPHYTransmitStackData *SD, comm_SDRuTransmitter
*b_ObjSDRuTransmitter)
{
OFDMDemodulator *unusedU1;
OFDMDemodulator_1 *unusedU0;
OFDMDemodulator_1 b_unusedU0;
OFDMDemodulator b_unusedU1;
int32_T framesTransmitted;
/* Send Messages */
/* % Create message bits */
/* The output needs to be duplicated to long vectors to help prevent */
/* Underflow for the USRP */
emlrtPushRtStackR2012b(&ve_emlrtRSI, emlrtRootTLSGlobal);
b_generateOFDMSignal_TX2(&b_unusedU1, &b_unusedU0, &unusedU0, &unusedU1,
SD->u2.f4.dataToTx, &SD->u2.f4.unusedU2);
emlrtPopRtStackR2012b(&ve_emlrtRSI, emlrtRootTLSGlobal);
/* 30 Dupe frames created (NOTE! author shouldcreate shorter simpler function) */
/* % Run transmitter */
/* increasing value will help receiver, 10 */
/* This should be longer to help transmit over periods when the RX is */
/* cleaning its buffer */
for (framesTransmitted = 0; framesTransmitted < 10; framesTransmitted++) {
emlrtPushRtStackR2012b(&ue_emlrtRSI, emlrtRootTLSGlobal);
g_SystemCore_step(SD, b_ObjSDRuTransmitter, SD->u2.f4.dataToTx);
emlrtPopRtStackR2012b(&ue_emlrtRSI, emlrtRootTLSGlobal);
/* if mod(framesTransmitted,60) == 0 */
/* end */
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal);
}
/* obj.pSDRuTransmitter.reset;%stop transmitting? */
}
/* 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 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 */
void eml_signed_integer_colon(int32_T b, emxArray_int32_T *y)
{
int32_T n;
int32_T yk;
boolean_T b3;
int32_T k;
emlrtPushRtStackR2012b(&jl_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&wk_emlrtRSI, emlrtRootTLSGlobal);
if (b < 1) {
n = 0;
} else {
emlrtPushRtStackR2012b(&xk_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&xk_emlrtRSI, emlrtRootTLSGlobal);
n = b;
}
emlrtPopRtStackR2012b(&wk_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&jl_emlrtRSI, emlrtRootTLSGlobal);
yk = y->size[0] * y->size[1];
y->size[0] = 1;
y->size[1] = n;
emxEnsureCapacity((emxArray__common *)y, yk, (int32_T)sizeof(int32_T),
&mb_emlrtRTEI);
if (n > 0) {
y->data[0] = 1;
yk = 1;
emlrtPushRtStackR2012b(&kl_emlrtRSI, emlrtRootTLSGlobal);
if (2 > n) {
b3 = FALSE;
} else {
b3 = (n > 2147483646);
}
if (b3) {
emlrtPushRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
check_forloop_overflow_error();
emlrtPopRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&kl_emlrtRSI, emlrtRootTLSGlobal);
for (k = 2; k <= n; k++) {
yk++;
y->data[k - 1] = yk;
}
}
}
static boolean_T isUTmatD(const emxArray_creal_T *T)
{
boolean_T p;
int32_T j;
int32_T exitg2;
int32_T i;
int32_T exitg1;
boolean_T b_T;
emlrtPushRtStackR2012b(&hh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&hh_emlrtRSI, emlrtRootTLSGlobal);
j = 0;
do {
exitg2 = 0;
if (j + 1 <= T->size[1]) {
emlrtPushRtStackR2012b(&ih_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ih_emlrtRSI, emlrtRootTLSGlobal);
i = 1;
do {
exitg1 = 0;
if (i <= j) {
b_T = ((T->data[(i + T->size[0] * j) - 1].re != 0.0) || (T->data[(i +
T->size[0] * j) - 1].im != 0.0));
if (b_T) {
p = FALSE;
exitg1 = 1;
} else {
i++;
}
} else {
j++;
exitg1 = 2;
}
} while (exitg1 == 0);
if (exitg1 == 1) {
exitg2 = 1;
}
} else {
p = TRUE;
exitg2 = 1;
}
} while (exitg2 == 0);
return p;
}
/* Function Definitions */
static void eml_error(void)
{
static char_T cv0[4][1] = { { 's' }, { 'q' }, { 'r' }, { 't' } };
emlrtPushRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
emlrtErrorWithMessageIdR2012b(emlrtRootTLSGlobal, &emlrtRTEI,
"Coder:toolbox:ElFunDomainError", 3, 4, 4, cv0);
emlrtPopRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
}
void b_sqrt(real_T x[1000000])
{
int32_T k;
for (k = 0; k < 1000000; k++) {
if (x[k] < 0.0) {
emlrtPushRtStackR2012b(&y_emlrtRSI, emlrtRootTLSGlobal);
eml_error();
emlrtPopRtStackR2012b(&y_emlrtRSI, emlrtRootTLSGlobal);
}
}
for (k = 0; k < 1000000; k++) {
x[k] = muDoubleScalarSqrt(x[k]);
}
}
/* Function Definitions */
static real_T c_fprintf(real_T varargin_1)
{
real_T nbytes;
const mxArray *y;
static const int32_T iv46[2] = { 1, 7 };
const mxArray *m6;
char_T cv22[7];
int32_T i;
static const char_T cv23[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
static const int32_T iv47[2] = { 1, 48 };
char_T cv24[48];
static const char_T cv25[48] = { 'E', 'r', 'r', 'o', 'r', ':', ' ', 'm', 'a',
't', 'r', 'i', 'x', ' ', 's', 'q', 'u', 'a', 'r', 'e', ' ', 'r', 'o', 'o',
't', ' ', 'r', 'e', 's', 'i', 'd', 'u', 'a', 'l', ' ', 'n', 'o', 'r', 'm',
' ', 'i', 's', ' ', '%', 'g', '.', '\\', 'n' };
emlrtPushRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m6 = mxCreateCharArray(2, iv46);
for (i = 0; i < 7; i++) {
cv22[i] = cv23[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m6, cv22);
emlrtAssign(&y, m6);
b_y = NULL;
m6 = mxCreateCharArray(2, iv47);
for (i = 0; i < 48; i++) {
cv24[i] = cv25[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 48, m6, cv24);
emlrtAssign(&b_y, m6);
nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
emlrt_marshallOut(varargin_1), &p_emlrtMCI), "feval");
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
return nbytes;
}
static real_T e_fprintf(real_T varargin_1)
{
real_T nbytes;
const mxArray *y;
static const int32_T iv2[2] = { 1, 7 };
const mxArray *m1;
char_T cv4[7];
int32_T i;
static const char_T cv5[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
static const int32_T iv3[2] = { 1, 25 };
char_T cv6[25];
static const char_T cv7[25] = { 'B', 'E', 'R', ' ', 'f', 'o', 'r', ' ', 'p',
'r', 'e', 'a', 'm', 'b', 'l', 'e', ':', ' ', '%', '.', '1', '0', 'f', '\\',
'n' };
emlrtPushRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m1 = mxCreateCharArray(2, iv2);
for (i = 0; i < 7; i++) {
cv4[i] = cv5[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m1, cv4);
emlrtAssign(&y, m1);
b_y = NULL;
m1 = mxCreateCharArray(2, iv3);
for (i = 0; i < 25; i++) {
cv6[i] = cv7[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 25, m1, cv6);
emlrtAssign(&b_y, m1);
nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
emlrt_marshallOut(varargin_1), &emlrtMCI), "feval");
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
return nbytes;
}
/* Function Definitions */
static real_T c_fprintf(real_T varargin_1)
{
real_T nbytes;
const mxArray *y;
static const int32_T iv0[2] = { 1, 7 };
const mxArray *m0;
char_T cv0[7];
int32_T i;
static const char_T cv1[7] = { 'f', 'p', 'r', 'i', 'n', 't', 'f' };
const mxArray *b_y;
static const int32_T iv1[2] = { 1, 21 };
char_T cv2[21];
static const char_T cv3[21] = { 'B', 'E', 'R', ' ', 'f', 'o', 'r', ' ', 'd',
'a', 't', 'a', ':', ' ', '%', '.', '1', '0', 'f', '\\', 'n' };
emlrtPushRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m0 = mxCreateCharArray(2, iv0);
for (i = 0; i < 7; i++) {
cv0[i] = cv1[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 7, m0, cv0);
emlrtAssign(&y, m0);
b_y = NULL;
m0 = mxCreateCharArray(2, iv1);
for (i = 0; i < 21; i++) {
cv2[i] = cv3[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m0, cv2);
emlrtAssign(&b_y, m0);
nbytes = emlrt_marshallIn(feval(y, emlrt_marshallOut(1.0), b_y,
emlrt_marshallOut(varargin_1), &emlrtMCI), "feval");
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
return nbytes;
}
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);
}
real_T logpdf(const emxArray_real_T *x, const emxArray_real_T *A, real_T C)
{
real_T f;
emxArray_real_T *a;
int32_T i2;
int32_T i;
const mxArray *y;
static const int32_T iv2[2] = { 1, 45 };
const mxArray *m0;
char_T cv1[45];
static const char_T cv2[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 iv3[2] = { 1, 21 };
char_T cv3[21];
static const char_T cv4[21] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'i', 'n', 'n', 'e', 'r', 'd', 'i', 'm' };
emxArray_real_T *c_y;
int32_T loop_ub;
int32_T i3;
uint32_T unnamed_idx_0;
real_T alpha1;
real_T beta1;
char_T TRANSB;
char_T TRANSA;
ptrdiff_t m_t;
ptrdiff_t n_t;
ptrdiff_t k_t;
ptrdiff_t lda_t;
ptrdiff_t ldb_t;
ptrdiff_t ldc_t;
double * alpha1_t;
double * Aia0_t;
double * Bib0_t;
double * beta1_t;
double * Cic0_t;
emxArray_real_T *b_x;
boolean_T overflow;
boolean_T p;
int32_T exitg1;
const mxArray *d_y;
static const int32_T iv4[2] = { 1, 30 };
char_T cv5[30];
static const char_T cv6[30] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
'l', 'b', 'o', 'x', ':', 's', 'u', 'm', '_', 's', 'p', 'e', 'c', 'i', 'a',
'l', 'E', 'm', 'p', 't', 'y' };
const mxArray *e_y;
static const int32_T iv5[2] = { 1, 36 };
char_T cv7[36];
static const char_T cv8[36] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
'l', 'b', 'o', 'x', ':', 'a', 'u', 't', 'o', 'D', 'i', 'm', 'I', 'n', 'c',
'o', 'm', 'p', 'a', 't', 'i', 'b', 'i', 'l', 'i', 't', 'y' };
emxArray_real_T *b_a;
const mxArray *f_y;
static const int32_T iv6[2] = { 1, 45 };
const mxArray *g_y;
static const int32_T iv7[2] = { 1, 21 };
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
emxInit_real_T(&a, 2, &e_emlrtRTEI, TRUE);
emlrtPushRtStackR2012b(&h_emlrtRSI, emlrtRootTLSGlobal);
i2 = a->size[0] * a->size[1];
a->size[0] = A->size[0];
a->size[1] = A->size[1];
emxEnsureCapacity((emxArray__common *)a, i2, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
i = A->size[0] * A->size[1];
for (i2 = 0; i2 < i; i2++) {
a->data[i2] = -A->data[i2];
}
emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
if (!(a->size[1] == x->size[0])) {
if (((a->size[0] == 1) && (a->size[1] == 1)) || (x->size[0] == 1)) {
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
y = NULL;
m0 = mxCreateCharArray(2, iv2);
for (i = 0; i < 45; i++) {
cv1[i] = cv2[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 45, m0, cv1);
emlrtAssign(&y, m0);
error(message(y, &b_emlrtMCI), &c_emlrtMCI);
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
} else {
emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
b_y = NULL;
m0 = mxCreateCharArray(2, iv3);
for (i = 0; i < 21; i++) {
cv3[i] = cv4[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m0, cv3);
emlrtAssign(&b_y, m0);
error(message(b_y, &d_emlrtMCI), &e_emlrtMCI);
emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
}
}
emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
b_emxInit_real_T(&c_y, 1, &e_emlrtRTEI, TRUE);
if ((a->size[1] == 1) || (x->size[0] == 1)) {
i2 = c_y->size[0];
c_y->size[0] = a->size[0];
emxEnsureCapacity((emxArray__common *)c_y, i2, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
i = a->size[0];
for (i2 = 0; i2 < i; i2++) {
c_y->data[i2] = 0.0;
loop_ub = a->size[1];
for (i3 = 0; i3 < loop_ub; i3++) {
c_y->data[i2] += a->data[i2 + a->size[0] * i3] * x->data[i3];
}
}
} else {
unnamed_idx_0 = (uint32_T)a->size[0];
emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
i2 = c_y->size[0];
c_y->size[0] = (int32_T)unnamed_idx_0;
emxEnsureCapacity((emxArray__common *)c_y, i2, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
i = (int32_T)unnamed_idx_0;
for (i2 = 0; i2 < i; i2++) {
c_y->data[i2] = 0.0;
}
if ((a->size[0] < 1) || (a->size[1] < 1)) {
} else {
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
alpha1 = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
m_t = (ptrdiff_t)(a->size[0]);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
n_t = (ptrdiff_t)(1);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
k_t = (ptrdiff_t)(a->size[1]);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
lda_t = (ptrdiff_t)(a->size[0]);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&y_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
ldb_t = (ptrdiff_t)(a->size[1]);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&y_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
ldc_t = (ptrdiff_t)(a->size[0]);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&bb_emlrtRSI, emlrtRootTLSGlobal);
alpha1_t = (double *)(&alpha1);
emlrtPopRtStackR2012b(&bb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&cb_emlrtRSI, emlrtRootTLSGlobal);
Aia0_t = (double *)(&a->data[0]);
emlrtPopRtStackR2012b(&cb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
Bib0_t = (double *)(&x->data[0]);
emlrtPopRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
Cic0_t = (double *)(&c_y->data[0]);
emlrtPopRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal);
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t,
&ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
}
emxFree_real_T(&a);
b_emxInit_real_T(&b_x, 1, &e_emlrtRTEI, TRUE);
i2 = b_x->size[0];
b_x->size[0] = c_y->size[0];
emxEnsureCapacity((emxArray__common *)b_x, i2, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
i = c_y->size[0];
for (i2 = 0; i2 < i; i2++) {
b_x->data[i2] = c_y->data[i2];
}
for (i = 0; i < c_y->size[0]; i++) {
b_x->data[i] = muDoubleScalarExp(b_x->data[i]);
}
i2 = b_x->size[0];
emxEnsureCapacity((emxArray__common *)b_x, i2, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
i = b_x->size[0];
for (i2 = 0; i2 < i; i2++) {
b_x->data[i2]++;
}
i2 = c_y->size[0];
c_y->size[0] = b_x->size[0];
emxEnsureCapacity((emxArray__common *)c_y, i2, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
i = b_x->size[0];
for (i2 = 0; i2 < i; i2++) {
c_y->data[i2] = b_x->data[i2];
}
for (i = 0; i < b_x->size[0]; i++) {
if (b_x->data[i] < 0.0) {
emlrtPushRtStackR2012b(&e_emlrtRSI, emlrtRootTLSGlobal);
eml_error();
emlrtPopRtStackR2012b(&e_emlrtRSI, emlrtRootTLSGlobal);
}
}
for (i = 0; i < b_x->size[0]; i++) {
c_y->data[i] = muDoubleScalarLog(c_y->data[i]);
}
emxFree_real_T(&b_x);
overflow = FALSE;
p = FALSE;
i = 0;
do {
exitg1 = 0;
if (i < 2) {
if (i + 1 <= 1) {
i2 = c_y->size[0];
} else {
i2 = 1;
}
if (i2 != 0) {
exitg1 = 1;
} else {
i++;
}
} else {
p = TRUE;
exitg1 = 1;
}
} while (exitg1 == 0);
if (!p) {
} else {
overflow = TRUE;
}
if (!overflow) {
} else {
emlrtPushRtStackR2012b(&ib_emlrtRSI, emlrtRootTLSGlobal);
d_y = NULL;
m0 = mxCreateCharArray(2, iv4);
for (i = 0; i < 30; i++) {
cv5[i] = cv6[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 30, m0, cv5);
emlrtAssign(&d_y, m0);
error(message(d_y, &h_emlrtMCI), &i_emlrtMCI);
emlrtPopRtStackR2012b(&ib_emlrtRSI, emlrtRootTLSGlobal);
}
if ((c_y->size[0] == 1) || (c_y->size[0] != 1)) {
overflow = TRUE;
} else {
overflow = FALSE;
}
if (overflow) {
} else {
emlrtPushRtStackR2012b(&jb_emlrtRSI, emlrtRootTLSGlobal);
e_y = NULL;
m0 = mxCreateCharArray(2, iv5);
for (i = 0; i < 36; i++) {
cv7[i] = cv8[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 36, m0, cv7);
emlrtAssign(&e_y, m0);
error(message(e_y, &j_emlrtMCI), &k_emlrtMCI);
emlrtPopRtStackR2012b(&jb_emlrtRSI, emlrtRootTLSGlobal);
}
if (c_y->size[0] == 0) {
alpha1 = 0.0;
} else {
alpha1 = c_y->data[0];
emlrtPushRtStackR2012b(&kb_emlrtRSI, emlrtRootTLSGlobal);
if (2 > c_y->size[0]) {
overflow = FALSE;
} else {
overflow = (c_y->size[0] > 2147483646);
}
if (overflow) {
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
check_forloop_overflow_error();
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&kb_emlrtRSI, emlrtRootTLSGlobal);
for (i = 2; i <= c_y->size[0]; i++) {
alpha1 += c_y->data[i - 1];
}
}
emxFree_real_T(&c_y);
emxInit_real_T(&b_a, 2, &e_emlrtRTEI, TRUE);
i2 = b_a->size[0] * b_a->size[1];
b_a->size[0] = 1;
emxEnsureCapacity((emxArray__common *)b_a, i2, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
i = x->size[0];
i2 = b_a->size[0] * b_a->size[1];
b_a->size[1] = i;
emxEnsureCapacity((emxArray__common *)b_a, i2, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
i = x->size[0];
for (i2 = 0; i2 < i; i2++) {
b_a->data[i2] = x->data[i2];
}
emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
if (!(b_a->size[1] == x->size[0])) {
if ((b_a->size[1] == 1) || (x->size[0] == 1)) {
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
f_y = NULL;
m0 = mxCreateCharArray(2, iv6);
for (i = 0; i < 45; i++) {
cv1[i] = cv2[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 45, m0, cv1);
emlrtAssign(&f_y, m0);
error(message(f_y, &b_emlrtMCI), &c_emlrtMCI);
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
} else {
emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
g_y = NULL;
m0 = mxCreateCharArray(2, iv7);
for (i = 0; i < 21; i++) {
cv3[i] = cv4[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m0, cv3);
emlrtAssign(&g_y, m0);
error(message(g_y, &d_emlrtMCI), &e_emlrtMCI);
emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
}
}
emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
if ((b_a->size[1] == 1) || (x->size[0] == 1)) {
beta1 = 0.0;
for (i2 = 0; i2 < b_a->size[1]; i2++) {
beta1 += b_a->data[b_a->size[0] * i2] * x->data[i2];
}
} else {
emlrtPushRtStackR2012b(&lb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&mb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&nb_emlrtRSI, emlrtRootTLSGlobal);
if (b_a->size[1] < 1) {
beta1 = 0.0;
} else {
emlrtPushRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&sb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
n_t = (ptrdiff_t)(b_a->size[1]);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&sb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
m_t = (ptrdiff_t)(1);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
k_t = (ptrdiff_t)(1);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal);
alpha1_t = (double *)(&b_a->data[0]);
emlrtPopRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal);
Aia0_t = (double *)(&x->data[0]);
emlrtPopRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal);
beta1 = ddot(&n_t, alpha1_t, &m_t, Aia0_t, &k_t);
emlrtPopRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&nb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&mb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&lb_emlrtRSI, emlrtRootTLSGlobal);
}
emxFree_real_T(&b_a);
f = -C * alpha1 - 0.5 * beta1;
emlrtPopRtStackR2012b(&h_emlrtRSI, emlrtRootTLSGlobal);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
return f;
}
/* Function Definitions */
void rsf2csf(const emxArray_real_T *Ur, const emxArray_real_T *Tr,
emxArray_creal_T *U, emxArray_creal_T *T)
{
int32_T y;
int32_T loop_ub;
int16_T varargin_1[2];
int32_T mtmp;
int32_T m;
real_T c;
real_T b;
real_T temp;
real_T p;
real_T bcmax;
real_T scale;
real_T bb;
real_T b_p;
real_T cs;
int32_T b_scale;
real_T b_c;
real_T mu1_re;
emlrtPushRtStackR2012b(&bh_emlrtRSI, emlrtRootTLSGlobal);
y = T->size[0] * T->size[1];
T->size[0] = Tr->size[0];
T->size[1] = Tr->size[1];
emxEnsureCapacity((emxArray__common *)T, y, (int32_T)sizeof(creal_T),
&v_emlrtRTEI);
loop_ub = Tr->size[0] * Tr->size[1];
for (y = 0; y < loop_ub; y++) {
T->data[y].re = Tr->data[y];
T->data[y].im = 0.0;
}
y = U->size[0] * U->size[1];
U->size[0] = Ur->size[0];
U->size[1] = Ur->size[1];
emxEnsureCapacity((emxArray__common *)U, y, (int32_T)sizeof(creal_T),
&v_emlrtRTEI);
loop_ub = Ur->size[0] * Ur->size[1];
for (y = 0; y < loop_ub; y++) {
U->data[y].re = Ur->data[y];
U->data[y].im = 0.0;
}
for (y = 0; y < 2; y++) {
varargin_1[y] = (int16_T)Tr->size[y];
}
mtmp = varargin_1[0];
if (varargin_1[1] < varargin_1[0]) {
mtmp = varargin_1[1];
}
for (y = 0; y < 2; y++) {
varargin_1[y] = (int16_T)Ur->size[y];
}
loop_ub = varargin_1[0];
if (varargin_1[1] < varargin_1[0]) {
loop_ub = varargin_1[1];
}
mtmp = (int32_T)muDoubleScalarMin(mtmp, loop_ub);
if (mtmp == 0) {
} else {
for (m = mtmp - 1; m + 1 >= 2; m--) {
if (Tr->data[m + Tr->size[0] * (m - 1)] != 0.0) {
emlrtPushRtStackR2012b(&ch_emlrtRSI, emlrtRootTLSGlobal);
c = Tr->data[m + Tr->size[0] * (m - 1)];
b = Tr->data[(m + Tr->size[0] * m) - 1];
temp = Tr->data[(m + Tr->size[0] * (m - 1)) - 1];
if (Tr->data[m + Tr->size[0] * (m - 1)] == 0.0) {
} else if (Tr->data[(m + Tr->size[0] * m) - 1] == 0.0) {
temp = Tr->data[m + Tr->size[0] * m];
b = -Tr->data[m + Tr->size[0] * (m - 1)];
c = 0.0;
} else if ((Tr->data[(m + Tr->size[0] * (m - 1)) - 1] - Tr->data[m +
Tr->size[0] * m] == 0.0) && ((Tr->data[(m + Tr->size[0] * m)
- 1] < 0.0) != (Tr->data[m + Tr->size[0] * (m - 1)] < 0.0))) {
} else {
temp = Tr->data[(m + Tr->size[0] * (m - 1)) - 1] - Tr->data[m +
Tr->size[0] * m];
p = 0.5 * temp;
bcmax = muDoubleScalarMax(muDoubleScalarAbs(Tr->data[(m + Tr->size[0] *
m) - 1]), muDoubleScalarAbs(Tr->data[m + Tr->size[0] * (m - 1)]));
if (!(Tr->data[(m + Tr->size[0] * m) - 1] < 0.0)) {
loop_ub = 1;
} else {
loop_ub = -1;
}
if (!(Tr->data[m + Tr->size[0] * (m - 1)] < 0.0)) {
y = 1;
} else {
y = -1;
}
scale = muDoubleScalarMax(muDoubleScalarAbs(p), bcmax);
bcmax = p / scale * p + bcmax / scale * (muDoubleScalarMin
(muDoubleScalarAbs(Tr->data[(m + Tr->size[0] * m) - 1]),
muDoubleScalarAbs(Tr->data[m + Tr->size[0] * (m - 1)])) * (real_T)
loop_ub * (real_T)y);
if (bcmax >= 8.8817841970012523E-16) {
emlrtPushRtStackR2012b(&gg_emlrtRSI, emlrtRootTLSGlobal);
bb = muDoubleScalarSqrt(scale) * muDoubleScalarSqrt(bcmax);
emlrtPopRtStackR2012b(&gg_emlrtRSI, emlrtRootTLSGlobal);
if (!(p < 0.0)) {
b_p = bb;
} else {
b_p = -bb;
}
temp = Tr->data[m + Tr->size[0] * m] + (p + b_p);
b = Tr->data[(m + Tr->size[0] * m) - 1] - Tr->data[m + Tr->size[0] *
(m - 1)];
c = 0.0;
} else {
scale = Tr->data[(m + Tr->size[0] * m) - 1] + Tr->data[m + Tr->size
[0] * (m - 1)];
bcmax = muDoubleScalarHypot(scale, temp);
emlrtPushRtStackR2012b(&hg_emlrtRSI, emlrtRootTLSGlobal);
bb = 0.5 * (1.0 + muDoubleScalarAbs(scale) / bcmax);
if (bb < 0.0) {
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
eml_error();
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
}
cs = muDoubleScalarSqrt(bb);
emlrtPopRtStackR2012b(&hg_emlrtRSI, emlrtRootTLSGlobal);
if (!(scale < 0.0)) {
b_scale = 1;
} else {
b_scale = -1;
}
bcmax = -(p / (bcmax * cs)) * (real_T)b_scale;
scale = Tr->data[(m + Tr->size[0] * (m - 1)) - 1] * cs + Tr->data[(m
+ Tr->size[0] * m) - 1] * bcmax;
bb = -Tr->data[(m + Tr->size[0] * (m - 1)) - 1] * bcmax + Tr->data
[(m + Tr->size[0] * m) - 1] * cs;
p = Tr->data[m + Tr->size[0] * (m - 1)] * cs + Tr->data[m + Tr->
size[0] * m] * bcmax;
temp = -Tr->data[m + Tr->size[0] * (m - 1)] * bcmax + Tr->data[m +
Tr->size[0] * m] * cs;
b = bb * cs + temp * bcmax;
c = -scale * bcmax + p * cs;
temp = 0.5 * ((scale * cs + p * bcmax) + (-bb * bcmax + temp * cs));
if (c != 0.0) {
if (b != 0.0) {
if ((b < 0.0) == (c < 0.0)) {
emlrtPushRtStackR2012b(&ig_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ig_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jg_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&jg_emlrtRSI, emlrtRootTLSGlobal);
bb = muDoubleScalarSqrt(muDoubleScalarAbs(b)) *
muDoubleScalarSqrt(muDoubleScalarAbs(c));
emlrtPushRtStackR2012b(&kg_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&kg_emlrtRSI, emlrtRootTLSGlobal);
if (!(c < 0.0)) {
b_c = bb;
} else {
b_c = -bb;
}
temp += b_c;
b -= c;
c = 0.0;
}
} else {
b = -c;
c = 0.0;
}
}
}
}
if (c == 0.0) {
bcmax = 0.0;
} else {
emlrtPushRtStackR2012b(&lg_emlrtRSI, emlrtRootTLSGlobal);
bcmax = muDoubleScalarSqrt(muDoubleScalarAbs(b)) * muDoubleScalarSqrt
(muDoubleScalarAbs(c));
emlrtPopRtStackR2012b(&lg_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&ch_emlrtRSI, emlrtRootTLSGlobal);
mu1_re = temp - Tr->data[m + Tr->size[0] * m];
scale = muDoubleScalarHypot(muDoubleScalarHypot(mu1_re, bcmax), Tr->
data[m + Tr->size[0] * (m - 1)]);
if (bcmax == 0.0) {
mu1_re /= scale;
cs = 0.0;
} else if (mu1_re == 0.0) {
mu1_re = 0.0;
cs = bcmax / scale;
} else {
mu1_re /= scale;
cs = bcmax / scale;
}
c = Tr->data[m + Tr->size[0] * (m - 1)] / scale;
emlrtPushRtStackR2012b(&dh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&dh_emlrtRSI, emlrtRootTLSGlobal);
for (loop_ub = m - 1; loop_ub + 1 <= mtmp; loop_ub++) {
b = T->data[(m + T->size[0] * loop_ub) - 1].re;
temp = T->data[(m + T->size[0] * loop_ub) - 1].im;
bb = T->data[(m + T->size[0] * loop_ub) - 1].re;
p = T->data[(m + T->size[0] * loop_ub) - 1].im;
bcmax = T->data[(m + T->size[0] * loop_ub) - 1].im;
scale = T->data[(m + T->size[0] * loop_ub) - 1].re;
T->data[(m + T->size[0] * loop_ub) - 1].re = (mu1_re * bb + cs * p) +
c * T->data[m + T->size[0] * loop_ub].re;
T->data[(m + T->size[0] * loop_ub) - 1].im = (mu1_re * bcmax - cs *
scale) + c * T->data[m + T->size[0] * loop_ub].im;
bcmax = mu1_re * T->data[m + T->size[0] * loop_ub].re - cs * T->data[m
+ T->size[0] * loop_ub].im;
scale = mu1_re * T->data[m + T->size[0] * loop_ub].im + cs * T->data[m
+ T->size[0] * loop_ub].re;
T->data[m + T->size[0] * loop_ub].re = bcmax - c * b;
T->data[m + T->size[0] * loop_ub].im = scale - c * temp;
}
emlrtPushRtStackR2012b(&eh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&eh_emlrtRSI, emlrtRootTLSGlobal);
for (loop_ub = 0; loop_ub + 1 <= m + 1; loop_ub++) {
b = T->data[loop_ub + T->size[0] * (m - 1)].re;
temp = T->data[loop_ub + T->size[0] * (m - 1)].im;
bcmax = mu1_re * T->data[loop_ub + T->size[0] * (m - 1)].re - cs *
T->data[loop_ub + T->size[0] * (m - 1)].im;
scale = mu1_re * T->data[loop_ub + T->size[0] * (m - 1)].im + cs *
T->data[loop_ub + T->size[0] * (m - 1)].re;
bb = T->data[loop_ub + T->size[0] * m].re;
p = T->data[loop_ub + T->size[0] * m].im;
T->data[loop_ub + T->size[0] * (m - 1)].re = bcmax + c * bb;
T->data[loop_ub + T->size[0] * (m - 1)].im = scale + c * p;
bb = T->data[loop_ub + T->size[0] * m].re;
p = T->data[loop_ub + T->size[0] * m].im;
bcmax = T->data[loop_ub + T->size[0] * m].im;
scale = T->data[loop_ub + T->size[0] * m].re;
T->data[loop_ub + T->size[0] * m].re = (mu1_re * bb + cs * p) - c * b;
T->data[loop_ub + T->size[0] * m].im = (mu1_re * bcmax - cs * scale) -
c * temp;
}
emlrtPushRtStackR2012b(&fh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&fh_emlrtRSI, emlrtRootTLSGlobal);
for (loop_ub = 0; loop_ub + 1 <= mtmp; loop_ub++) {
b = U->data[loop_ub + U->size[0] * (m - 1)].re;
temp = U->data[loop_ub + U->size[0] * (m - 1)].im;
bcmax = mu1_re * U->data[loop_ub + U->size[0] * (m - 1)].re - cs *
U->data[loop_ub + U->size[0] * (m - 1)].im;
scale = mu1_re * U->data[loop_ub + U->size[0] * (m - 1)].im + cs *
U->data[loop_ub + U->size[0] * (m - 1)].re;
bb = U->data[loop_ub + U->size[0] * m].re;
p = U->data[loop_ub + U->size[0] * m].im;
U->data[loop_ub + U->size[0] * (m - 1)].re = bcmax + c * bb;
U->data[loop_ub + U->size[0] * (m - 1)].im = scale + c * p;
bb = U->data[loop_ub + U->size[0] * m].re;
p = U->data[loop_ub + U->size[0] * m].im;
bcmax = U->data[loop_ub + U->size[0] * m].im;
scale = U->data[loop_ub + U->size[0] * m].re;
U->data[loop_ub + U->size[0] * m].re = (mu1_re * bb + cs * p) - c * b;
U->data[loop_ub + U->size[0] * m].im = (mu1_re * bcmax - cs * scale) -
c * temp;
}
T->data[m + T->size[0] * (m - 1)].re = 0.0;
T->data[m + T->size[0] * (m - 1)].im = 0.0;
}
}
}
emlrtPopRtStackR2012b(&bh_emlrtRSI, emlrtRootTLSGlobal);
}
/* Function Definitions */
void linearODESSEP2X4(const emxArray_real_T *T, const emxArray_real_T *I)
{
int32_T i;
real_T hoistedGlobal[9];
int32_T j;
int32_T b_i;
real_T normA;
real_T y[81];
real_T F[81];
boolean_T exitg2;
real_T s;
boolean_T exitg1;
static const real_T theta[5] = { 0.01495585217958292, 0.253939833006323,
0.95041789961629319, 2.097847961257068, 5.3719203511481517 };
static const int8_T iv2[5] = { 3, 5, 7, 9, 13 };
int32_T eint;
real_T b_y[81];
real_T beta1;
char_T TRANSB;
char_T TRANSA;
ptrdiff_t m_t;
ptrdiff_t n_t;
ptrdiff_t k_t;
ptrdiff_t lda_t;
ptrdiff_t ldb_t;
ptrdiff_t ldc_t;
double * alpha1_t;
double * Aia0_t;
double * Bib0_t;
double * beta1_t;
double * Cic0_t;
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
/* global k1 k2 k3 k4 k5 k6 k7 k8 k9 k10 k11 k12 L1 L2 L3 L4 H1 H2 H3 H4 g1 g2 E1 E2 alpha A J Q; */
/* Right */
/* [C1,C2,C3,Q1,Q2,Q3,D1,D2,Z] */
Q[0] = -k2 * A - L2 * J;
Q[9] = L2 * J;
Q[18] = 0.0;
Q[27] = k2 * A;
Q[36] = 0.0;
Q[45] = 0.0;
Q[54] = 0.0;
Q[63] = 0.0;
Q[72] = 0.0;
Q[1] = L1;
Q[10] = (-k4 * A - L1) - L4 * J;
Q[19] = L4 * J;
Q[28] = 0.0;
Q[37] = k4 * A;
Q[46] = 0.0;
Q[55] = 0.0;
Q[64] = 0.0;
Q[73] = 0.0;
Q[2] = 0.0;
Q[11] = L3;
Q[20] = -k6 * A - L3;
Q[29] = 0.0;
Q[38] = 0.0;
Q[47] = k6 * A;
Q[56] = 0.0;
Q[65] = 0.0;
Q[74] = 0.0;
Q[3] = k1;
Q[12] = 0.0;
Q[21] = 0.0;
Q[30] = (-k1 - L2 * J) - H2;
Q[39] = L2 * J;
Q[48] = 0.0;
Q[57] = 0.0;
Q[66] = H2;
Q[75] = 0.0;
Q[4] = 0.0;
Q[13] = k3;
Q[22] = 0.0;
Q[31] = L1;
Q[40] = (-k3 - L1) - L4 * J;
Q[49] = L4 * J;
Q[58] = 0.0;
Q[67] = 0.0;
Q[76] = 0.0;
Q[5] = 0.0;
Q[14] = 0.0;
Q[23] = k5;
Q[32] = 0.0;
Q[41] = L3;
Q[50] = -k5 - L3;
Q[59] = 0.0;
Q[68] = 0.0;
Q[77] = 0.0;
Q[6] = H1;
Q[15] = 0.0;
Q[24] = 0.0;
Q[33] = 0.0;
Q[42] = 0.0;
Q[51] = 0.0;
Q[60] = -k2 * A - H1;
Q[69] = k2 * A;
Q[78] = 0.0;
Q[7] = 0.0;
Q[16] = 0.0;
Q[25] = 0.0;
Q[34] = 0.0;
Q[43] = 0.0;
Q[52] = 0.0;
Q[61] = k1;
Q[70] = -k1 - H3;
Q[79] = H3;
Q[8] = H4;
Q[17] = 0.0;
Q[26] = 0.0;
Q[35] = 0.0;
Q[44] = 0.0;
Q[53] = 0.0;
Q[62] = 0.0;
Q[71] = 0.0;
Q[80] = -H4;
Q_dirty |= 1U;
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
i = 0;
while (i <= T->size[0] - 1) {
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
memcpy(&hoistedGlobal[0], &p0[0], 9U * sizeof(real_T));
j = T->size[0];
b_i = (int32_T)(1.0 + (real_T)i);
emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &t_emlrtBCI, emlrtRootTLSGlobal);
normA = T->data[i];
for (j = 0; j < 81; j++) {
y[j] = Q[j] * normA;
}
normA = 0.0;
j = 0;
exitg2 = FALSE;
while ((exitg2 == FALSE) && (j < 9)) {
s = 0.0;
for (b_i = 0; b_i < 9; b_i++) {
s += muDoubleScalarAbs(y[b_i + 9 * j]);
}
if (muDoubleScalarIsNaN(s)) {
normA = rtNaN;
exitg2 = TRUE;
} else {
if (s > normA) {
normA = s;
}
j++;
}
}
if (normA <= 5.3719203511481517) {
b_i = 0;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (b_i < 5)) {
if (normA <= theta[b_i]) {
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
PadeApproximantOfDegree(y, iv2[b_i], F);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
exitg1 = TRUE;
} else {
b_i++;
}
}
} else {
normA /= 5.3719203511481517;
if ((!muDoubleScalarIsInf(normA)) && (!muDoubleScalarIsNaN(normA))) {
normA = frexp(normA, &eint);
j = eint;
} else {
j = 0;
}
s = j;
if (normA == 0.5) {
s = (real_T)j - 1.0;
}
normA = muDoubleScalarPower(2.0, s);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
for (j = 0; j < 81; j++) {
b_y[j] = y[j] / normA;
}
PadeApproximantOfDegree(b_y, 13.0, F);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtForLoopVectorCheckR2012b(1.0, 1.0, s, mxDOUBLE_CLASS, (int32_T)s,
&g_emlrtRTEI, emlrtRootTLSGlobal);
for (j = 0; j < (int32_T)s; j++) {
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&cb_emlrtRSI, emlrtRootTLSGlobal);
memcpy(&y[0], &F[0], 81U * sizeof(real_T));
emlrtPushRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
normA = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
memset(&F[0], 0, 81U * sizeof(real_T));
emlrtPushRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
m_t = (ptrdiff_t)(9);
emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
n_t = (ptrdiff_t)(9);
emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
k_t = (ptrdiff_t)(9);
emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ib_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
lda_t = (ptrdiff_t)(9);
emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ib_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldb_t = (ptrdiff_t)(9);
emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&jb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&kb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldc_t = (ptrdiff_t)(9);
emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&kb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&lb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
alpha1_t = (double *)(&normA);
emlrtPopRtStackR2012b(&lb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&mb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Aia0_t = (double *)(&y[0]);
emlrtPopRtStackR2012b(&mb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&nb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Bib0_t = (double *)(&y[0]);
emlrtPopRtStackR2012b(&nb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Cic0_t = (double *)(&F[0]);
emlrtPopRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t,
Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&qb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&cb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
}
}
for (j = 0; j < 9; j++) {
p0[j] = 0.0;
for (b_i = 0; b_i < 9; b_i++) {
p0[j] += hoistedGlobal[b_i] * F[b_i + 9 * j];
}
}
p0_dirty |= 1U;
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
j = I->size[0];
b_i = 1 + i;
normA = Acell * 1.0E+12 * (g1 * p0[3] * (V - E1) + g2 * (p0[4] + p0[5]) * (V
- E2)) - I->data[emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &u_emlrtBCI,
emlrtRootTLSGlobal) - 1];
normA = muDoubleScalarAbs(normA);
err += normA * normA;
err_dirty |= 1U;
i++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal);
}
}
void sammon(sammonStackData *SD, const real_T x[1000000], real_T y[2000], real_T
*E)
{
real_T B;
int32_T i;
real_T dv0[1000];
int32_T b_i;
boolean_T exitg1;
real_T alpha1;
real_T beta1;
char_T TRANSB;
char_T TRANSA;
ptrdiff_t m_t;
ptrdiff_t n_t;
ptrdiff_t k_t;
ptrdiff_t lda_t;
ptrdiff_t ldb_t;
ptrdiff_t ldc_t;
double * alpha1_t;
double * Aia0_t;
double * Bib0_t;
double * beta1_t;
double * Cic0_t;
real_T g[2000];
real_T y2[2000];
real_T b_y[2000];
real_T c_y[2000];
real_T d_y[2000];
real_T e_y[2000];
real_T b_g[2000];
int32_T j;
int32_T b_j;
boolean_T exitg2;
real_T dv1[1000];
real_T E_new;
/* #codgen */
/* */
/* SAMMON - apply Sammon's nonlinear mapping */
/* */
/* Y = SAMMON(X) applies Sammon's nonlinear mapping procedure on */
/* multivariate data X, where each row represents a pattern and each column */
/* represents a feature. On completion, Y contains the corresponding */
/* co-ordinates of each point on the map. By default, a two-dimensional */
/* map is created. Note if X contains any duplicated rows, SAMMON will */
/* fail (ungracefully). */
/* */
/* [Y,E] = SAMMON(X) also returns the value of the cost function in E (i.e. */
/* the stress of the mapping). */
/* */
/* An N-dimensional output map is generated by Y = SAMMON(X,N) . */
/* */
/* A set of optimisation options can also be specified using a third */
/* argument, Y = SAMMON(X,N,OPTS) , where OPTS is a structure with fields: */
/* */
/* MaxIter - maximum number of iterations */
/* TolFun - relative tolerance on objective function */
/* MaxHalves - maximum number of step halvings */
/* Input - {'raw','distance'} if set to 'distance', X is */
/* interpreted as a matrix of pairwise distances. */
/* Display - {'off', 'on', 'iter'} */
/* Initialisation - {'pca', 'random'} */
/* */
/* The default options structure can be retrieved by calling SAMMON with */
/* no parameters. */
/* */
/* References : */
/* */
/* [1] Sammon, John W. Jr., "A Nonlinear Mapping for Data Structure */
/* Analysis", IEEE Transactions on Computers, vol. C-18, no. 5, */
/* pp 401-409, May 1969. */
/* */
/* See also : SAMMON_TEST */
/* */
/* File : sammon.m */
/* */
/* Date : Monday 12th November 2007. */
/* */
/* Author : Gavin C. Cawley and Nicola L. C. Talbot */
/* */
/* Description : Simple vectorised MATLAB implementation of Sammon's non-linear */
/* mapping algorithm [1]. */
/* */
/* References : [1] Sammon, John W. Jr., "A Nonlinear Mapping for Data */
/* Structure Analysis", IEEE Transactions on Computers, */
/* vol. C-18, no. 5, pp 401-409, May 1969. */
/* */
/* History : 10/08/2004 - v1.00 */
/* 11/08/2004 - v1.10 Hessian made positive semidefinite */
/* 13/08/2004 - v1.11 minor optimisation */
/* 12/11/2007 - v1.20 initialisation using the first n principal */
/* components. */
/* */
/* Thanks : Dr Nick Hamilton ([email protected]) for supplying the */
/* code for implementing initialisation using the first n */
/* principal components (introduced in v1.20). */
/* */
/* To do : The current version does not take advantage of the symmetry */
/* of the distance matrix in order to allow for easy */
/* vectorisation. This may not be a good choice for very large */
/* datasets, so perhaps one day I'll get around to doing a MEX */
/* version using the BLAS library etc. for very large datasets. */
/* */
/* Copyright : (c) Dr Gavin C. Cawley, November 2007. */
/* */
/* This program is free software; you can redistribute it and/or modify */
/* it under the terms of the GNU General Public License as published by */
/* the Free Software Foundation; either version 2 of the License, or */
/* (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* */
/* use the default options structure */
/* create distance matrix unless given by parameters */
emlrtPushRtStackR2012b(&emlrtRSI, emlrtRootTLSGlobal);
euclid(SD, x, x, SD->f2.D);
emlrtPopRtStackR2012b(&emlrtRSI, emlrtRootTLSGlobal);
/* remaining initialisation */
B = b_sum(SD->f2.D);
eye(SD->f2.delta);
for (i = 0; i < 1000000; i++) {
SD->f2.D[i] += SD->f2.delta[i];
}
rdivide(1.0, SD->f2.D, SD->f2.Dinv);
emlrtPushRtStackR2012b(&b_emlrtRSI, emlrtRootTLSGlobal);
randn(y);
emlrtPopRtStackR2012b(&b_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&c_emlrtRSI, emlrtRootTLSGlobal);
b_euclid(SD, y, y, SD->f2.d);
eye(SD->f2.delta);
for (i = 0; i < 1000000; i++) {
SD->f2.d[i] += SD->f2.delta[i];
}
emlrtPopRtStackR2012b(&c_emlrtRSI, emlrtRootTLSGlobal);
rdivide(1.0, SD->f2.d, SD->f2.dinv);
for (i = 0; i < 1000000; i++) {
SD->f2.b_D[i] = SD->f2.D[i] - SD->f2.d[i];
}
power(SD->f2.b_D, SD->f2.delta);
for (i = 0; i < 1000000; i++) {
SD->f2.d[i] = SD->f2.delta[i] * SD->f2.Dinv[i];
}
d_sum(SD->f2.d, dv0);
*E = e_sum(dv0);
/* get on with it */
b_i = 0;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (b_i < 500)) {
/* compute gradient, Hessian and search direction (note it is actually */
/* 1/4 of the gradient and Hessian, but the step size is just the ratio */
/* of the gradient and the diagonal of the Hessian so it doesn't matter). */
for (i = 0; i < 1000000; i++) {
SD->f2.delta[i] = SD->f2.dinv[i] - SD->f2.Dinv[i];
}
emlrtPushRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
alpha1 = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
for (i = 0; i < 2000; i++) {
SD->f2.y_old[i] = 1.0;
SD->f2.deltaone[i] = 0.0;
}
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
m_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
n_t = (ptrdiff_t)(2);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
k_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
lda_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldb_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldc_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
alpha1_t = (double *)(&alpha1);
emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
Aia0_t = (double *)(&SD->f2.delta[0]);
emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
Bib0_t = (double *)(&SD->f2.y_old[0]);
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
Cic0_t = (double *)(&SD->f2.deltaone[0]);
emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t,
&ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&d_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&e_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
alpha1 = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
memset(&g[0], 0, 2000U * sizeof(real_T));
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
m_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
n_t = (ptrdiff_t)(2);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
k_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
lda_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldb_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldc_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
alpha1_t = (double *)(&alpha1);
emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
Aia0_t = (double *)(&SD->f2.delta[0]);
emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
Bib0_t = (double *)(&y[0]);
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
Cic0_t = (double *)(&g[0]);
emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t,
&ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
for (i = 0; i < 2000; i++) {
g[i] -= y[i] * SD->f2.deltaone[i];
}
emlrtPopRtStackR2012b(&e_emlrtRSI, emlrtRootTLSGlobal);
c_power(SD->f2.dinv, SD->f2.delta);
b_power(y, y2);
emlrtPushRtStackR2012b(&f_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
alpha1 = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
memset(&b_y[0], 0, 2000U * sizeof(real_T));
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
m_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
n_t = (ptrdiff_t)(2);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
k_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
lda_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldb_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldc_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
alpha1_t = (double *)(&alpha1);
emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
Aia0_t = (double *)(&SD->f2.delta[0]);
emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
Bib0_t = (double *)(&y2[0]);
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
Cic0_t = (double *)(&b_y[0]);
emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t,
&ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
for (i = 0; i < 2000; i++) {
c_y[i] = 2.0 * y[i];
}
emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
alpha1 = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
memset(&d_y[0], 0, 2000U * sizeof(real_T));
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
m_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
n_t = (ptrdiff_t)(2);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
k_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
lda_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldb_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldc_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
alpha1_t = (double *)(&alpha1);
emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
Aia0_t = (double *)(&SD->f2.delta[0]);
emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
Bib0_t = (double *)(&y[0]);
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
Cic0_t = (double *)(&d_y[0]);
emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t,
&ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
alpha1 = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
for (i = 0; i < 2000; i++) {
SD->f2.y_old[i] = 1.0;
e_y[i] = 0.0;
}
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
m_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
n_t = (ptrdiff_t)(2);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
k_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
lda_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldb_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldc_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
alpha1_t = (double *)(&alpha1);
emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
Aia0_t = (double *)(&SD->f2.delta[0]);
emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
Bib0_t = (double *)(&SD->f2.y_old[0]);
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
Cic0_t = (double *)(&e_y[0]);
emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t,
&ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&f_emlrtRSI, emlrtRootTLSGlobal);
for (i = 0; i < 2000; i++) {
SD->f2.y_old[i] = ((b_y[i] - SD->f2.deltaone[i]) - c_y[i] * d_y[i]) + y2[i]
* e_y[i];
b_g[i] = -g[i];
}
b_abs(SD->f2.y_old, y2);
for (i = 0; i < 2000; i++) {
SD->f2.deltaone[i] = y2[i];
SD->f2.y_old[i] = y[i];
}
b_rdivide(b_g, SD->f2.deltaone, y2);
/* use step-halving procedure to ensure progress is made */
j = 1;
b_j = 0;
exitg2 = FALSE;
while ((exitg2 == FALSE) && (b_j < 20)) {
j = b_j + 1;
for (i = 0; i < 2000; i++) {
y[i] = SD->f2.y_old[i] + y2[i];
}
emlrtPushRtStackR2012b(&g_emlrtRSI, emlrtRootTLSGlobal);
b_euclid(SD, y, y, SD->f2.d);
eye(SD->f2.delta);
for (i = 0; i < 1000000; i++) {
SD->f2.d[i] += SD->f2.delta[i];
}
emlrtPopRtStackR2012b(&g_emlrtRSI, emlrtRootTLSGlobal);
rdivide(1.0, SD->f2.d, SD->f2.dinv);
for (i = 0; i < 1000000; i++) {
SD->f2.b_D[i] = SD->f2.D[i] - SD->f2.d[i];
}
power(SD->f2.b_D, SD->f2.delta);
for (i = 0; i < 1000000; i++) {
SD->f2.d[i] = SD->f2.delta[i] * SD->f2.Dinv[i];
}
d_sum(SD->f2.d, dv1);
E_new = e_sum(dv1);
if (E_new < *E) {
exitg2 = TRUE;
} else {
for (i = 0; i < 2000; i++) {
y2[i] *= 0.5;
}
b_j++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar,
emlrtRootTLSGlobal);
}
}
/* bomb out if too many halving steps are required */
if ((j == 20) || (muDoubleScalarAbs((*E - E_new) / *E) < 1.0E-9)) {
exitg1 = TRUE;
} else {
/* evaluate termination criterion */
/* report progress */
*E = E_new;
b_i++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal);
}
}
/* fiddle stress to match the original Sammon paper */
*E *= 0.5 / B;
}
static void euclid(sammonStackData *SD, const real_T x[1000000], const real_T y
[1000000], real_T d[1000000])
{
int32_T k;
int32_T i0;
real_T alpha1;
real_T beta1;
char_T TRANSB;
char_T TRANSA;
ptrdiff_t m_t;
ptrdiff_t n_t;
ptrdiff_t k_t;
ptrdiff_t lda_t;
ptrdiff_t ldb_t;
ptrdiff_t ldc_t;
double * alpha1_t;
double * Aia0_t;
double * Bib0_t;
double * beta1_t;
double * Cic0_t;
real_T dv2[1000];
real_T dv3[1000];
/* all done */
emlrtPushRtStackR2012b(&h_emlrtRSI, emlrtRootTLSGlobal);
for (k = 0; k < 1000000; k++) {
SD->u1.f1.y[k] = x[k] * x[k];
SD->u1.f1.b_y[k] = y[k] * y[k];
}
for (k = 0; k < 1000; k++) {
for (i0 = 0; i0 < 1000; i0++) {
SD->u1.f1.b[i0 + 1000 * k] = y[k + 1000 * i0];
}
}
emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
alpha1 = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
memset(&SD->u1.f1.c_y[0], 0, 1000000U * sizeof(real_T));
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
m_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
n_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
k_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
lda_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldb_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldc_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
alpha1_t = (double *)(&alpha1);
emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
Aia0_t = (double *)(&x[0]);
emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
Bib0_t = (double *)(&SD->u1.f1.b[0]);
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
Cic0_t = (double *)(&SD->u1.f1.c_y[0]);
emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t,
&ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
sum(SD->u1.f1.y, dv2);
sum(SD->u1.f1.b_y, dv3);
for (k = 0; k < 1000; k++) {
for (i0 = 0; i0 < 1000; i0++) {
SD->u1.f1.y[k + 1000 * i0] = dv2[k];
SD->u1.f1.b_y[k + 1000 * i0] = dv3[i0];
}
}
for (k = 0; k < 1000; k++) {
for (i0 = 0; i0 < 1000; i0++) {
d[i0 + 1000 * k] = (SD->u1.f1.y[i0 + 1000 * k] + SD->u1.f1.b_y[i0 + 1000 *
k]) - 2.0 * SD->u1.f1.c_y[i0 + 1000 * k];
}
}
b_sqrt(d);
emlrtPopRtStackR2012b(&h_emlrtRSI, emlrtRootTLSGlobal);
}
/* Function Definitions */
static void b_euclid(sammonStackData *SD, const real_T x[2000], const real_T y
[2000], real_T d[1000000])
{
real_T b_y[2000];
real_T c_y[2000];
int32_T k;
real_T b[2000];
int32_T i2;
real_T alpha1;
real_T beta1;
char_T TRANSB;
char_T TRANSA;
ptrdiff_t m_t;
ptrdiff_t n_t;
ptrdiff_t k_t;
ptrdiff_t lda_t;
ptrdiff_t ldb_t;
ptrdiff_t ldc_t;
double * alpha1_t;
double * Aia0_t;
double * Bib0_t;
double * beta1_t;
double * Cic0_t;
real_T dv4[1000];
real_T dv5[1000];
/* all done */
emlrtPushRtStackR2012b(&h_emlrtRSI, emlrtRootTLSGlobal);
for (k = 0; k < 2000; k++) {
b_y[k] = x[k] * x[k];
c_y[k] = y[k] * y[k];
}
for (k = 0; k < 1000; k++) {
for (i2 = 0; i2 < 2; i2++) {
b[i2 + (k << 1)] = y[k + 1000 * i2];
}
}
emlrtPushRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
alpha1 = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
memset(&SD->u1.f0.y[0], 0, 1000000U * sizeof(real_T));
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
m_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
n_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
k_t = (ptrdiff_t)(2);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
lda_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldb_t = (ptrdiff_t)(2);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
ldc_t = (ptrdiff_t)(1000);
emlrtPopRtStackR2012b(&x_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
alpha1_t = (double *)(&alpha1);
emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
Aia0_t = (double *)(&x[0]);
emlrtPopRtStackR2012b(&s_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
Bib0_t = (double *)(&b[0]);
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&u_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
Cic0_t = (double *)(&SD->u1.f0.y[0]);
emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t,
&ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&w_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&k_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&j_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&i_emlrtRSI, emlrtRootTLSGlobal);
c_sum(b_y, dv4);
c_sum(c_y, dv5);
for (k = 0; k < 1000; k++) {
for (i2 = 0; i2 < 1000; i2++) {
SD->u1.f0.dv6[k + 1000 * i2] = dv4[k];
SD->u1.f0.dv7[k + 1000 * i2] = dv5[i2];
}
}
for (k = 0; k < 1000; k++) {
for (i2 = 0; i2 < 1000; i2++) {
d[i2 + 1000 * k] = (SD->u1.f0.dv6[i2 + 1000 * k] + SD->u1.f0.dv7[i2 + 1000
* k]) - 2.0 * SD->u1.f0.y[i2 + 1000 * k];
}
}
b_sqrt(d);
emlrtPopRtStackR2012b(&h_emlrtRSI, emlrtRootTLSGlobal);
}
/* Function Definitions */
void linearODESSEP2X4(const emxArray_real_T *T, const emxArray_real_T *I)
{
int32_T i;
real_T hoistedGlobal[17];
int32_T j;
int32_T b_i;
real_T normA;
real_T y[289];
real_T F[289];
boolean_T exitg2;
real_T s;
boolean_T exitg1;
static const real_T theta[5] = { 0.01495585217958292, 0.253939833006323,
0.95041789961629319, 2.097847961257068, 5.3719203511481517 };
static const int8_T iv2[5] = { 3, 5, 7, 9, 13 };
int32_T eint;
real_T b_y[289];
real_T beta1;
char_T TRANSB;
char_T TRANSA;
ptrdiff_t m_t;
ptrdiff_t n_t;
ptrdiff_t k_t;
ptrdiff_t lda_t;
ptrdiff_t ldb_t;
ptrdiff_t ldc_t;
double * alpha1_t;
double * Aia0_t;
double * Bib0_t;
double * beta1_t;
double * Cic0_t;
emlrtPushRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
Q[0] = -k2 * A - L2 * J;
Q[17] = k2 * A;
Q[34] = L2 * J;
Q[51] = 0.0;
Q[68] = 0.0;
Q[85] = 0.0;
Q[102] = 0.0;
Q[119] = 0.0;
Q[136] = 0.0;
Q[153] = 0.0;
Q[170] = 0.0;
Q[187] = 0.0;
Q[204] = 0.0;
Q[221] = 0.0;
Q[238] = 0.0;
Q[255] = 0.0;
Q[272] = 0.0;
Q[1] = k1;
Q[18] = ((-k1 - k4 * A) - H2) - L2 * J;
Q[35] = 0.0;
Q[52] = L2 * J;
Q[69] = 0.0;
Q[86] = 0.0;
Q[103] = k4 * A;
Q[120] = 0.0;
Q[137] = 0.0;
Q[154] = 0.0;
Q[171] = 0.0;
Q[188] = 0.0;
Q[205] = 0.0;
Q[222] = H2;
Q[239] = 0.0;
Q[256] = 0.0;
Q[273] = 0.0;
Q[2] = L1;
Q[19] = 0.0;
Q[36] = (-k8 * A - L1) - L4 * J;
Q[53] = k8 * A;
Q[70] = L4 * J;
Q[87] = 0.0;
Q[104] = 0.0;
Q[121] = 0.0;
Q[138] = 0.0;
Q[155] = 0.0;
Q[172] = 0.0;
Q[189] = 0.0;
Q[206] = 0.0;
Q[223] = 0.0;
Q[240] = 0.0;
Q[257] = 0.0;
Q[274] = 0.0;
Q[3] = 0.0;
Q[20] = L1;
Q[37] = k7;
Q[54] = ((-k7 - k10 * A) - L1) - L4 * J;
Q[71] = 0.0;
Q[88] = L4 * J;
Q[105] = 0.0;
Q[122] = 0.0;
Q[139] = k10 * A;
Q[156] = 0.0;
Q[173] = 0.0;
Q[190] = 0.0;
Q[207] = 0.0;
Q[224] = 0.0;
Q[241] = 0.0;
Q[258] = 0.0;
Q[275] = 0.0;
Q[4] = 0.0;
Q[21] = 0.0;
Q[38] = L3;
Q[55] = 0.0;
Q[72] = -k8 * alpha * A - L3;
Q[89] = k8 * alpha * A;
Q[106] = 0.0;
Q[123] = 0.0;
Q[140] = 0.0;
Q[157] = 0.0;
Q[174] = 0.0;
Q[191] = 0.0;
Q[208] = 0.0;
Q[225] = 0.0;
Q[242] = 0.0;
Q[259] = 0.0;
Q[276] = 0.0;
Q[5] = 0.0;
Q[22] = 0.0;
Q[39] = 0.0;
Q[56] = L3;
Q[73] = k7;
Q[90] = (-k7 - k10 * alpha * A) - L3;
Q[107] = 0.0;
Q[124] = 0.0;
Q[141] = 0.0;
Q[158] = 0.0;
Q[175] = k10 * alpha * A;
Q[192] = 0.0;
Q[209] = 0.0;
Q[226] = 0.0;
Q[243] = 0.0;
Q[260] = 0.0;
Q[277] = 0.0;
Q[6] = 0.0;
Q[23] = k3;
Q[40] = 0.0;
Q[57] = 0.0;
Q[74] = 0.0;
Q[91] = 0.0;
Q[108] = ((-k3 - k6 * A) - H2) - L2 * J;
Q[125] = k6 * A;
Q[142] = L2 * J;
Q[159] = 0.0;
Q[176] = 0.0;
Q[193] = 0.0;
Q[210] = 0.0;
Q[227] = 0.0;
Q[244] = H2;
Q[261] = 0.0;
Q[278] = 0.0;
Q[7] = 0.0;
Q[24] = 0.0;
Q[41] = 0.0;
Q[58] = 0.0;
Q[75] = 0.0;
Q[92] = 0.0;
Q[109] = k5;
Q[126] = (-k5 - H2) - L2 * J;
Q[143] = 0.0;
Q[160] = L2 * J;
Q[177] = 0.0;
Q[194] = 0.0;
Q[211] = 0.0;
Q[228] = 0.0;
Q[245] = 0.0;
Q[262] = H2;
Q[279] = 0.0;
Q[8] = 0.0;
Q[25] = 0.0;
Q[42] = 0.0;
Q[59] = k9;
Q[76] = 0.0;
Q[93] = 0.0;
Q[110] = L1;
Q[127] = 0.0;
Q[144] = ((-k9 - k12 * A) - L1) - L4 * J;
Q[161] = k12 * A;
Q[178] = L4 * J;
Q[195] = 0.0;
Q[212] = 0.0;
Q[229] = 0.0;
Q[246] = 0.0;
Q[263] = 0.0;
Q[280] = 0.0;
Q[9] = 0.0;
Q[26] = 0.0;
Q[43] = 0.0;
Q[60] = 0.0;
Q[77] = 0.0;
Q[94] = 0.0;
Q[111] = 0.0;
Q[128] = L1;
Q[145] = k11;
Q[162] = (-k11 - L1) - L4 * J;
Q[179] = 0.0;
Q[196] = L4 * J;
Q[213] = 0.0;
Q[230] = 0.0;
Q[247] = 0.0;
Q[264] = 0.0;
Q[281] = 0.0;
Q[10] = 0.0;
Q[27] = 0.0;
Q[44] = 0.0;
Q[61] = 0.0;
Q[78] = 0.0;
Q[95] = k9;
Q[112] = 0.0;
Q[129] = 0.0;
Q[146] = L3;
Q[163] = 0.0;
Q[180] = (-k9 - k12 * alpha * A) - L3;
Q[197] = k12 * alpha * A;
Q[214] = 0.0;
Q[231] = 0.0;
Q[248] = 0.0;
Q[265] = 0.0;
Q[282] = 0.0;
Q[11] = 0.0;
Q[28] = 0.0;
Q[45] = 0.0;
Q[62] = 0.0;
Q[79] = 0.0;
Q[96] = 0.0;
Q[113] = 0.0;
Q[130] = 0.0;
Q[147] = 0.0;
Q[164] = L3;
Q[181] = k11;
Q[198] = -k11 - L3;
Q[215] = 0.0;
Q[232] = 0.0;
Q[249] = 0.0;
Q[266] = 0.0;
Q[283] = 0.0;
Q[12] = H1;
Q[29] = 0.0;
Q[46] = 0.0;
Q[63] = 0.0;
Q[80] = 0.0;
Q[97] = 0.0;
Q[114] = 0.0;
Q[131] = 0.0;
Q[148] = 0.0;
Q[165] = 0.0;
Q[182] = 0.0;
Q[199] = 0.0;
Q[216] = -k2 * A - H1;
Q[233] = k2 * A;
Q[250] = 0.0;
Q[267] = 0.0;
Q[284] = 0.0;
Q[13] = 0.0;
Q[30] = 0.0;
Q[47] = 0.0;
Q[64] = 0.0;
Q[81] = 0.0;
Q[98] = 0.0;
Q[115] = 0.0;
Q[132] = 0.0;
Q[149] = 0.0;
Q[166] = 0.0;
Q[183] = 0.0;
Q[200] = 0.0;
Q[217] = k1;
Q[234] = -k1 - k4 * A;
Q[251] = k4 * A;
Q[268] = 0.0;
Q[285] = 0.0;
Q[14] = 0.0;
Q[31] = 0.0;
Q[48] = 0.0;
Q[65] = 0.0;
Q[82] = 0.0;
Q[99] = 0.0;
Q[116] = 0.0;
Q[133] = 0.0;
Q[150] = 0.0;
Q[167] = 0.0;
Q[184] = 0.0;
Q[201] = 0.0;
Q[218] = 0.0;
Q[235] = k3;
Q[252] = -k3 - k6 * A;
Q[269] = k6 * A;
Q[286] = 0.0;
Q[15] = 0.0;
Q[32] = 0.0;
Q[49] = 0.0;
Q[66] = 0.0;
Q[83] = 0.0;
Q[100] = 0.0;
Q[117] = 0.0;
Q[134] = 0.0;
Q[151] = 0.0;
Q[168] = 0.0;
Q[185] = 0.0;
Q[202] = 0.0;
Q[219] = 0.0;
Q[236] = 0.0;
Q[253] = k5;
Q[270] = -k5 - H3;
Q[287] = H3;
Q[16] = H4;
Q[33] = 0.0;
Q[50] = 0.0;
Q[67] = 0.0;
Q[84] = 0.0;
Q[101] = 0.0;
Q[118] = 0.0;
Q[135] = 0.0;
Q[152] = 0.0;
Q[169] = 0.0;
Q[186] = 0.0;
Q[203] = 0.0;
Q[220] = 0.0;
Q[237] = 0.0;
Q[254] = 0.0;
Q[271] = 0.0;
Q[288] = -H4;
Q_dirty |= 1U;
emlrtPopRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
i = 0;
while (i <= T->size[0] - 1) {
emlrtPushRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
memcpy(&hoistedGlobal[0], &p0[0], 17U * sizeof(real_T));
j = T->size[0];
b_i = (int32_T)(1.0 + (real_T)i);
emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &bd_emlrtBCI,
emlrtRootTLSGlobal);
normA = T->data[i];
for (j = 0; j < 289; j++) {
y[j] = Q[j] * normA;
}
normA = 0.0;
j = 0;
exitg2 = FALSE;
while ((exitg2 == FALSE) && (j < 17)) {
s = 0.0;
for (b_i = 0; b_i < 17; b_i++) {
s += muDoubleScalarAbs(y[b_i + 17 * j]);
}
if (muDoubleScalarIsNaN(s)) {
normA = rtNaN;
exitg2 = TRUE;
} else {
if (s > normA) {
normA = s;
}
j++;
}
}
if (normA <= 5.3719203511481517) {
b_i = 0;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (b_i < 5)) {
if (normA <= theta[b_i]) {
emlrtPushRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
PadeApproximantOfDegree(y, iv2[b_i], F);
emlrtPopRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
exitg1 = TRUE;
} else {
b_i++;
}
}
} else {
normA /= 5.3719203511481517;
if ((!muDoubleScalarIsInf(normA)) && (!muDoubleScalarIsNaN(normA))) {
normA = frexp(normA, &eint);
j = eint;
} else {
j = 0;
}
s = j;
if (normA == 0.5) {
s = (real_T)j - 1.0;
}
normA = muDoubleScalarPower(2.0, s);
emlrtPushRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal);
for (j = 0; j < 289; j++) {
b_y[j] = y[j] / normA;
}
PadeApproximantOfDegree(b_y, 13.0, F);
emlrtPopRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal);
emlrtForLoopVectorCheckR2012b(1.0, 1.0, s, mxDOUBLE_CLASS, (int32_T)s,
&l_emlrtRTEI, emlrtRootTLSGlobal);
for (j = 0; j < (int32_T)s; j++) {
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal);
memcpy(&y[0], &F[0], 289U * sizeof(real_T));
emlrtPushRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal);
normA = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
memset(&F[0], 0, 289U * sizeof(real_T));
emlrtPushRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
m_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&xb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
n_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&xb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&yb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
k_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&yb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ac_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
lda_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ac_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&bc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldb_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&bc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&cc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldc_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&cc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&dc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
alpha1_t = (double *)(&normA);
emlrtPopRtStackR2012b(&dc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Aia0_t = (double *)(&y[0]);
emlrtPopRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&fc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Bib0_t = (double *)(&y[0]);
emlrtPopRtStackR2012b(&fc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Cic0_t = (double *)(&F[0]);
emlrtPopRtStackR2012b(&hc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t,
Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
}
}
for (j = 0; j < 17; j++) {
p0[j] = 0.0;
for (b_i = 0; b_i < 17; b_i++) {
p0[j] += hoistedGlobal[b_i] * F[b_i + 17 * j];
}
}
p0_dirty |= 1U;
emlrtPopRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
j = I->size[0];
b_i = 1 + i;
normA = Acell * 1.0E+12 * (g1 * (p0[6] + p0[7]) * (V - E1) + g2 * (((p0[8] +
p0[9]) + p0[10]) + p0[11]) * (V - E2)) - I->
data[emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &cd_emlrtBCI,
emlrtRootTLSGlobal) - 1];
normA = muDoubleScalarAbs(normA);
err += normA * normA;
err_dirty |= 1U;
i++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal);
}
}
/* Function Definitions */
real_T b_norm(const emxArray_real_T *x)
{
real_T y;
int32_T n;
ptrdiff_t n_t;
ptrdiff_t incx_t;
double * xix0_t;
if ((x->size[0] == 1) || (x->size[1] == 1)) {
emlrtPushRtStackR2012b(&ei_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&gi_emlrtRSI, emlrtRootTLSGlobal);
n = x->size[0] * x->size[1];
emlrtPushRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
if (1 > n) {
y = 0.0;
} else {
emlrtPushRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&kc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
n_t = (ptrdiff_t)(n);
emlrtPopRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&kc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&lc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
incx_t = (ptrdiff_t)(1);
emlrtPopRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&lc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&mc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
xix0_t = (double *)(&x->data[0]);
emlrtPopRtStackR2012b(&mc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
y = dnrm2(&n_t, xix0_t, &incx_t);
emlrtPopRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&gi_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ei_emlrtRSI, emlrtRootTLSGlobal);
} else {
emlrtPushRtStackR2012b(&fi_emlrtRSI, emlrtRootTLSGlobal);
n = x->size[0] * x->size[1];
emlrtPushRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
if (1 > n) {
y = 0.0;
} else {
emlrtPushRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&kc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
n_t = (ptrdiff_t)(n);
emlrtPopRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&kc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&lc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
incx_t = (ptrdiff_t)(1);
emlrtPopRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&lc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&mc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
xix0_t = (double *)(&x->data[0]);
emlrtPopRtStackR2012b(&mc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
y = dnrm2(&n_t, xix0_t, &incx_t);
emlrtPopRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&fi_emlrtRSI, emlrtRootTLSGlobal);
}
return y;
}
/* Function Definitions */
void repmat(const real_T a_data[2201], const int32_T a_size[2], real_T m,
emxArray_real_T *b)
{
boolean_T p;
const mxArray *y;
static const int32_T iv27[2] = { 1, 28 };
const mxArray *m7;
char_T cv27[28];
int32_T i;
static const char_T cv28[28] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'N', 'o', 'n', 'I', 'n', 't', 'e', 'g', 'e', 'r', 'I',
'n', 'p', 'u', 't' };
real_T b_m;
const mxArray *b_y;
static const int32_T iv28[2] = { 1, 21 };
char_T cv29[21];
static const char_T cv30[21] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'p', 'm', 'a', 'x', 's', 'i', 'z', 'e' };
int32_T mv[2];
int32_T outsize[2];
int32_T ib;
int32_T iacol;
int32_T jcol;
boolean_T b2;
int32_T itilerow;
emlrtPushRtStackR2012b(&ki_emlrtRSI, emlrtRootTLSGlobal);
if ((m != m) || muDoubleScalarIsInf(m)) {
p = FALSE;
} else {
p = TRUE;
}
if (p) {
} else {
emlrtPushRtStackR2012b(&oi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m7 = mxCreateCharArray(2, iv27);
for (i = 0; i < 28; i++) {
cv27[i] = cv28[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 28, m7, cv27);
emlrtAssign(&y, m7);
error(message(y, &s_emlrtMCI), &t_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&oi_emlrtRSI, emlrtRootTLSGlobal);
}
if (m <= 0.0) {
b_m = 0.0;
} else {
b_m = m;
}
if (2.147483647E+9 >= b_m) {
} else {
emlrtPushRtStackR2012b(&pi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
b_y = NULL;
m7 = mxCreateCharArray(2, iv28);
for (i = 0; i < 21; i++) {
cv29[i] = cv30[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m7, cv29);
emlrtAssign(&b_y, m7);
error(message(b_y, &u_emlrtMCI), &v_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&pi_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&ki_emlrtRSI, emlrtRootTLSGlobal);
mv[0] = (int32_T)m;
mv[1] = 1;
for (i = 0; i < 2; i++) {
outsize[i] = a_size[i] * mv[i];
}
i = b->size[0] * b->size[1];
b->size[0] = outsize[0];
b->size[1] = outsize[1];
emxEnsureCapacity((emxArray__common *)b, i, (int32_T)sizeof(real_T),
&y_emlrtRTEI);
if (outsize[0] == 0) {
} else {
i = 0;
ib = 0;
emlrtPushRtStackR2012b(&li_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&li_emlrtRSI, emlrtRootTLSGlobal);
iacol = 0;
emlrtPushRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&mi_emlrtRSI, emlrtRootTLSGlobal);
for (jcol = 1; jcol <= a_size[1]; jcol++) {
emlrtPushRtStackR2012b(&ni_emlrtRSI, emlrtRootTLSGlobal);
if (1 > (int32_T)m) {
b2 = FALSE;
} else {
b2 = ((int32_T)m > 2147483646);
}
if (b2) {
emlrtPushRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
check_forloop_overflow_error();
emlrtPopRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&ni_emlrtRSI, emlrtRootTLSGlobal);
for (itilerow = 1; itilerow <= (int32_T)m; itilerow++) {
b->data[ib] = a_data[iacol];
i = iacol + 1;
ib++;
}
iacol = i;
}
}
}
void mldivide(const real_T A[289], real_T B[289])
{
real_T b_A[289];
int8_T ipiv[17];
int32_T jA;
int32_T info;
int32_T j;
int32_T c;
int32_T ix;
real_T temp;
int32_T jy;
real_T s;
int32_T b;
int32_T b_j;
boolean_T b_jA;
int32_T ijA;
char_T DIAGA;
char_T TRANSA;
char_T UPLO;
char_T SIDE;
ptrdiff_t m_t;
ptrdiff_t n_t;
ptrdiff_t lda_t;
ptrdiff_t ldb_t;
double * Aia0_t;
double * Bib0_t;
double * alpha1_t;
emlrtPushRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&sb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal);
memcpy(&b_A[0], &A[0], 289U * sizeof(real_T));
for (jA = 0; jA < 17; jA++) {
ipiv[jA] = (int8_T)(1 + jA);
}
info = 0;
for (j = 0; j < 16; j++) {
c = j * 18;
emlrtPushRtStackR2012b(&xb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&bc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&cc_emlrtRSI, emlrtRootTLSGlobal);
jA = 1;
ix = c;
temp = muDoubleScalarAbs(b_A[c]);
emlrtPushRtStackR2012b(&dc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&dc_emlrtRSI, emlrtRootTLSGlobal);
for (jy = 2; jy <= 17 - j; jy++) {
ix++;
s = muDoubleScalarAbs(b_A[ix]);
if (s > temp) {
jA = jy;
temp = s;
}
}
emlrtPopRtStackR2012b(&cc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&bc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&xb_emlrtRSI, emlrtRootTLSGlobal);
if (b_A[(c + jA) - 1] != 0.0) {
if (jA - 1 != 0) {
ipiv[j] = (int8_T)(j + jA);
eml_xswap(b_A, j + 1, j + jA);
}
b = (c - j) + 17;
emlrtPushRtStackR2012b(&yb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&yb_emlrtRSI, emlrtRootTLSGlobal);
for (jA = c + 1; jA + 1 <= b; jA++) {
b_A[jA] /= b_A[c];
}
} else {
info = j + 1;
}
emlrtPushRtStackR2012b(&ac_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&fc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hc_emlrtRSI, emlrtRootTLSGlobal);
jA = c;
jy = c + 17;
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
for (b_j = 1; b_j <= 16 - j; b_j++) {
temp = b_A[jy];
if (b_A[jy] != 0.0) {
ix = c + 1;
b = (jA - j) + 34;
emlrtPushRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
if (jA + 19 > b) {
b_jA = FALSE;
} else {
b_jA = (b > 2147483646);
}
if (b_jA) {
emlrtPushRtStackR2012b(&g_emlrtRSI, emlrtRootTLSGlobal);
check_forloop_overflow_error();
emlrtPopRtStackR2012b(&g_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
for (ijA = jA + 18; ijA + 1 <= b; ijA++) {
b_A[ijA] += b_A[ix] * -temp;
ix++;
}
}
jy += 17;
jA += 17;
}
emlrtPopRtStackR2012b(&hc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&fc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ac_emlrtRSI, emlrtRootTLSGlobal);
}
if ((info == 0) && (!(b_A[288] != 0.0))) {
info = 17;
}
emlrtPopRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&sb_emlrtRSI, emlrtRootTLSGlobal);
if (info > 0) {
emlrtPushRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&kc_emlrtRSI, emlrtRootTLSGlobal);
eml_warning();
emlrtPopRtStackR2012b(&kc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&rb_emlrtRSI, emlrtRootTLSGlobal);
}
for (jA = 0; jA < 17; jA++) {
if (ipiv[jA] != jA + 1) {
for (j = 0; j < 17; j++) {
temp = B[jA + 17 * j];
B[jA + 17 * j] = B[(ipiv[jA] + 17 * j) - 1];
B[(ipiv[jA] + 17 * j) - 1] = temp;
}
}
}
emlrtPushRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&mc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
temp = 1.0;
DIAGA = 'U';
TRANSA = 'N';
UPLO = 'L';
SIDE = 'L';
emlrtPushRtStackR2012b(&oc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
m_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&pc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
n_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&pc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
lda_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldb_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&sc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Aia0_t = (double *)(&b_A[0]);
emlrtPopRtStackR2012b(&sc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&tc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Bib0_t = (double *)(&B[0]);
emlrtPopRtStackR2012b(&tc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&uc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
alpha1_t = (double *)(&temp);
emlrtPopRtStackR2012b(&uc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&vc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
dtrsm(&SIDE, &UPLO, &TRANSA, &DIAGA, &m_t, &n_t, alpha1_t, Aia0_t, &lda_t,
Bib0_t, &ldb_t);
emlrtPopRtStackR2012b(&vc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&mc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&mc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
temp = 1.0;
DIAGA = 'N';
TRANSA = 'N';
UPLO = 'U';
SIDE = 'L';
emlrtPushRtStackR2012b(&oc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
m_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&pc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
n_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&pc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
lda_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldb_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&sc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Aia0_t = (double *)(&b_A[0]);
emlrtPopRtStackR2012b(&sc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&tc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Bib0_t = (double *)(&B[0]);
emlrtPopRtStackR2012b(&tc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&uc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
alpha1_t = (double *)(&temp);
emlrtPopRtStackR2012b(&uc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&vc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
dtrsm(&SIDE, &UPLO, &TRANSA, &DIAGA, &m_t, &n_t, alpha1_t, Aia0_t, &lda_t,
Bib0_t, &ldb_t);
emlrtPopRtStackR2012b(&vc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&nc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&mc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal);
}
boolean_T b_any(const emxArray_boolean_T *x)
{
boolean_T y;
boolean_T overflow;
boolean_T p;
int32_T i;
int32_T exitg2;
const mxArray *b_y;
static const int32_T iv35[2] = { 1, 41 };
const mxArray *m10;
char_T cv39[41];
static const char_T cv40[41] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
'l', 'b', 'o', 'x', ':', 'e', 'm', 'l', '_', 'a', 'l', 'l', '_', 'o', 'r',
'_', 'a', 'n', 'y', '_', 's', 'p', 'e', 'c', 'i', 'a', 'l', 'E', 'm', 'p',
't', 'y' };
const mxArray *c_y;
static const int32_T iv36[2] = { 1, 51 };
char_T cv41[51];
static const char_T cv42[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;
emlrtPushRtStackR2012b(&gj_emlrtRSI, emlrtRootTLSGlobal);
overflow = FALSE;
p = FALSE;
i = 0;
do {
exitg2 = 0;
if (i < 2) {
if (x->size[i] != 0) {
exitg2 = 1;
} else {
i++;
}
} else {
p = TRUE;
exitg2 = 1;
}
} while (exitg2 == 0);
if (!p) {
} else {
overflow = TRUE;
}
if (!overflow) {
} else {
emlrtPushRtStackR2012b(&hj_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
b_y = NULL;
m10 = mxCreateCharArray(2, iv35);
for (i = 0; i < 41; i++) {
cv39[i] = cv40[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 41, m10, cv39);
emlrtAssign(&b_y, m10);
error(message(b_y, &bb_emlrtMCI), &cb_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&hj_emlrtRSI, emlrtRootTLSGlobal);
}
if ((x->size[1] == 1) || (x->size[1] != 1)) {
overflow = TRUE;
} else {
overflow = FALSE;
}
if (overflow) {
} else {
emlrtPushRtStackR2012b(&ij_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
c_y = NULL;
m10 = mxCreateCharArray(2, iv36);
for (i = 0; i < 51; i++) {
cv41[i] = cv42[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 51, m10, cv41);
emlrtAssign(&c_y, m10);
error(message(c_y, &db_emlrtMCI), &eb_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&ij_emlrtRSI, emlrtRootTLSGlobal);
}
y = FALSE;
emlrtPushRtStackR2012b(&jj_emlrtRSI, emlrtRootTLSGlobal);
if (1 > x->size[1]) {
overflow = FALSE;
} else {
overflow = (x->size[1] > 2147483646);
}
if (overflow) {
emlrtPushRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
check_forloop_overflow_error();
emlrtPopRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&jj_emlrtRSI, emlrtRootTLSGlobal);
i = 1;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (i <= x->size[1])) {
overflow = (x->data[i - 1] == 0);
if (!overflow) {
y = TRUE;
exitg1 = TRUE;
} else {
i++;
}
}
emlrtPopRtStackR2012b(&gj_emlrtRSI, emlrtRootTLSGlobal);
return y;
}
/* Function Definitions */
void any(const emxArray_boolean_T *x, emxArray_boolean_T *y)
{
boolean_T overflow;
boolean_T p;
int32_T i;
int32_T exitg2;
const mxArray *b_y;
static const int32_T iv33[2] = { 1, 41 };
const mxArray *m9;
char_T cv35[41];
static const char_T cv36[41] = { 'C', 'o', 'd', 'e', 'r', ':', 't', 'o', 'o',
'l', 'b', 'o', 'x', ':', 'e', 'm', 'l', '_', 'a', 'l', 'l', '_', 'o', 'r',
'_', 'a', 'n', 'y', '_', 's', 'p', 'e', 'c', 'i', 'a', 'l', 'E', 'm', 'p',
't', 'y' };
const mxArray *c_y;
static const int32_T iv34[2] = { 1, 51 };
char_T cv37[51];
static const char_T cv38[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' };
uint32_T outsize[2];
int32_T i2;
int32_T iy;
int32_T i1;
boolean_T b_i1;
boolean_T exitg1;
emlrtPushRtStackR2012b(&gj_emlrtRSI, emlrtRootTLSGlobal);
overflow = FALSE;
p = FALSE;
i = 0;
do {
exitg2 = 0;
if (i < 2) {
if (x->size[i] != 0) {
exitg2 = 1;
} else {
i++;
}
} else {
p = TRUE;
exitg2 = 1;
}
} while (exitg2 == 0);
if (!p) {
} else {
overflow = TRUE;
}
if (!overflow) {
} else {
emlrtPushRtStackR2012b(&hj_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
b_y = NULL;
m9 = mxCreateCharArray(2, iv33);
for (i = 0; i < 41; i++) {
cv35[i] = cv36[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 41, m9, cv35);
emlrtAssign(&b_y, m9);
error(message(b_y, &bb_emlrtMCI), &cb_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&hj_emlrtRSI, emlrtRootTLSGlobal);
}
if (((x->size[0] == 1) && (x->size[1] == 1)) || (x->size[0] != 1)) {
overflow = TRUE;
} else {
overflow = FALSE;
}
if (overflow) {
} else {
emlrtPushRtStackR2012b(&ij_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
c_y = NULL;
m9 = mxCreateCharArray(2, iv34);
for (i = 0; i < 51; i++) {
cv37[i] = cv38[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 51, m9, cv37);
emlrtAssign(&c_y, m9);
error(message(c_y, &db_emlrtMCI), &eb_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&ij_emlrtRSI, emlrtRootTLSGlobal);
}
for (i = 0; i < 2; i++) {
outsize[i] = (uint32_T)x->size[i];
}
i = y->size[0] * y->size[1];
y->size[0] = 1;
emxEnsureCapacity((emxArray__common *)y, i, (int32_T)sizeof(boolean_T),
&hb_emlrtRTEI);
i = y->size[0] * y->size[1];
y->size[1] = (int32_T)outsize[1];
emxEnsureCapacity((emxArray__common *)y, i, (int32_T)sizeof(boolean_T),
&hb_emlrtRTEI);
i2 = (int32_T)outsize[1];
for (i = 0; i < i2; i++) {
y->data[i] = FALSE;
}
i2 = 0;
iy = -1;
emlrtPushRtStackR2012b(&oj_emlrtRSI, emlrtRootTLSGlobal);
if (1 > x->size[1]) {
overflow = FALSE;
} else {
overflow = (x->size[1] > 2147483646);
}
if (overflow) {
emlrtPushRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
check_forloop_overflow_error();
emlrtPopRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&oj_emlrtRSI, emlrtRootTLSGlobal);
for (i = 1; i <= x->size[1]; i++) {
i1 = i2 + 1;
i2 += x->size[0];
iy++;
emlrtPushRtStackR2012b(&jj_emlrtRSI, emlrtRootTLSGlobal);
if (i1 > i2) {
b_i1 = FALSE;
} else {
b_i1 = (i2 > 2147483646);
}
if (b_i1) {
emlrtPushRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
check_forloop_overflow_error();
emlrtPopRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&jj_emlrtRSI, emlrtRootTLSGlobal);
exitg1 = FALSE;
while ((exitg1 == FALSE) && (i1 <= i2)) {
overflow = (x->data[i1 - 1] == 0);
if (!overflow) {
y->data[iy] = TRUE;
exitg1 = TRUE;
} else {
i1++;
}
}
}
emlrtPopRtStackR2012b(&gj_emlrtRSI, emlrtRootTLSGlobal);
}
/* Function Definitions */
commcodegen_CRCDetector *CRCDetector_CRCDetector(commcodegen_CRCDetector *obj)
{
commcodegen_CRCDetector *b_obj;
commcodegen_CRCDetector *c_obj;
b_obj = obj;
emlrtPushRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
c_obj = b_obj;
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
c_obj->isInitialized = FALSE;
c_obj->isReleased = FALSE;
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qe_emlrtRSI, emlrtRootTLSGlobal);
return b_obj;
}
void d_fprintf(real_T formatSpec)
{
emlrtPushRtStackR2012b(&c_emlrtRSI, emlrtRootTLSGlobal);
e_fprintf(formatSpec);
emlrtPopRtStackR2012b(&c_emlrtRSI, emlrtRootTLSGlobal);
}
void sqrtm(const emxArray_real_T *A, emxArray_creal_T *X, real_T *arg2)
{
emxArray_creal_T *T;
emxArray_creal_T *y;
boolean_T b0;
const mxArray *b_y;
static const int32_T iv40[2] = { 1, 19 };
const mxArray *m2;
char_T cv12[19];
int32_T i;
static const char_T cv13[19] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 's', 'q', 'u', 'a', 'r', 'e' };
emxArray_creal_T *Q;
emxArray_creal_T *r25;
int32_T loop_ub;
int16_T iv41[2];
emxArray_creal_T *R;
real_T s_re;
real_T s_im;
int32_T k;
real_T R_re;
real_T R_im;
real_T T_re;
real_T T_im;
real_T brm;
int32_T i1;
int32_T b_loop_ub;
int32_T i2;
emxArray_creal_T *b_T;
emxArray_real_T *b_X;
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
emxInit_creal_T(&T, 2, &k_emlrtRTEI, TRUE);
emxInit_creal_T(&y, 2, &k_emlrtRTEI, TRUE);
b0 = (A->size[0] == A->size[1]);
if (b0) {
} else {
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
b_y = NULL;
m2 = mxCreateCharArray(2, iv40);
for (i = 0; i < 19; i++) {
cv12[i] = cv13[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 19, m2, cv12);
emlrtAssign(&b_y, m2);
error(message(b_y, &f_emlrtMCI), &g_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
}
emxInit_creal_T(&Q, 2, &k_emlrtRTEI, TRUE);
emxInit_creal_T(&r25, 2, &k_emlrtRTEI, TRUE);
emlrtPushRtStackR2012b(&ib_emlrtRSI, emlrtRootTLSGlobal);
schur(A, Q, r25);
i = T->size[0] * T->size[1];
T->size[0] = r25->size[0];
T->size[1] = r25->size[1];
emxEnsureCapacity((emxArray__common *)T, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = r25->size[0] * r25->size[1];
for (i = 0; i < loop_ub; i++) {
T->data[i] = r25->data[i];
}
emxFree_creal_T(&r25);
emlrtPopRtStackR2012b(&ib_emlrtRSI, emlrtRootTLSGlobal);
for (i = 0; i < 2; i++) {
iv41[i] = (int16_T)T->size[i];
}
emxInit_creal_T(&R, 2, &l_emlrtRTEI, TRUE);
i = R->size[0] * R->size[1];
R->size[0] = iv41[0];
emxEnsureCapacity((emxArray__common *)R, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
i = R->size[0] * R->size[1];
R->size[1] = iv41[1];
emxEnsureCapacity((emxArray__common *)R, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = iv41[0] * iv41[1];
for (i = 0; i < loop_ub; i++) {
R->data[i].re = 0.0;
R->data[i].im = 0.0;
}
emlrtPushRtStackR2012b(&jb_emlrtRSI, emlrtRootTLSGlobal);
b0 = isUTmatD(T);
emlrtPopRtStackR2012b(&jb_emlrtRSI, emlrtRootTLSGlobal);
if (b0) {
emlrtPushRtStackR2012b(&kb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&kb_emlrtRSI, emlrtRootTLSGlobal);
for (loop_ub = 0; loop_ub + 1 <= A->size[0]; loop_ub++) {
R->data[loop_ub + R->size[0] * loop_ub] = T->data[loop_ub + T->size[0] *
loop_ub];
c_sqrt(&R->data[loop_ub + R->size[0] * loop_ub]);
}
} else {
emlrtPushRtStackR2012b(&lb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&lb_emlrtRSI, emlrtRootTLSGlobal);
for (loop_ub = 0; loop_ub + 1 <= A->size[0]; loop_ub++) {
R->data[loop_ub + R->size[0] * loop_ub] = T->data[loop_ub + T->size[0] *
loop_ub];
c_sqrt(&R->data[loop_ub + R->size[0] * loop_ub]);
for (i = loop_ub - 1; i + 1 > 0; i--) {
s_re = 0.0;
s_im = 0.0;
emlrtPushRtStackR2012b(&mb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&mb_emlrtRSI, emlrtRootTLSGlobal);
for (k = i + 1; k + 1 <= loop_ub; k++) {
R_re = R->data[i + R->size[0] * k].re * R->data[k + R->size[0] *
loop_ub].re - R->data[i + R->size[0] * k].im * R->data[k + R->size[0]
* loop_ub].im;
R_im = R->data[i + R->size[0] * k].re * R->data[k + R->size[0] *
loop_ub].im + R->data[i + R->size[0] * k].im * R->data[k + R->size[0]
* loop_ub].re;
s_re += R_re;
s_im += R_im;
}
T_re = T->data[i + T->size[0] * loop_ub].re - s_re;
T_im = T->data[i + T->size[0] * loop_ub].im - s_im;
R_re = R->data[i + R->size[0] * i].re + R->data[loop_ub + R->size[0] *
loop_ub].re;
R_im = R->data[i + R->size[0] * i].im + R->data[loop_ub + R->size[0] *
loop_ub].im;
if (R_im == 0.0) {
if (T_im == 0.0) {
R->data[i + R->size[0] * loop_ub].re = T_re / R_re;
R->data[i + R->size[0] * loop_ub].im = 0.0;
} else if (T_re == 0.0) {
R->data[i + R->size[0] * loop_ub].re = 0.0;
R->data[i + R->size[0] * loop_ub].im = T_im / R_re;
} else {
R->data[i + R->size[0] * loop_ub].re = T_re / R_re;
R->data[i + R->size[0] * loop_ub].im = T_im / R_re;
}
} else if (R_re == 0.0) {
if (T_re == 0.0) {
R->data[i + R->size[0] * loop_ub].re = T_im / R_im;
R->data[i + R->size[0] * loop_ub].im = 0.0;
} else if (T_im == 0.0) {
R->data[i + R->size[0] * loop_ub].re = 0.0;
R->data[i + R->size[0] * loop_ub].im = -(T_re / R_im);
} else {
R->data[i + R->size[0] * loop_ub].re = T_im / R_im;
R->data[i + R->size[0] * loop_ub].im = -(T_re / R_im);
}
} else {
brm = muDoubleScalarAbs(R_re);
s_re = muDoubleScalarAbs(R_im);
if (brm > s_re) {
s_re = R_im / R_re;
s_im = R_re + s_re * R_im;
R->data[i + R->size[0] * loop_ub].re = (T_re + s_re * T_im) / s_im;
R->data[i + R->size[0] * loop_ub].im = (T_im - s_re * T_re) / s_im;
} else if (s_re == brm) {
if (R_re > 0.0) {
s_im = 0.5;
} else {
s_im = -0.5;
}
if (R_im > 0.0) {
s_re = 0.5;
} else {
s_re = -0.5;
}
R->data[i + R->size[0] * loop_ub].re = (T_re * s_im + T_im * s_re) /
brm;
R->data[i + R->size[0] * loop_ub].im = (T_im * s_im - T_re * s_re) /
brm;
} else {
s_re = R_re / R_im;
s_im = R_im + s_re * R_re;
R->data[i + R->size[0] * loop_ub].re = (s_re * T_re + T_im) / s_im;
R->data[i + R->size[0] * loop_ub].im = (s_re * T_im - T_re) / s_im;
}
}
}
}
}
emlrtPushRtStackR2012b(&nb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&kh_emlrtRSI, emlrtRootTLSGlobal);
dynamic_size_checks(Q, R);
emlrtPopRtStackR2012b(&kh_emlrtRSI, emlrtRootTLSGlobal);
if ((Q->size[1] == 1) || (R->size[0] == 1)) {
i = y->size[0] * y->size[1];
y->size[0] = Q->size[0];
y->size[1] = R->size[1];
emxEnsureCapacity((emxArray__common *)y, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = Q->size[0];
for (i = 0; i < loop_ub; i++) {
k = R->size[1];
for (i1 = 0; i1 < k; i1++) {
y->data[i + y->size[0] * i1].re = 0.0;
y->data[i + y->size[0] * i1].im = 0.0;
b_loop_ub = Q->size[1];
for (i2 = 0; i2 < b_loop_ub; i2++) {
s_re = Q->data[i + Q->size[0] * i2].re * R->data[i2 + R->size[0] * i1]
.re - Q->data[i + Q->size[0] * i2].im * R->data[i2 + R->size[0] * i1]
.im;
s_im = Q->data[i + Q->size[0] * i2].re * R->data[i2 + R->size[0] * i1]
.im + Q->data[i + Q->size[0] * i2].im * R->data[i2 + R->size[0] * i1]
.re;
y->data[i + y->size[0] * i1].re += s_re;
y->data[i + y->size[0] * i1].im += s_im;
}
}
}
} else {
iv41[0] = (int16_T)Q->size[0];
iv41[1] = (int16_T)R->size[1];
emlrtPushRtStackR2012b(&jh_emlrtRSI, emlrtRootTLSGlobal);
i = y->size[0] * y->size[1];
y->size[0] = iv41[0];
emxEnsureCapacity((emxArray__common *)y, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
i = y->size[0] * y->size[1];
y->size[1] = iv41[1];
emxEnsureCapacity((emxArray__common *)y, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = iv41[0] * iv41[1];
for (i = 0; i < loop_ub; i++) {
y->data[i].re = 0.0;
y->data[i].im = 0.0;
}
eml_xgemm(Q->size[0], R->size[1], Q->size[1], Q, Q->size[0], R, Q->size[1],
y, Q->size[0]);
emlrtPopRtStackR2012b(&jh_emlrtRSI, emlrtRootTLSGlobal);
}
emxFree_creal_T(&R);
i = T->size[0] * T->size[1];
T->size[0] = Q->size[1];
T->size[1] = Q->size[0];
emxEnsureCapacity((emxArray__common *)T, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = Q->size[0];
for (i = 0; i < loop_ub; i++) {
k = Q->size[1];
for (i1 = 0; i1 < k; i1++) {
T->data[i1 + T->size[0] * i].re = Q->data[i + Q->size[0] * i1].re;
T->data[i1 + T->size[0] * i].im = -Q->data[i + Q->size[0] * i1].im;
}
}
emxFree_creal_T(&Q);
emlrtPushRtStackR2012b(&kh_emlrtRSI, emlrtRootTLSGlobal);
dynamic_size_checks(y, T);
emlrtPopRtStackR2012b(&kh_emlrtRSI, emlrtRootTLSGlobal);
if ((y->size[1] == 1) || (T->size[0] == 1)) {
i = X->size[0] * X->size[1];
X->size[0] = y->size[0];
X->size[1] = T->size[1];
emxEnsureCapacity((emxArray__common *)X, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = y->size[0];
for (i = 0; i < loop_ub; i++) {
k = T->size[1];
for (i1 = 0; i1 < k; i1++) {
X->data[i + X->size[0] * i1].re = 0.0;
X->data[i + X->size[0] * i1].im = 0.0;
b_loop_ub = y->size[1];
for (i2 = 0; i2 < b_loop_ub; i2++) {
s_re = y->data[i + y->size[0] * i2].re * T->data[i2 + T->size[0] * i1]
.re - y->data[i + y->size[0] * i2].im * T->data[i2 + T->size[0] * i1]
.im;
s_im = y->data[i + y->size[0] * i2].re * T->data[i2 + T->size[0] * i1]
.im + y->data[i + y->size[0] * i2].im * T->data[i2 + T->size[0] * i1]
.re;
X->data[i + X->size[0] * i1].re += s_re;
X->data[i + X->size[0] * i1].im += s_im;
}
}
}
} else {
iv41[0] = (int16_T)y->size[0];
iv41[1] = (int16_T)T->size[1];
emlrtPushRtStackR2012b(&jh_emlrtRSI, emlrtRootTLSGlobal);
i = X->size[0] * X->size[1];
X->size[0] = iv41[0];
emxEnsureCapacity((emxArray__common *)X, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
i = X->size[0] * X->size[1];
X->size[1] = iv41[1];
emxEnsureCapacity((emxArray__common *)X, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = iv41[0] * iv41[1];
for (i = 0; i < loop_ub; i++) {
X->data[i].re = 0.0;
X->data[i].im = 0.0;
}
eml_xgemm(y->size[0], T->size[1], y->size[1], y, y->size[0], T, y->size[1],
X, y->size[0]);
emlrtPopRtStackR2012b(&jh_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&nb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&kh_emlrtRSI, emlrtRootTLSGlobal);
dynamic_size_checks(X, X);
emlrtPopRtStackR2012b(&kh_emlrtRSI, emlrtRootTLSGlobal);
if ((X->size[1] == 1) || (X->size[0] == 1)) {
i = T->size[0] * T->size[1];
T->size[0] = X->size[0];
T->size[1] = X->size[1];
emxEnsureCapacity((emxArray__common *)T, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = X->size[0];
for (i = 0; i < loop_ub; i++) {
k = X->size[1];
for (i1 = 0; i1 < k; i1++) {
T->data[i + T->size[0] * i1].re = 0.0;
T->data[i + T->size[0] * i1].im = 0.0;
b_loop_ub = X->size[1];
for (i2 = 0; i2 < b_loop_ub; i2++) {
s_re = X->data[i + X->size[0] * i2].re * X->data[i2 + X->size[0] * i1]
.re - X->data[i + X->size[0] * i2].im * X->data[i2 + X->size[0] * i1]
.im;
s_im = X->data[i + X->size[0] * i2].re * X->data[i2 + X->size[0] * i1]
.im + X->data[i + X->size[0] * i2].im * X->data[i2 + X->size[0] * i1]
.re;
T->data[i + T->size[0] * i1].re += s_re;
T->data[i + T->size[0] * i1].im += s_im;
}
}
}
} else {
iv41[0] = (int16_T)X->size[0];
iv41[1] = (int16_T)X->size[1];
emlrtPushRtStackR2012b(&jh_emlrtRSI, emlrtRootTLSGlobal);
i = T->size[0] * T->size[1];
T->size[0] = iv41[0];
emxEnsureCapacity((emxArray__common *)T, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
i = T->size[0] * T->size[1];
T->size[1] = iv41[1];
emxEnsureCapacity((emxArray__common *)T, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = iv41[0] * iv41[1];
for (i = 0; i < loop_ub; i++) {
T->data[i].re = 0.0;
T->data[i].im = 0.0;
}
eml_xgemm(X->size[0], X->size[1], X->size[1], X, X->size[0], X, X->size[1],
T, X->size[0]);
emlrtPopRtStackR2012b(&jh_emlrtRSI, emlrtRootTLSGlobal);
}
emxInit_creal_T(&b_T, 2, &k_emlrtRTEI, TRUE);
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
i = b_T->size[0] * b_T->size[1];
b_T->size[0] = T->size[0];
b_T->size[1] = T->size[1];
emxEnsureCapacity((emxArray__common *)b_T, i, (int32_T)sizeof(creal_T),
&k_emlrtRTEI);
loop_ub = T->size[0] * T->size[1];
for (i = 0; i < loop_ub; i++) {
b_T->data[i].re = T->data[i].re - A->data[i];
b_T->data[i].im = T->data[i].im;
}
emxInit_real_T(&b_X, 2, &k_emlrtRTEI, TRUE);
s_re = norm(b_T);
s_im = b_norm(A);
*arg2 = s_re / s_im;
emlrtPopRtStackR2012b(&ob_emlrtRSI, emlrtRootTLSGlobal);
i = b_X->size[0] * b_X->size[1];
b_X->size[0] = X->size[0];
b_X->size[1] = X->size[1];
emxEnsureCapacity((emxArray__common *)b_X, i, (int32_T)sizeof(real_T),
&k_emlrtRTEI);
loop_ub = X->size[0] * X->size[1];
emxFree_creal_T(&b_T);
for (i = 0; i < loop_ub; i++) {
b_X->data[i] = X->data[i].im;
}
if (c_norm(b_X) <= 10.0 * (real_T)A->size[0] * 2.2204460492503131E-16 * d_norm
(X)) {
emlrtPushRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&pb_emlrtRSI, emlrtRootTLSGlobal);
for (loop_ub = 0; loop_ub + 1 <= A->size[0]; loop_ub++) {
emlrtPushRtStackR2012b(&qb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&qb_emlrtRSI, emlrtRootTLSGlobal);
for (i = 0; i + 1 <= A->size[0]; i++) {
s_re = X->data[i + X->size[0] * loop_ub].re;
X->data[i + X->size[0] * loop_ub].re = s_re;
X->data[i + X->size[0] * loop_ub].im = 0.0;
}
}
}
emxFree_real_T(&b_X);
emxFree_creal_T(&y);
emxFree_creal_T(&T);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
}
/* Function Definitions */
static void eml_xgemm(int32_T m, int32_T n, int32_T k, const emxArray_creal_T *A,
int32_T lda, const emxArray_creal_T *B, int32_T ldb,
emxArray_creal_T *C, int32_T ldc)
{
char_T TRANSB;
char_T TRANSA;
ptrdiff_t m_t;
ptrdiff_t n_t;
ptrdiff_t k_t;
ptrdiff_t lda_t;
ptrdiff_t ldb_t;
ptrdiff_t ldc_t;
static const creal_T alpha1 = { 1.0, 0.0 };
double * alpha1_t;
double * Aia0_t;
double * Bib0_t;
static const creal_T beta1 = { 0.0, 0.0 };
double * beta1_t;
double * Cic0_t;
emlrtPushRtStackR2012b(&nh_emlrtRSI, emlrtRootTLSGlobal);
if ((m < 1) || (n < 1) || (k < 1)) {
} else {
emlrtPushRtStackR2012b(&ph_emlrtRSI, emlrtRootTLSGlobal);
TRANSB = 'N';
TRANSA = 'N';
emlrtPushRtStackR2012b(&vh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
m_t = (ptrdiff_t)(m);
emlrtPopRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&vh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&wh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
n_t = (ptrdiff_t)(n);
emlrtPopRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&wh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&xh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
k_t = (ptrdiff_t)(k);
emlrtPopRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&xh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&yh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
lda_t = (ptrdiff_t)(lda);
emlrtPopRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&yh_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ai_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldb_t = (ptrdiff_t)(ldb);
emlrtPopRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ai_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&bi_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldc_t = (ptrdiff_t)(ldc);
emlrtPopRtStackR2012b(&rc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&bi_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ci_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
alpha1_t = (double *)(&alpha1);
emlrtPopRtStackR2012b(&ci_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&di_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Aia0_t = (double *)(&A->data[0]);
emlrtPopRtStackR2012b(&di_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ei_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Bib0_t = (double *)(&B->data[0]);
emlrtPopRtStackR2012b(&ei_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&fi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&fi_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&gi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Cic0_t = (double *)(&C->data[0]);
emlrtPopRtStackR2012b(&gi_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
zgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t, Bib0_t,
&ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&hi_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ph_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&nh_emlrtRSI, emlrtRootTLSGlobal);
}
/* Function Definitions */
void eye(real_T n, emxArray_real_T *I)
{
boolean_T p;
const mxArray *y;
static const int32_T iv37[2] = { 1, 28 };
const mxArray *m11;
char_T cv43[28];
int32_T i;
static const char_T cv44[28] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'N', 'o', 'n', 'I', 'n', 't', 'e', 'g', 'e', 'r', 'I',
'n', 'p', 'u', 't' };
const mxArray *b_y;
static const int32_T iv38[2] = { 1, 28 };
real_T b_n;
real_T c_n;
const mxArray *c_y;
static const int32_T iv39[2] = { 1, 21 };
char_T cv45[21];
static const char_T cv46[21] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'p', 'm', 'a', 'x', 's', 'i', 'z', 'e' };
int32_T loop_ub;
real_T minval;
boolean_T b6;
emlrtPushRtStackR2012b(&dm_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&em_emlrtRSI, emlrtRootTLSGlobal);
if ((n != n) || muDoubleScalarIsInf(n)) {
p = FALSE;
} else {
p = TRUE;
}
if (p) {
} else {
emlrtPushRtStackR2012b(&oi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m11 = mxCreateCharArray(2, iv37);
for (i = 0; i < 28; i++) {
cv43[i] = cv44[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 28, m11, cv43);
emlrtAssign(&y, m11);
error(message(y, &s_emlrtMCI), &t_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&oi_emlrtRSI, emlrtRootTLSGlobal);
}
if ((n != n) || muDoubleScalarIsInf(n)) {
p = FALSE;
} else {
p = TRUE;
}
if (p) {
} else {
emlrtPushRtStackR2012b(&oi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
b_y = NULL;
m11 = mxCreateCharArray(2, iv38);
for (i = 0; i < 28; i++) {
cv43[i] = cv44[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 28, m11, cv43);
emlrtAssign(&b_y, m11);
error(message(b_y, &s_emlrtMCI), &t_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&oi_emlrtRSI, emlrtRootTLSGlobal);
}
if (n <= 0.0) {
b_n = 0.0;
} else {
if (n <= 0.0) {
c_n = 0.0;
} else {
c_n = n;
}
b_n = c_n * n;
}
if (2.147483647E+9 >= b_n) {
} else {
emlrtPushRtStackR2012b(&pi_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
c_y = NULL;
m11 = mxCreateCharArray(2, iv39);
for (i = 0; i < 21; i++) {
cv45[i] = cv46[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m11, cv45);
emlrtAssign(&c_y, m11);
error(message(c_y, &u_emlrtMCI), &v_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&pi_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&em_emlrtRSI, emlrtRootTLSGlobal);
i = I->size[0] * I->size[1];
I->size[0] = (int32_T)n;
I->size[1] = (int32_T)n;
emxEnsureCapacity((emxArray__common *)I, i, (int32_T)sizeof(real_T),
&pb_emlrtRTEI);
loop_ub = (int32_T)n * (int32_T)n;
for (i = 0; i < loop_ub; i++) {
I->data[i] = 0.0;
}
minval = muDoubleScalarMin(n, n);
if ((int32_T)minval > 0) {
emlrtPushRtStackR2012b(&fm_emlrtRSI, emlrtRootTLSGlobal);
if (1 > (int32_T)minval) {
b6 = FALSE;
} else {
b6 = ((int32_T)minval > 2147483646);
}
if (b6) {
emlrtPushRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
check_forloop_overflow_error();
emlrtPopRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&fm_emlrtRSI, emlrtRootTLSGlobal);
for (i = 0; i + 1 <= (int32_T)minval; i++) {
I->data[i + I->size[0] * i] = 1.0;
}
}
emlrtPopRtStackR2012b(&dm_emlrtRSI, emlrtRootTLSGlobal);
}
/* Function Definitions */
real_T signalPower(const emxArray_creal_T *input)
{
real_T out;
emxArray_real_T *a;
emxArray_real_T *b;
int32_T i2;
int32_T i;
const mxArray *y;
static const int32_T iv11[2] = { 1, 45 };
const mxArray *m1;
char_T cv17[45];
static const char_T cv18[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 iv12[2] = { 1, 21 };
char_T cv19[21];
static const char_T cv20[21] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'i', 'n', 'n', 'e', 'r', 'd', 'i', 'm' };
real_T c_y;
ptrdiff_t n_t;
ptrdiff_t incx_t;
ptrdiff_t incy_t;
double * xix0_t;
double * yiy0_t;
emlrtHeapReferenceStackEnterFcnR2012b(emlrtRootTLSGlobal);
b_emxInit_real_T(&a, 2, &f_emlrtRTEI, TRUE);
emxInit_real_T(&b, 1, &f_emlrtRTEI, TRUE);
/* out=input'*input/sentBitsSize; */
/* out=abs(out); */
emlrtPushRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
b_abs(input, b);
i2 = a->size[0] * a->size[1];
a->size[0] = 1;
emxEnsureCapacity((emxArray__common *)a, i2, (int32_T)sizeof(real_T),
&f_emlrtRTEI);
i = b->size[0];
i2 = a->size[0] * a->size[1];
a->size[1] = i;
emxEnsureCapacity((emxArray__common *)a, i2, (int32_T)sizeof(real_T),
&f_emlrtRTEI);
i = b->size[0];
for (i2 = 0; i2 < i; i2++) {
a->data[i2] = b->data[i2];
}
b_abs(input, b);
emlrtPushRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
if (!(a->size[1] == b->size[0])) {
if ((a->size[1] == 1) || (b->size[0] == 1)) {
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
y = NULL;
m1 = mxCreateCharArray(2, iv11);
for (i = 0; i < 45; i++) {
cv17[i] = cv18[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 45, m1, cv17);
emlrtAssign(&y, m1);
error(message(y, &i_emlrtMCI), &j_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
} else {
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrt_synchGlobalsToML();
b_y = NULL;
m1 = mxCreateCharArray(2, iv12);
for (i = 0; i < 21; i++) {
cv19[i] = cv20[i];
}
emlrtInitCharArrayR2013a(emlrtRootTLSGlobal, 21, m1, cv19);
emlrtAssign(&b_y, m1);
error(message(b_y, &k_emlrtMCI), &l_emlrtMCI);
emlrt_synchGlobalsFromML();
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
}
}
emlrtPopRtStackR2012b(&n_emlrtRSI, emlrtRootTLSGlobal);
if ((a->size[1] == 1) || (b->size[0] == 1)) {
c_y = 0.0;
for (i2 = 0; i2 < a->size[1]; i2++) {
c_y += a->data[a->size[0] * i2] * b->data[i2];
}
} else {
emlrtPushRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
if (a->size[1] < 1) {
c_y = 0.0;
} else {
emlrtPushRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&y_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
n_t = (ptrdiff_t)(a->size[1]);
emlrtPopRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&y_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
incx_t = (ptrdiff_t)(1);
emlrtPopRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ab_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&bb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
incy_t = (ptrdiff_t)(1);
emlrtPopRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&bb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&cb_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
xix0_t = (double *)(&a->data[0]);
emlrtPopRtStackR2012b(&cb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
yiy0_t = (double *)(&b->data[0]);
emlrtPopRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
c_y = ddot(&n_t, xix0_t, &incx_t, yiy0_t, &incy_t);
emlrtPopRtStackR2012b(&t_emlrtRSI, emlrtRootTLSGlobal);
}
emlrtPopRtStackR2012b(&r_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&m_emlrtRSI, emlrtRootTLSGlobal);
}
emxFree_real_T(&b);
emxFree_real_T(&a);
out = c_y / (real_T)input->size[0];
emlrtPopRtStackR2012b(&l_emlrtRSI, emlrtRootTLSGlobal);
emlrtHeapReferenceStackLeaveFcnR2012b(emlrtRootTLSGlobal);
return out;
}
/* Function Definitions */
commcodegen_CRCDetector *CRCDetector_CRCDetector(commcodegen_CRCDetector *obj)
{
commcodegen_CRCDetector *b_obj;
commcodegen_CRCDetector *c_obj;
comm_CRCDetector_6 *d_obj;
int32_T i;
static const int8_T iv79[256] = { 0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0 };
b_obj = obj;
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
c_obj = b_obj;
emlrtPushRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
c_obj->isInitialized = FALSE;
c_obj->isReleased = FALSE;
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
c_obj->inputDirectFeedthrough1 = FALSE;
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&p_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&o_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
d_obj = &b_obj->cSFunObject;
/* System object Constructor function: comm.CRCDetector */
d_obj->S0_isInitialized = FALSE;
d_obj->S1_isReleased = FALSE;
for (i = 0; i < 256; i++) {
d_obj->P0_CRCTable[i] = (uint32_T)iv79[i];
}
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&v_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&q_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&oe_emlrtRSI, emlrtRootTLSGlobal);
return b_obj;
}
