/* Function Definitions */
real_T util_sub_jaccard_index(real_T a, real_T b)
{
real_T result;
real_T dotproduct;
/* JACCARD_INDEX Calculating the Jaccard Coefficient Index between a and b. */
/* */
/* This is the extented jaccard index, a.k.a. Tanimoto coefficient */
/* */
/* Created on Aug/28/2010 By Pu Jiangbo */
/* Britton Chance Center for Biomedical Photonics */
/* PJB#2012-07-04 Adding assert for codegen */
/* Assert Class for Codegen */
/* This is slow */
/* dotproduct = dot(a, b); */
/* Because when a and b are both column vectors, a'*b is the same as dot(a,b) */
dotproduct = a * b;
/* Avoid nan (0/0 = NaN) */
if (!(dotproduct != 0.0)) {
result = 0.0;
} else {
result = dotproduct / ((muDoubleScalarPower(muDoubleScalarAbs(a), 2.0) +
muDoubleScalarPower(muDoubleScalarAbs(b), 2.0)) - dotproduct);
}
return result;
}
return ( true ) ; } real_T Deadbeat_CUK_acc_rt_TDelayInterpolate ( real_T
tMinusDelay , real_T tStart , real_T * tBuf , real_T * uBuf , int_T bufSz ,
int_T * lastIdx , int_T oldestIdx , int_T newIdx , real_T initOutput ,
boolean_T discrete , boolean_T minorStepAndTAtLastMajorOutput ) { int_T i ;
real_T yout , t1 , t2 , u1 , u2 ; if ( ( newIdx == 0 ) && ( oldestIdx == 0 )
&& ( tMinusDelay > tStart ) ) return initOutput ; if ( tMinusDelay <= tStart
) return initOutput ; if ( ( tMinusDelay <= tBuf [ oldestIdx ] ) ) { if (
discrete ) { return ( uBuf [ oldestIdx ] ) ; } else { int_T tempIdx =
oldestIdx + 1 ; if ( oldestIdx == bufSz - 1 ) tempIdx = 0 ; t1 = tBuf [
oldestIdx ] ; t2 = tBuf [ tempIdx ] ; u1 = uBuf [ oldestIdx ] ; u2 = uBuf [
tempIdx ] ; if ( t2 == t1 ) { if ( tMinusDelay >= t2 ) { yout = u2 ; } else {
yout = u1 ; } } else { real_T f1 = ( t2 - tMinusDelay ) / ( t2 - t1 ) ;
real_T f2 = 1.0 - f1 ; yout = f1 * u1 + f2 * u2 ; } return yout ; } } if (
minorStepAndTAtLastMajorOutput ) { if ( newIdx != 0 ) { if ( * lastIdx ==
newIdx ) { ( * lastIdx ) -- ; } newIdx -- ; } else { if ( * lastIdx == newIdx
) { * lastIdx = bufSz - 1 ; } newIdx = bufSz - 1 ; } } i = * lastIdx ; if (
tBuf [ i ] < tMinusDelay ) { while ( tBuf [ i ] < tMinusDelay ) { if ( i ==
newIdx ) break ; i = ( i < ( bufSz - 1 ) ) ? ( i + 1 ) : 0 ; } } else { while
( tBuf [ i ] >= tMinusDelay ) { i = ( i > 0 ) ? i - 1 : ( bufSz - 1 ) ; } i =
( i < ( bufSz - 1 ) ) ? ( i + 1 ) : 0 ; } * lastIdx = i ; if ( discrete ) {
double tempEps = ( DBL_EPSILON ) * 128.0 ; double localEps = tempEps *
muDoubleScalarAbs ( tBuf [ i ] ) ; if ( tempEps > localEps ) { localEps =
tempEps ; } localEps = localEps / 2.0 ; if ( tMinusDelay >= ( tBuf [ i ] -
localEps ) ) { yout = uBuf [ i ] ; } else { if ( i == 0 ) { yout = uBuf [
bufSz - 1 ] ; } else { yout = uBuf [ i - 1 ] ; } } } else { if ( i == 0 ) {
t1 = tBuf [ bufSz - 1 ] ; u1 = uBuf [ bufSz - 1 ] ; } else { t1 = tBuf [ i -
1 ] ; u1 = uBuf [ i - 1 ] ; } t2 = tBuf [ i ] ; u2 = uBuf [ i ] ; if ( t2 ==
t1 ) { if ( tMinusDelay >= t2 ) { yout = u2 ; } else { yout = u1 ; } } else {
real_T f1 = ( t2 - tMinusDelay ) / ( t2 - t1 ) ; real_T f2 = 1.0 - f1 ; yout
= f1 * u1 + f2 * u2 ; } } return ( yout ) ; } void e0hptcctem ( mvw1gbh0c1 *
static real_T c3_norm(SFc3_ErdMondInstanceStruct *chartInstance, real_T c3_x[2])
{
real_T c3_y;
real_T c3_scale;
int32_T c3_k;
int32_T c3_b_k;
real_T c3_b_x;
real_T c3_c_x;
real_T c3_absxk;
real_T c3_t;
c3_y = 0.0;
c3_scale = 2.2250738585072014E-308;
c3_eml_int_forloop_overflow_check(chartInstance);
for (c3_k = 1; c3_k < 3; c3_k++) {
c3_b_k = c3_k;
c3_b_x = c3_x[_SFD_EML_ARRAY_BOUNDS_CHECK("", (int32_T)_SFD_INTEGER_CHECK("",
(real_T)c3_b_k), 1, 2, 1, 0) - 1];
c3_c_x = c3_b_x;
c3_absxk = muDoubleScalarAbs(c3_c_x);
if (c3_absxk > c3_scale) {
c3_t = c3_scale / c3_absxk;
c3_y = 1.0 + c3_y * c3_t * c3_t;
c3_scale = c3_absxk;
} else {
c3_t = c3_absxk / c3_scale;
c3_y += c3_t * c3_t;
}
}
return c3_scale * muDoubleScalarSqrt(c3_y);
}
real_T bisection2(real_T a, real_T b, real_T tol)
{
real_T p;
const mxArray *y;
static const int32_T iv0[2] = { 1, 16 };
const mxArray *m0;
static const char_T cv0[16] = { 'W', 'r', 'o', 'n', 'g', ' ', 'c', 'h', 'o',
'i', 'c', 'e', ' ', 'b', 'r', 'o' };
real_T err;
/* provide the equation you want to solve with R.H.S = 0 form. */
/* Write the L.H.S by using inline function */
/* Give initial guesses. */
/* Solves it by method of bisection. */
/* A very simple code and very handy! */
if ((muDoubleScalarPower(a - 1.5, 3.0) + 10.0) * (muDoubleScalarPower(b - 1.5,
3.0) + 10.0) > 0.0) {
EMLRTPUSHRTSTACK(&emlrtRSI);
EMLRTPUSHRTSTACK(&b_emlrtRSI);
y = NULL;
m0 = mxCreateCharArray(2, iv0);
emlrtInitCharArray(16, m0, cv0);
emlrtAssign(&y, m0);
error(y, &emlrtMCI);
EMLRTPOPRTSTACK(&b_emlrtRSI);
EMLRTPOPRTSTACK(&emlrtRSI);
} else {
p = (a + b) / 2.0;
err = muDoubleScalarAbs(b - a);
while (err >= tol) {
if ((muDoubleScalarPower(a - 1.5, 3.0) + 10.0) * (muDoubleScalarPower(p -
1.5, 3.0) + 10.0) < 0.0) {
b = p;
} else {
a = p;
}
p = (a + b) / 2.0;
err = muDoubleScalarAbs(b - a);
emlrtBreakCheck();
}
}
return p;
}
/* Function Definitions */
void b_abs(const emxArray_real_T *x, emxArray_real_T *y)
{
uint32_T unnamed_idx_0;
int32_T k;
unnamed_idx_0 = (uint32_T)x->size[0];
k = y->size[0];
y->size[0] = (int32_T)unnamed_idx_0;
emxEnsureCapacity((emxArray__common *)y, k, (int32_T)sizeof(real_T),
&gb_emlrtRTEI);
for (k = 0; k < x->size[0]; k++) {
y->data[k] = muDoubleScalarAbs(x->data[k]);
}
}
void transceive102_energy(transceive102_energyStackData *SD, const emlrtStack
*sp, const creal_T d2s[1408], boolean_T ft, real_T txGain, real_T rxGain,
real_T centerFreqTx, real_T centerFreqRx, real_T intFactor, real_T decFactor,
real_T swapFreqFlag, creal_T dr[1408], uint32_T *ns)
{
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
memset(&dr[0], 0, 1408U * sizeof(creal_T));
*ns = 0U;
if (!htx_not_empty) {
st.site = &emlrtRSI;
SDRuTransmitter_SDRuTransmitter(&st, &htx, centerFreqTx, txGain, intFactor);
htx_not_empty = true;
}
if (!hrx_not_empty) {
st.site = &b_emlrtRSI;
SDRuReceiver_SDRuReceiver(&st, &hrx, centerFreqRx, decFactor, rxGain);
hrx_not_empty = true;
}
/* listening mode: */
if (muDoubleScalarAbs(centerFreqTx - centerFreqRx) > 0.0) {
/* if Rx and Tx is different, switch for Listening mode */
if (swapFreqFlag != 0.0) {
st.site = &c_emlrtRSI;
SDRuBase_set_CenterFrequency(&hrx, centerFreqTx);
} else {
st.site = &d_emlrtRSI;
SDRuBase_set_CenterFrequency(&hrx, centerFreqRx);
}
}
if (ft) {
st.site = &e_emlrtRSI;
SystemCore_release(&st, &hrx);
st.site = &f_emlrtRSI;
b_SystemCore_release(&st, &htx);
} else {
st.site = &g_emlrtRSI;
SystemCore_step(&st, &htx, d2s);
while (*ns < 1U) {
st.site = &h_emlrtRSI;
b_SystemCore_step(SD, &st, &hrx, dr, ns);
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
}
}
real_T c_norm(const emxArray_real_T *x)
{
real_T y;
int32_T j;
int32_T i;
boolean_T exitg1;
real_T s;
if ((x->size[0] == 1) || (x->size[1] == 1)) {
y = 0.0;
j = x->size[0] * x->size[1];
for (i = 0; i < j; i++) {
y += muDoubleScalarAbs(x->data[i]);
}
} else {
y = 0.0;
j = 0;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (j <= x->size[1] - 1)) {
s = 0.0;
for (i = 0; i < x->size[0]; i++) {
s += muDoubleScalarAbs(x->data[i + x->size[0] * j]);
}
if (muDoubleScalarIsNaN(s)) {
y = rtNaN;
exitg1 = TRUE;
} else {
if (s > y) {
y = s;
}
j++;
}
}
}
return y;
}
void c_abs(const emxArray_real_T *x, emxArray_real_T *y)
{
uint32_T uv2[2];
int32_T k;
for (k = 0; k < 2; k++) {
uv2[k] = (uint32_T)x->size[k];
}
k = y->size[0] * y->size[1];
y->size[0] = 1;
y->size[1] = (int32_T)uv2[1];
emxEnsureCapacity((emxArray__common *)y, k, (int32_T)sizeof(real_T));
for (k = 0; k < x->size[1]; k++) {
y->data[k] = muDoubleScalarAbs(x->data[k]);
}
}
/* Function Definitions */
void b_abs(const emxArray_real_T *x, emxArray_real_T *y)
{
uint32_T uv0[2];
int32_T i4;
int32_T k;
for (i4 = 0; i4 < 2; i4++) {
uv0[i4] = (uint32_T)x->size[i4];
}
i4 = y->size[0] * y->size[1];
y->size[0] = (int32_T)uv0[0];
y->size[1] = (int32_T)uv0[1];
emxEnsureCapacity((emxArray__common *)y, i4, (int32_T)sizeof(real_T));
i4 = x->size[0] * x->size[1];
for (k = 0; k < i4; k++) {
y->data[k] = muDoubleScalarAbs(x->data[k]);
}
}
/* Function Definitions */
real_T norm(const real_T x[3])
{
real_T y;
real_T scale;
int32_T k;
real_T absxk;
real_T t;
y = 0.0;
scale = 3.3121686421112381E-170;
for (k = 0; k < 3; k++) {
absxk = muDoubleScalarAbs(x[k]);
if (absxk > scale) {
t = scale / absxk;
y = 1.0 + y * t * t;
scale = absxk;
} else {
t = absxk / scale;
y += t * t;
}
}
return scale * muDoubleScalarSqrt(y);
}
/* Function Definitions */
real_T norm(const real_T x[4])
{
real_T y;
real_T scale;
int32_T k;
real_T absxk;
real_T t;
y = 0.0;
scale = 2.2250738585072014E-308;
for (k = 0; k < 4; k++) {
absxk = muDoubleScalarAbs(x[k]);
if (absxk > scale) {
t = scale / absxk;
y = 1.0 + y * t * t;
scale = absxk;
} else {
t = absxk / scale;
y += t * t;
}
}
return scale * muDoubleScalarSqrt(y);
}
/* 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 */
void do_vectors(const emlrtStack *sp, const real_T a_data[1224], const int32_T
a_size[1], const real_T b[8], real_T c_data[8], int32_T c_size[1],
int32_T ia_data[8], int32_T ia_size[1], int32_T ib_data[8],
int32_T ib_size[1])
{
int32_T ncmax;
boolean_T y;
int32_T ialast;
boolean_T exitg4;
boolean_T guard9 = FALSE;
boolean_T p;
boolean_T exitg3;
boolean_T guard8 = FALSE;
int32_T nc;
int32_T iafirst;
int32_T ibfirst;
int32_T iblast;
int32_T b_ialast;
real_T ak;
boolean_T exitg2;
real_T absxk;
int32_T exponent;
boolean_T guard6 = FALSE;
boolean_T guard7 = FALSE;
int32_T b_iblast;
real_T bk;
boolean_T exitg1;
int32_T b_exponent;
boolean_T guard4 = FALSE;
boolean_T guard5 = FALSE;
int32_T c_exponent;
boolean_T guard2 = FALSE;
boolean_T guard3 = FALSE;
boolean_T guard1 = FALSE;
const mxArray *b_y;
const mxArray *m20;
int32_T b_ia_data[8];
const mxArray *c_y;
const mxArray *d_y;
real_T b_c_data[8];
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
st.site = &fp_emlrtRSI;
ncmax = muIntScalarMin_sint32(a_size[0], 8);
c_size[0] = (int8_T)ncmax;
ia_size[0] = ncmax;
ib_size[0] = ncmax;
st.site = &gp_emlrtRSI;
y = TRUE;
if (a_size[0] == 0) {
} else {
ialast = 1;
exitg4 = FALSE;
while ((exitg4 == FALSE) && (ialast <= a_size[0] - 1)) {
guard9 = FALSE;
if (a_data[ialast - 1] <= a_data[ialast]) {
guard9 = TRUE;
} else if (muDoubleScalarIsNaN(a_data[ialast])) {
guard9 = TRUE;
} else {
p = FALSE;
}
if (guard9 == TRUE) {
p = TRUE;
}
if (!p) {
y = FALSE;
exitg4 = TRUE;
} else {
ialast++;
}
}
}
if (!y) {
st.site = &hp_emlrtRSI;
eml_error(&st);
}
st.site = &ip_emlrtRSI;
y = TRUE;
ialast = 1;
exitg3 = FALSE;
while ((exitg3 == FALSE) && (ialast < 8)) {
guard8 = FALSE;
if (b[ialast - 1] <= b[ialast]) {
guard8 = TRUE;
} else if (muDoubleScalarIsNaN(b[ialast])) {
guard8 = TRUE;
} else {
p = FALSE;
}
if (guard8 == TRUE) {
p = TRUE;
}
if (!p) {
y = FALSE;
exitg3 = TRUE;
} else {
ialast++;
}
}
if (!y) {
st.site = &jp_emlrtRSI;
b_eml_error(&st);
}
nc = 0;
iafirst = 0;
ialast = 0;
ibfirst = 0;
iblast = 0;
while ((ialast + 1 <= a_size[0]) && (iblast + 1 <= 8)) {
st.site = &kp_emlrtRSI;
b_ialast = ialast + 1;
ak = a_data[ialast];
exitg2 = FALSE;
while ((exitg2 == FALSE) && (b_ialast < a_size[0])) {
absxk = muDoubleScalarAbs(a_data[ialast] / 2.0);
if ((!muDoubleScalarIsInf(absxk)) && (!muDoubleScalarIsNaN(absxk))) {
if (absxk <= 2.2250738585072014E-308) {
absxk = 4.94065645841247E-324;
} else {
frexp(absxk, &exponent);
absxk = ldexp(1.0, exponent - 53);
}
} else {
absxk = rtNaN;
}
guard6 = FALSE;
guard7 = FALSE;
if (muDoubleScalarAbs(a_data[ialast] - a_data[b_ialast]) < absxk) {
guard7 = TRUE;
} else if (muDoubleScalarIsInf(a_data[b_ialast])) {
if (muDoubleScalarIsInf(a_data[ialast]) && ((a_data[b_ialast] > 0.0) ==
(a_data[ialast] > 0.0))) {
guard7 = TRUE;
} else {
guard6 = TRUE;
}
} else {
guard6 = TRUE;
}
if (guard7 == TRUE) {
p = TRUE;
}
if (guard6 == TRUE) {
p = FALSE;
}
if (p) {
b_ialast++;
} else {
exitg2 = TRUE;
}
}
ialast = b_ialast - 1;
st.site = &lp_emlrtRSI;
b_iblast = iblast + 1;
bk = b[iblast];
exitg1 = FALSE;
while ((exitg1 == FALSE) && (b_iblast < 8)) {
absxk = muDoubleScalarAbs(b[iblast] / 2.0);
if ((!muDoubleScalarIsInf(absxk)) && (!muDoubleScalarIsNaN(absxk))) {
if (absxk <= 2.2250738585072014E-308) {
absxk = 4.94065645841247E-324;
} else {
frexp(absxk, &b_exponent);
absxk = ldexp(1.0, b_exponent - 53);
}
} else {
absxk = rtNaN;
}
guard4 = FALSE;
guard5 = FALSE;
if (muDoubleScalarAbs(b[iblast] - b[b_iblast]) < absxk) {
guard5 = TRUE;
} else if (muDoubleScalarIsInf(b[b_iblast])) {
if (muDoubleScalarIsInf(b[iblast]) && ((b[b_iblast] > 0.0) == (b[iblast]
> 0.0))) {
guard5 = TRUE;
} else {
guard4 = TRUE;
}
} else {
guard4 = TRUE;
}
if (guard5 == TRUE) {
p = TRUE;
}
if (guard4 == TRUE) {
p = FALSE;
}
if (p) {
b_iblast++;
} else {
exitg1 = TRUE;
}
}
iblast = b_iblast - 1;
st.site = &mp_emlrtRSI;
absxk = muDoubleScalarAbs(bk / 2.0);
if ((!muDoubleScalarIsInf(absxk)) && (!muDoubleScalarIsNaN(absxk))) {
if (absxk <= 2.2250738585072014E-308) {
absxk = 4.94065645841247E-324;
} else {
frexp(absxk, &c_exponent);
absxk = ldexp(1.0, c_exponent - 53);
}
} else {
absxk = rtNaN;
}
guard2 = FALSE;
guard3 = FALSE;
if (muDoubleScalarAbs(bk - ak) < absxk) {
guard3 = TRUE;
} else if (muDoubleScalarIsInf(ak)) {
if (muDoubleScalarIsInf(bk) && ((ak > 0.0) == (bk > 0.0))) {
guard3 = TRUE;
} else {
guard2 = TRUE;
}
} else {
guard2 = TRUE;
}
if (guard3 == TRUE) {
p = TRUE;
}
if (guard2 == TRUE) {
p = FALSE;
}
if (p) {
st.site = &np_emlrtRSI;
nc++;
c_data[nc - 1] = ak;
ia_data[nc - 1] = iafirst + 1;
ib_data[nc - 1] = ibfirst + 1;
st.site = &op_emlrtRSI;
ialast = b_ialast;
iafirst = b_ialast;
st.site = &pp_emlrtRSI;
iblast = b_iblast;
ibfirst = b_iblast;
} else {
st.site = &qp_emlrtRSI;
guard1 = FALSE;
if (ak < bk) {
guard1 = TRUE;
} else if (muDoubleScalarIsNaN(bk)) {
guard1 = TRUE;
} else {
p = FALSE;
}
if (guard1 == TRUE) {
p = TRUE;
}
if (p) {
st.site = &rp_emlrtRSI;
ialast = b_ialast;
iafirst = b_ialast;
} else {
st.site = &sp_emlrtRSI;
iblast = b_iblast;
ibfirst = b_iblast;
}
}
}
if (ncmax > 0) {
if (nc <= ncmax) {
} else {
b_y = NULL;
m20 = mxCreateString("Assertion failed.");
emlrtAssign(&b_y, m20);
st.site = &yt_emlrtRSI;
b_error(&st, b_y, &y_emlrtMCI);
}
if (1 > nc) {
ialast = 0;
} else {
ialast = nc;
}
for (iafirst = 0; iafirst < ialast; iafirst++) {
b_ia_data[iafirst] = ia_data[iafirst];
}
ia_size[0] = ialast;
for (iafirst = 0; iafirst < ialast; iafirst++) {
ia_data[iafirst] = b_ia_data[iafirst];
}
}
if (ncmax > 0) {
if (nc <= ncmax) {
} else {
c_y = NULL;
m20 = mxCreateString("Assertion failed.");
emlrtAssign(&c_y, m20);
st.site = &xt_emlrtRSI;
b_error(&st, c_y, &ab_emlrtMCI);
}
if (1 > nc) {
ialast = 0;
} else {
ialast = nc;
}
for (iafirst = 0; iafirst < ialast; iafirst++) {
b_ia_data[iafirst] = ib_data[iafirst];
}
ib_size[0] = ialast;
for (iafirst = 0; iafirst < ialast; iafirst++) {
ib_data[iafirst] = b_ia_data[iafirst];
}
}
if (ncmax > 0) {
if (nc <= ncmax) {
} else {
d_y = NULL;
m20 = mxCreateString("Assertion failed.");
emlrtAssign(&d_y, m20);
st.site = &wt_emlrtRSI;
b_error(&st, d_y, &bb_emlrtMCI);
}
if (1 > nc) {
ialast = 0;
} else {
ialast = nc;
}
for (iafirst = 0; iafirst < ialast; iafirst++) {
b_c_data[iafirst] = c_data[iafirst];
}
c_size[0] = ialast;
for (iafirst = 0; iafirst < ialast; iafirst++) {
c_data[iafirst] = b_c_data[iafirst];
}
}
}
/* Function Definitions */
void mldivide(const emlrtStack *sp, const real_T A[16], real_T B[4])
{
real_T b_A[16];
int8_T ipiv[4];
int32_T kAcol;
int32_T info;
int32_T j;
int32_T c;
int32_T ix;
real_T temp;
int32_T k;
real_T s;
int32_T b;
int32_T jy;
boolean_T b_kAcol;
int32_T ijA;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
emlrtStack e_st;
emlrtStack f_st;
emlrtStack g_st;
emlrtStack h_st;
emlrtStack i_st;
emlrtStack j_st;
emlrtStack k_st;
emlrtStack l_st;
st.prev = sp;
st.tls = sp->tls;
st.site = &g_emlrtRSI;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &c_st;
d_st.tls = c_st.tls;
e_st.prev = &d_st;
e_st.tls = d_st.tls;
f_st.prev = &e_st;
f_st.tls = e_st.tls;
g_st.prev = &f_st;
g_st.tls = f_st.tls;
h_st.prev = &g_st;
h_st.tls = g_st.tls;
i_st.prev = &h_st;
i_st.tls = h_st.tls;
j_st.prev = &i_st;
j_st.tls = i_st.tls;
k_st.prev = &j_st;
k_st.tls = j_st.tls;
l_st.prev = &k_st;
l_st.tls = k_st.tls;
b_st.site = &h_emlrtRSI;
c_st.site = &j_emlrtRSI;
d_st.site = &k_emlrtRSI;
e_st.site = &l_emlrtRSI;
memcpy(&b_A[0], &A[0], sizeof(real_T) << 4);
for (kAcol = 0; kAcol < 4; kAcol++) {
ipiv[kAcol] = (int8_T)(1 + kAcol);
}
info = 0;
for (j = 0; j < 3; j++) {
c = j * 5;
f_st.site = &m_emlrtRSI;
g_st.site = &p_emlrtRSI;
h_st.site = &q_emlrtRSI;
kAcol = 0;
ix = c;
temp = muDoubleScalarAbs(b_A[c]);
i_st.site = &r_emlrtRSI;
for (k = 2; k <= 4 - j; k++) {
ix++;
s = muDoubleScalarAbs(b_A[ix]);
if (s > temp) {
kAcol = k - 1;
temp = s;
}
}
if (b_A[c + kAcol] != 0.0) {
if (kAcol != 0) {
ipiv[j] = (int8_T)((j + kAcol) + 1);
ix = j;
kAcol += j;
for (k = 0; k < 4; k++) {
temp = b_A[ix];
b_A[ix] = b_A[kAcol];
b_A[kAcol] = temp;
ix += 4;
kAcol += 4;
}
}
b = (c - j) + 4;
f_st.site = &n_emlrtRSI;
for (jy = c + 1; jy + 1 <= b; jy++) {
b_A[jy] /= b_A[c];
}
} else {
info = j + 1;
}
f_st.site = &o_emlrtRSI;
g_st.site = &t_emlrtRSI;
h_st.site = &u_emlrtRSI;
i_st.site = &v_emlrtRSI;
j_st.site = &w_emlrtRSI;
kAcol = c;
jy = c + 4;
for (k = 1; k <= 3 - j; k++) {
temp = b_A[jy];
if (b_A[jy] != 0.0) {
ix = c + 1;
b = (kAcol - j) + 8;
k_st.site = &x_emlrtRSI;
if (kAcol + 6 > b) {
b_kAcol = false;
} else {
b_kAcol = (b > 2147483646);
}
if (b_kAcol) {
l_st.site = &s_emlrtRSI;
check_forloop_overflow_error(&l_st);
}
for (ijA = kAcol + 5; ijA + 1 <= b; ijA++) {
b_A[ijA] += b_A[ix] * -temp;
ix++;
}
}
jy += 4;
kAcol += 4;
}
}
if ((info == 0) && (!(b_A[15] != 0.0))) {
info = 4;
}
if (info > 0) {
c_st.site = &i_emlrtRSI;
d_st.site = &y_emlrtRSI;
eml_warning(&d_st);
}
for (kAcol = 0; kAcol < 3; kAcol++) {
if (ipiv[kAcol] != kAcol + 1) {
temp = B[kAcol];
B[kAcol] = B[ipiv[kAcol] - 1];
B[ipiv[kAcol] - 1] = temp;
}
}
for (k = 0; k < 4; k++) {
kAcol = k << 2;
if (B[k] != 0.0) {
for (jy = k + 1; jy + 1 < 5; jy++) {
B[jy] -= B[k] * b_A[jy + kAcol];
}
}
}
for (k = 3; k > -1; k += -1) {
kAcol = k << 2;
if (B[k] != 0.0) {
B[k] /= b_A[k + kAcol];
for (jy = 0; jy + 1 <= k; jy++) {
B[jy] -= B[k] * b_A[jy + kAcol];
}
}
}
}
/* Function Definitions */
void xgetrf(const emlrtStack *sp, real_T A[16], int32_T ipiv[4])
{
int32_T iy;
int32_T j;
int32_T c;
int32_T ix;
real_T smax;
int32_T jy;
real_T s;
int32_T b;
int32_T b_j;
boolean_T b_iy;
int32_T ijA;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
emlrtStack e_st;
emlrtStack f_st;
emlrtStack g_st;
st.prev = sp;
st.tls = sp->tls;
st.site = &v_emlrtRSI;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &c_st;
d_st.tls = c_st.tls;
e_st.prev = &d_st;
e_st.tls = d_st.tls;
f_st.prev = &e_st;
f_st.tls = e_st.tls;
g_st.prev = &f_st;
g_st.tls = f_st.tls;
for (iy = 0; iy < 4; iy++) {
ipiv[iy] = 1 + iy;
}
for (j = 0; j < 3; j++) {
c = j * 5;
b_st.site = &w_emlrtRSI;
c_st.site = &ab_emlrtRSI;
iy = 0;
ix = c;
smax = muDoubleScalarAbs(A[c]);
d_st.site = &bb_emlrtRSI;
for (jy = 2; jy <= 4 - j; jy++) {
ix++;
s = muDoubleScalarAbs(A[ix]);
if (s > smax) {
iy = jy - 1;
smax = s;
}
}
if (A[c + iy] != 0.0) {
if (iy != 0) {
ipiv[j] = (j + iy) + 1;
ix = j;
iy += j;
for (jy = 0; jy < 4; jy++) {
smax = A[ix];
A[ix] = A[iy];
A[iy] = smax;
ix += 4;
iy += 4;
}
}
b = (c - j) + 4;
b_st.site = &x_emlrtRSI;
for (iy = c + 1; iy + 1 <= b; iy++) {
A[iy] /= A[c];
}
}
b_st.site = &y_emlrtRSI;
c_st.site = &db_emlrtRSI;
d_st.site = &eb_emlrtRSI;
e_st.site = &fb_emlrtRSI;
iy = c;
jy = c + 4;
f_st.site = &gb_emlrtRSI;
for (b_j = 1; b_j <= 3 - j; b_j++) {
smax = A[jy];
if (A[jy] != 0.0) {
ix = c + 1;
b = (iy - j) + 8;
f_st.site = &hb_emlrtRSI;
if (iy + 6 > b) {
b_iy = false;
} else {
b_iy = (b > 2147483646);
}
if (b_iy) {
g_st.site = &cb_emlrtRSI;
check_forloop_overflow_error(&g_st, true);
}
for (ijA = iy + 5; ijA + 1 <= b; ijA++) {
A[ijA] += A[ix] * -smax;
ix++;
}
}
jy += 4;
iy += 4;
}
}
}
/* Function Definitions */
static boolean_T b_MACLayerTransmitter(testMACTransmitterStackData *SD, const
emlrtStack *sp, comm_AGC *ObjAGC, comm_SDRuReceiver *ObjSDRuReceiver,
comm_SDRuTransmitter *ObjSDRuTransmitter, commcodegen_CRCDetector *ObjDetect,
OFDMDemodulator_1 *ObjPreambleDemod, OFDMDemodulator_1 *ObjDataDemod, const
c_struct_T *estimate, const e_struct_T *tx, const real_T messageBits_data[563],
char_T previousMessage_data[77], int32_T previousMessage_size[2])
{
boolean_T msgStatus;
int32_T tries;
int32_T state;
real_T decisions[10];
real_T destNodeID;
int16_T i36;
comm_SDRuTransmitter *obj;
boolean_T flag;
boolean_T exitg1;
comm_AGC *b_ObjAGC;
comm_SDRuReceiver *b_ObjSDRuReceiver;
commcodegen_CRCDetector *b_ObjDetect;
OFDMDemodulator_1 *b_ObjPreambleDemod;
OFDMDemodulator_1 *b_ObjDataDemod;
int32_T originNodeID;
real_T timeouts;
int32_T Response_size[2];
int32_T exitg10;
boolean_T guard1 = FALSE;
static const char_T b[7] = { 'T', 'i', 'm', 'e', 'o', 'u', 't' };
char_T Response_data[80];
int32_T messageBits_size[2];
real_T b_messageBits_data[563];
int8_T sza[2];
int32_T exitg16;
int32_T exitg15;
static const char_T cv343[7] = { 'T', 'i', 'm', 'e', 'o', 'u', 't' };
int32_T exitg14;
int32_T exitg13;
static const char_T cv344[9] = { 'C', 'R', 'C', ' ', 'E', 'r', 'r', 'o', 'r' };
int8_T szb[2];
int32_T exitg12;
int32_T exitg11;
int32_T loop_ub;
static const char_T b_b[9] = { 'D', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e' };
char_T b_Response_data[80];
int32_T exitg9;
int32_T exitg8;
boolean_T b_guard1 = FALSE;
int32_T exitg7;
int32_T exitg6;
static const char_T cv345[9] = { 'D', 'u', 'p', 'l', 'i', 'c', 'a', 't', 'e' };
int32_T exitg5;
int32_T exitg4;
int32_T exitg3;
int32_T exitg2;
static const char_T cv346[3] = { 'A', 'C', 'K' };
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
/* %Objects */
/* %Structs */
/* %Values/Vectors */
/* % This function is called when the node wants to transmit something */
/* % Sense spectrum and wait until it is unoccupied */
for (tries = 0; tries < 4; tries++) {
/* try only so many times */
for (state = 0; state < 10; state++) {
st.site = &xl_emlrtRSI;
SpectrumSenseP25(SD, &st, ObjAGC, ObjSDRuReceiver, decisions);
destNodeID = muDoubleScalarRound(decisions[state]);
if (destNodeID < 32768.0) {
if (destNodeID >= -32768.0) {
i36 = (int16_T)destNodeID;
} else {
i36 = MIN_int16_T;
}
} else if (destNodeID >= 32768.0) {
i36 = MAX_int16_T;
} else {
i36 = 0;
}
st.site = &yl_emlrtRSI;
d_fprintf(&st, (int16_T)(1 + state), i36);
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* if occupied */
/* fprintf('MAC| Spectrum occupied, listening...\n'); */
/* %Recover signal and/or wait */
/* lookingForACK = false; */
/* %MACLayerReceiver(PHY,lookingForACK); */
/* else% Yay we can transmit now */
/* break; */
/* end */
/* if tries >=4 */
/* fprintf('MAC| Spectrum Busy, try again later\n'); */
/* return; */
/* end */
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
msgStatus = FALSE;
/* Adjust offset for node */
st.site = &am_emlrtRSI;
f_fprintf(&st, 1, tx->offsetTable[0]);
st.site = &bm_emlrtRSI;
obj = ObjSDRuTransmitter;
b_st.site = &gb_emlrtRSI;
obj->CenterFrequency = 2.24E+9 + tx->offsetTable[0];
c_st.site = &ck_emlrtRSI;
b_st.site = &gb_emlrtRSI;
if (obj->isInitialized && (!obj->isReleased)) {
flag = TRUE;
} else {
flag = FALSE;
}
if (flag) {
obj->TunablePropsChanged = TRUE;
obj->tunablePropertyChanged[1] = TRUE;
}
/* % Spectrum clear, send message */
tries = 0;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (tries < 4)) {
/* Send message */
/* %originator */
/* %destination */
st.site = &cm_emlrtRSI;
PHYTransmit(SD, &st, ObjSDRuTransmitter, ObjSDRuReceiver, tx->nodeNum);
/* Listen for acknowledgement */
/* fprintf('###########################################\n'); */
st.site = &dm_emlrtRSI;
h_fprintf(&st);
/* Call Receiver */
/* %Objects */
/* %Structs */
/* %Values/Vectors */
st.site = &em_emlrtRSI;
b_ObjAGC = ObjAGC;
b_ObjSDRuReceiver = ObjSDRuReceiver;
obj = ObjSDRuTransmitter;
b_ObjDetect = ObjDetect;
b_ObjPreambleDemod = ObjPreambleDemod;
b_ObjDataDemod = ObjDataDemod;
/* %Objects */
/* %Structs */
/* %Values/Vectors */
/* This function is called when the node is just listening to the spectrum */
/* waiting for a message to be transmitted to them */
/* % Listen to the spectrum */
/* previousMessage will be updated for next run */
/* %Objects */
/* %Structs */
/* %Values/Vectors */
b_st.site = &rt_emlrtRSI;
/* %Objects */
/* %Structs */
/* %Values/Vectors */
/* Initialize values */
originNodeID = -1;
destNodeID = -1.0;
/* 0 = Call PHY Receiver */
/* 1 = Timeout */
/* 2 = Corrupt Message */
/* 3 = Message Reception Successfull */
/* Duplicates are checked at the last stage */
state = 0;
/* Initial state */
timeouts = 0.0;
/* Counter */
/* Message string holder */
emlrtDimSizeGeqCheckFastR2012b(80, 0, &y_emlrtECI, &b_st);
Response_size[0] = 1;
Response_size[1] = 0;
/* Run system */
do {
exitg10 = 0;
/* %% Process Messages */
guard1 = FALSE;
switch (state) {
case 0:
/* Wait for message */
if (timeouts > 10.0) {
emlrtDimSizeGeqCheckFastR2012b(80, 7, &db_emlrtECI, &b_st);
Response_size[0] = 1;
Response_size[1] = 7;
for (state = 0; state < 7; state++) {
Response_data[state] = b[state];
}
exitg10 = 1;
} else {
/* Call Physical Layer */
/* %Objects */
/* %Structs */
/* %Values/Vectors */
SD->f15.estimate = *estimate;
messageBits_size[0] = 1;
messageBits_size[1] = 563;
memcpy(&b_messageBits_data[0], &messageBits_data[0], 563U * sizeof
(real_T));
c_st.site = &eu_emlrtRSI;
PHYReceive(SD, &c_st, b_ObjAGC, b_ObjSDRuReceiver, b_ObjDetect,
b_ObjPreambleDemod, b_ObjDataDemod, &SD->f15.estimate,
tx->shortPreambleOFDM, tx->longPreamble, tx->pilots,
tx->pilotLocationsWithoutGuardbands,
tx->dataSubcarrierIndexies.data,
tx->dataSubcarrierIndexies.size, b_messageBits_data,
messageBits_size, Response_data, Response_size);
/* Choose next state */
c_st.site = &fu_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg16 = 0;
if (state < 2) {
if (sza[state] != 1 + 6 * state) {
exitg16 = 1;
} else {
state++;
}
} else {
state = 0;
exitg16 = 2;
}
} while (exitg16 == 0);
if (exitg16 == 1) {
} else {
do {
exitg15 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv343[state]) {
exitg15 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg15 = 1;
}
} while (exitg15 == 0);
}
if (flag) {
state = 1;
} else {
c_st.site = &gu_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg14 = 0;
if (state < 2) {
if (sza[state] != 1 + (state << 3)) {
exitg14 = 1;
} else {
state++;
}
} else {
state = 0;
exitg14 = 2;
}
} while (exitg14 == 0);
if (exitg14 == 1) {
} else {
do {
exitg13 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv344[state]) {
exitg13 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg13 = 1;
}
} while (exitg13 == 0);
}
if (flag || (Response_size[1] == 0)) {
state = 2;
} else {
/* Successfully decoded */
state = 3;
}
}
/* Timeout occured */
guard1 = TRUE;
}
break;
case 1:
timeouts++;
if (timeouts > 10.0) {
/* if DebugFlag;fprintf('DL| Max timeouts reached\n');end */
c_st.site = &du_emlrtRSI;
l_fprintf(&c_st);
emlrtDimSizeGeqCheckFastR2012b(80, 7, &cb_emlrtECI, &b_st);
Response_size[0] = 1;
Response_size[1] = 7;
for (state = 0; state < 7; state++) {
Response_data[state] = b[state];
}
exitg10 = 1;
} else {
state = 0;
/* Get another message */
/* Message corrupted */
guard1 = TRUE;
}
break;
case 2:
timeouts += 0.01;
state = 0;
/* Get another message */
/* Default: Message successfully received */
guard1 = TRUE;
break;
case 3:
/* otherwise */
/* disp(['DL| MSG: ',Response]) */
/* disp(['DL| Timeouts: ',num2str(timeouts)]) */
/* Final Duplication check */
c_st.site = &bu_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)previousMessage_size[state];
}
for (state = 0; state < 2; state++) {
szb[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg12 = 0;
if (state < 2) {
if (sza[state] != szb[state]) {
exitg12 = 1;
} else {
state++;
}
} else {
state = 0;
exitg12 = 2;
}
} while (exitg12 == 0);
if (exitg12 == 1) {
} else {
do {
exitg11 = 0;
if (state <= previousMessage_size[1] - 1) {
if (previousMessage_data[state] != Response_data[state]) {
exitg11 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg11 = 1;
}
} while (exitg11 == 0);
}
if (flag) {
/* Dupe */
/* if DebugFlag;fprintf('DL| Duplicate Message\n');end */
c_st.site = &cu_emlrtRSI;
j_fprintf(&c_st);
previousMessage_size[0] = 1;
previousMessage_size[1] = Response_size[1];
loop_ub = Response_size[1];
for (state = 0; state < loop_ub; state++) {
previousMessage_data[previousMessage_size[0] * state] =
Response_data[Response_size[0] * state];
}
/* Update history for next iteration */
state = Response_size[1] - 2;
originNodeID = (uint8_T)
Response_data[emlrtDynamicBoundsCheckFastR2012b(state, 1,
Response_size[1], &wb_emlrtBCI, &b_st) - 1] - 48;
/* extract node ID and convert char to number */
state = Response_size[1] - 1;
destNodeID = (real_T)(uint8_T)
Response_data[emlrtDynamicBoundsCheckFastR2012b(state, 1,
Response_size[1], &xb_emlrtBCI, &b_st) - 1] - 48.0;
/* extract node ID and convert char to number */
emlrtDimSizeGeqCheckFastR2012b(80, 9, &ab_emlrtECI, &b_st);
Response_size[0] = 1;
Response_size[1] = 9;
for (state = 0; state < 9; state++) {
Response_data[state] = b_b[state];
}
/* Tell upper layers duplicate */
} else {
/* No Dupe */
previousMessage_size[0] = 1;
previousMessage_size[1] = Response_size[1];
loop_ub = Response_size[1];
for (state = 0; state < loop_ub; state++) {
previousMessage_data[previousMessage_size[0] * state] =
Response_data[Response_size[0] * state];
}
/* Update history for next iteration */
state = Response_size[1] - 2;
originNodeID = (uint8_T)
Response_data[emlrtDynamicBoundsCheckFastR2012b(state, 1,
Response_size[1], &ub_emlrtBCI, &b_st) - 1] - 48;
/* extract node ID and convert char to number */
state = Response_size[1] - 1;
destNodeID = (real_T)(uint8_T)
Response_data[emlrtDynamicBoundsCheckFastR2012b(state, 1,
Response_size[1], &vb_emlrtBCI, &b_st) - 1] - 48.0;
/* extract node ID and convert char to number */
if (1 > Response_size[1] - 3) {
loop_ub = 0;
} else {
emlrtDynamicBoundsCheckFastR2012b(1, 1, Response_size[1],
&tb_emlrtBCI, &b_st);
state = Response_size[1] - 3;
loop_ub = emlrtDynamicBoundsCheckFastR2012b(state, 1, Response_size
[1], &tb_emlrtBCI, &b_st);
}
emlrtDimSizeGeqCheckFastR2012b(80, loop_ub, &bb_emlrtECI, &b_st);
for (state = 0; state < loop_ub; state++) {
b_Response_data[state] = Response_data[state];
}
Response_size[0] = 1;
Response_size[1] = loop_ub;
for (state = 0; state < loop_ub; state++) {
Response_data[state] = b_Response_data[state];
}
/* Remove identifer key and nodeIDs */
}
exitg10 = 1;
break;
default:
guard1 = TRUE;
break;
}
if (guard1 == TRUE) {
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, &b_st);
}
} while (exitg10 == 0);
/* Final check */
c_st.site = &hu_emlrtRSI;
if (muDoubleScalarAbs(destNodeID) > 3.0) {
destNodeID = tx->nodeNum;
/* Something went wrong, probably corrupt message, reset to self */
}
/* % Possible response messages */
/* 1.) Timeout */
/* 2.) Some message */
b_st.site = &st_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg9 = 0;
if (state < 2) {
if (sza[state] != 1 + 6 * state) {
exitg9 = 1;
} else {
state++;
}
} else {
state = 0;
exitg9 = 2;
}
} while (exitg9 == 0);
if (exitg9 == 1) {
} else {
do {
exitg8 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv343[state]) {
exitg8 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg8 = 1;
}
} while (exitg8 == 0);
}
b_guard1 = FALSE;
if (!flag) {
b_st.site = &st_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg7 = 0;
if (state < 2) {
if (sza[state] != 1 + (state << 3)) {
exitg7 = 1;
} else {
state++;
}
} else {
state = 0;
exitg7 = 2;
}
} while (exitg7 == 0);
if (exitg7 == 1) {
} else {
do {
exitg6 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv345[state]) {
exitg6 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg6 = 1;
}
} while (exitg6 == 0);
}
if (!flag) {
/* fprintf('###########################################\n'); */
b_st.site = &tt_emlrtRSI;
n_fprintf(&b_st, Response_data, Response_size);
b_st.site = &ut_emlrtRSI;
p_fprintf(&b_st, (int16_T)originNodeID);
} else {
b_guard1 = TRUE;
}
} else {
b_guard1 = TRUE;
}
if (b_guard1 == TRUE) {
b_st.site = &vt_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg5 = 0;
if (state < 2) {
if (sza[state] != 1 + (state << 3)) {
exitg5 = 1;
} else {
state++;
}
} else {
state = 0;
exitg5 = 2;
}
} while (exitg5 == 0);
if (exitg5 == 1) {
} else {
do {
exitg4 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv345[state]) {
exitg4 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg4 = 1;
}
} while (exitg4 == 0);
}
if (flag) {
b_st.site = &wt_emlrtRSI;
r_fprintf(&b_st);
/* %% Send ACK */
b_st.site = &xt_emlrtRSI;
f_fprintf(&b_st, (int16_T)originNodeID, tx->
offsetTable[emlrtDynamicBoundsCheckFastR2012b(originNodeID, 1,
3, &yb_emlrtBCI, &st) - 1]);
b_st.site = &yt_emlrtRSI;
c_st.site = &gb_emlrtRSI;
obj->CenterFrequency = 2.24E+9 + tx->offsetTable[originNodeID - 1];
c_st.site = &gb_emlrtRSI;
if (obj->isInitialized && (!obj->isReleased)) {
flag = TRUE;
} else {
flag = FALSE;
}
if (flag) {
obj->TunablePropsChanged = TRUE;
obj->tunablePropertyChanged[1] = TRUE;
}
/* Adjust offset for node */
b_st.site = &au_emlrtRSI;
b_PHYTransmit(SD, &b_st, obj, b_ObjSDRuReceiver, originNodeID,
destNodeID);
}
}
st.site = &fm_emlrtRSI;
flag = FALSE;
for (state = 0; state < 2; state++) {
sza[state] = (int8_T)Response_size[state];
}
state = 0;
do {
exitg3 = 0;
if (state < 2) {
if (sza[state] != 1 + (state << 1)) {
exitg3 = 1;
} else {
state++;
}
} else {
state = 0;
exitg3 = 2;
}
} while (exitg3 == 0);
if (exitg3 == 1) {
} else {
do {
exitg2 = 0;
if (state <= Response_size[1] - 1) {
if (Response_data[state] != cv346[state]) {
exitg2 = 1;
} else {
state++;
}
} else {
flag = TRUE;
exitg2 = 1;
}
} while (exitg2 == 0);
}
if (flag) {
st.site = &gm_emlrtRSI;
t_fprintf(&st);
msgStatus = TRUE;
exitg1 = TRUE;
} else {
st.site = &hm_emlrtRSI;
v_fprintf(&st);
if (tries + 1 >= 4) {
st.site = &im_emlrtRSI;
x_fprintf(&st);
st.site = &jm_emlrtRSI;
ab_fprintf(&st);
st.site = &km_emlrtRSI;
x_fprintf(&st);
exitg1 = TRUE;
} else {
tries++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
}
}
return msgStatus;
}
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);
}
/* Function Definitions */
real_T Bcoeff(const emlrtStack *sp, real_T ksi, real_T j, real_T x, real_T t,
const emxArray_real_T *gridT)
{
real_T vals;
int32_T k;
int32_T i1;
boolean_T b_x[3];
boolean_T y;
boolean_T exitg2;
boolean_T exitg1;
real_T c_x;
real_T d_x;
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
/* evaluate the coefficient B at the boundary ksi=0 or ksi=1; */
/* for the index j which describes the time steps timePoints_j, at time t and space */
/* point x */
/* timePoints is a vector describing the time descritized domain */
k = gridT->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(j, &b_emlrtDCI, sp);
if (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k, &n_emlrtBCI,
sp) - 1]) {
vals = 0.0;
} else {
k = gridT->size[1];
i1 = (int32_T)j;
b_x[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k,
&o_emlrtBCI, sp) - 1]);
k = gridT->size[1];
i1 = (int32_T)((uint32_T)j + 1U);
b_x[1] = (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k,
&p_emlrtBCI, sp) - 1]);
b_x[2] = (x == ksi);
y = true;
k = 0;
exitg2 = false;
while ((!exitg2) && (k < 3)) {
if (b_x[k] == 0) {
y = false;
exitg2 = true;
} else {
k++;
}
}
if (y) {
vals = 0.0;
} else {
k = gridT->size[1];
i1 = (int32_T)j;
b_x[0] = (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k,
&q_emlrtBCI, sp) - 1]);
k = gridT->size[1];
i1 = (int32_T)((uint32_T)j + 1U);
b_x[1] = (t <= gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k,
&r_emlrtBCI, sp) - 1]);
b_x[2] = (x != ksi);
y = true;
k = 0;
exitg1 = false;
while ((!exitg1) && (k < 3)) {
if (b_x[k] == 0) {
y = false;
exitg1 = true;
} else {
k++;
}
}
if (y) {
st.site = &g_emlrtRSI;
k = gridT->size[1];
i1 = (int32_T)j;
c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k,
&v_emlrtBCI, &st) - 1];
if (c_x < 0.0) {
b_st.site = &f_emlrtRSI;
eml_error(&b_st);
}
vals = -scalar_erf(muDoubleScalarAbs(x - ksi) / (2.0 *
muDoubleScalarSqrt(c_x))) / 2.0;
} else {
k = gridT->size[1];
i1 = (int32_T)((uint32_T)j + 1U);
if (t > gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k,
&s_emlrtBCI, sp) - 1]) {
st.site = &h_emlrtRSI;
k = gridT->size[1];
i1 = (int32_T)j;
c_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k,
&t_emlrtBCI, &st) - 1];
if (c_x < 0.0) {
b_st.site = &f_emlrtRSI;
eml_error(&b_st);
}
st.site = &i_emlrtRSI;
k = gridT->size[1];
i1 = (int32_T)((uint32_T)j + 1U);
d_x = t - gridT->data[emlrtDynamicBoundsCheckFastR2012b(i1, 1, k,
&u_emlrtBCI, &st) - 1];
if (d_x < 0.0) {
b_st.site = &f_emlrtRSI;
eml_error(&b_st);
}
vals = (b_scalar_erf(muDoubleScalarAbs(x - ksi) / (2.0 *
muDoubleScalarSqrt(c_x))) - b_scalar_erf(muDoubleScalarAbs(x
- ksi) / (2.0 * muDoubleScalarSqrt(d_x)))) / 2.0;
} else {
vals = 0.0;
}
}
}
}
return vals;
}
/* Function Definitions */
real_T batFrcClc_tmp(real_T batPwr, real_T vel, real_T batRstDch, real_T
batRstChr, real_T batOcv)
{
real_T batFrc;
real_T batRst;
real_T batFrcCpl_re;
real_T yr;
real_T yi;
real_T ar;
real_T ai;
real_T br;
real_T batFrcCpl_im;
/* Skalar - Batteriekraft (E') */
/* Skalar - Batterieklemmleistung */
/* Skalar - mittlere Geschwindigkeit im Intervall */
/* Skalar - Entladewiderstand */
/* Skalar - Ladewiderstand */
/* Skalar - battery open-circuit voltage */
/* BATFRCCLC Calculating losses in battery */
/* Batteriekraft (E') aus Verlusten in der Batterie berechnen */
/* Calucluate battery power losses (E') */
/* */
/* Version vom 25.05.2016: Zero-Order-Hold (keine mittlere Geschwindigkeit) */
/* Zero-Order-Hold (average velocity is NOT used) */
/* % Initialisieren der Ausgabe der Funktion */
/* initializing the function output */
batFrc = rtInf;
/* % Berechnung der Verluste in der Batterie */
/* calculating battery losses */
/* Berechnung der Batterieenergienderung im Wegschritt in externer Funktion */
/* Fallunterscheidung, ob Batterie geladen oder entladen wird */
/* */
/* calculate the change in battery energy along path_idx in exterior func, */
/* distinguished whether battery is charging or discharging. */
/* Assining battery resistance value */
if (batPwr > 0.0) {
batRst = batRstDch;
} else {
batRst = batRstChr;
}
/* Batterieenergieänderung über dem Weg berechnen. Herleitung der Formel */
/* kann zum Beispiel dem Paper mit Chalmers entnommen werden */
/* calculate battery power charge for path_idx. Formula derivation can be */
/* found from other papers (for example, Chalmers paper) */
batFrcCpl_re = 1.0 - 4.0 * batRst / (batOcv * batOcv) * batPwr;
if (batFrcCpl_re < 0.0) {
yr = 0.0;
yi = muDoubleScalarSqrt(muDoubleScalarAbs(batFrcCpl_re));
} else {
yr = muDoubleScalarSqrt(batFrcCpl_re);
yi = 0.0;
}
ar = batOcv * batOcv * (yr - 1.0);
ai = batOcv * batOcv * yi;
br = 2.0 * batRst * vel;
if (ai == 0.0) {
batFrcCpl_re = ar / br;
batFrcCpl_im = 0.0;
} else if (ar == 0.0) {
batFrcCpl_re = 0.0;
batFrcCpl_im = ai / br;
} else {
batFrcCpl_re = ar / br;
batFrcCpl_im = ai / br;
}
/* Sollte die physikalisch mögliche Batterieleistung überschritten werden, */
/* wird der Term unter der Wurzel negativ. In diesem Fall wird die Ausgabe */
/* ungültig geschrieben. */
/* check to make sure that the battery capacity is not exceeded (when the */
/* root becomes negative, the output is no longer valid) (Quadrants 3, 4) */
if (batFrcCpl_im != 0.0) {
} else {
batFrc = batFrcCpl_re;
}
return batFrc;
}
/* 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);
}
static void sf_c3_controller1(SFc3_controller1InstanceStruct *chartInstance)
{
int32_T c3_previousEvent;
real_T c3_hoistedGlobal;
real_T c3_u;
uint32_T c3_debug_family_var_map[5];
real_T c3_T;
real_T c3_nargin = 1.0;
real_T c3_nargout = 1.0;
real_T c3_y;
real_T c3_x;
real_T c3_b_x;
real_T c3_b_y;
real_T c3_c_x;
real_T c3_d_x;
real_T c3_c_y;
real_T c3_b;
real_T c3_d_y;
real_T c3_A;
real_T c3_B;
real_T c3_e_x;
real_T c3_e_y;
real_T c3_f_x;
real_T c3_f_y;
real_T c3_g_x;
real_T c3_g_y;
real_T *c3_b_u;
real_T *c3_h_y;
c3_h_y = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c3_b_u = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 2);
_SFD_DATA_RANGE_CHECK(*c3_b_u, 0U);
_SFD_DATA_RANGE_CHECK(*c3_h_y, 1U);
c3_previousEvent = _sfEvent_;
_sfEvent_ = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 2);
c3_hoistedGlobal = *c3_b_u;
c3_u = c3_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 5U, 5U, c3_debug_family_names,
c3_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c3_T, c3_sf_marshall, 0U);
sf_debug_symbol_scope_add_eml(&c3_nargin, c3_sf_marshall, 1U);
sf_debug_symbol_scope_add_eml(&c3_nargout, c3_sf_marshall, 2U);
sf_debug_symbol_scope_add_eml(&c3_u, c3_sf_marshall, 3U);
sf_debug_symbol_scope_add_eml(&c3_y, c3_sf_marshall, 4U);
CV_EML_FCN(0, 0);
/* hard limit cutoff function. */
_SFD_EML_CALL(0, 4);
c3_T = 100.0;
_SFD_EML_CALL(0, 5);
c3_x = c3_u;
c3_b_x = c3_x;
c3_b_y = muDoubleScalarAbs(c3_b_x);
if (CV_EML_IF(0, 0, c3_b_y > c3_T)) {
_SFD_EML_CALL(0, 6);
c3_c_x = c3_u;
c3_d_x = c3_c_x;
c3_c_y = muDoubleScalarAbs(c3_d_x);
c3_b = c3_c_y;
c3_d_y = 100.0 * c3_b;
c3_A = c3_d_y;
c3_B = c3_u;
c3_e_x = c3_A;
c3_e_y = c3_B;
c3_f_x = c3_e_x;
c3_f_y = c3_e_y;
c3_g_x = c3_f_x;
c3_g_y = c3_f_y;
c3_u = c3_g_x / c3_g_y;
}
_SFD_EML_CALL(0, 8);
c3_y = c3_u;
_SFD_EML_CALL(0, -8);
sf_debug_symbol_scope_pop();
*c3_h_y = c3_y;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 2);
_sfEvent_ = c3_previousEvent;
sf_debug_check_for_state_inconsistency(_controller1MachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
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;
}
/* 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);
}
}
/* Function Definitions */
void generateOFDMSignal(const emlrtStack *sp, OFDMDemodulator_1 *iobj_0,
OFDMDemodulator_1 *iobj_1, OFDMDemodulator_1 **hPreambleDemod,
OFDMDemodulator_1 **hDataDemod, creal_T r[25600], d_struct_T *tx)
{
OFDMModulator_1 hDataMod;
OFDMModulator hPreambleMod;
creal_T shortPreambleOFDM[64];
int32_T i;
creal_T completeShortPreambleOFDM[160];
creal_T longPreambleOFDM[64];
creal_T completeLongPreambleOFDM[160];
real_T originalData[560];
real_T x[560];
int32_T ib;
real_T b_originalData[560];
commcodegen_CRCGenerator_6 hGen;
real_T dataWithCRC[563];
commcodegen_BPSKModulator_1 hMod;
creal_T modData[563];
real_T varargin_1[13];
int32_T k;
commcodegen_BPSKModulator_1 *obj;
const mxArray *y;
static const int32_T iv54[2] = { 1, 45 };
const mxArray *m10;
char_T cv58[45];
static const char_T cv59[45] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y',
's', 't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l',
'e', 'd', 'W', 'h', 'e', 'n', 'R', 'e', 'l', 'e', 'a', 's', 'e', 'd', 'C',
'o', 'd', 'e', 'g', 'e', 'n' };
const mxArray *b_y;
static const int32_T iv55[2] = { 1, 4 };
char_T cv60[4];
static const char_T cv61[4] = { 's', 't', 'e', 'p' };
const mxArray *c_y;
static const int32_T iv56[2] = { 1, 51 };
char_T cv62[51];
static const char_T cv63[51] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 's', 'y',
's', 't', 'e', 'm', ':', 'm', 'e', 't', 'h', 'o', 'd', 'C', 'a', 'l', 'l',
'e', 'd', 'W', 'h', 'e', 'n', 'L', 'o', 'c', 'k', 'e', 'd', 'R', 'e', 'l',
'e', 'a', 's', 'e', 'd', 'C', 'o', 'd', 'e', 'g', 'e', 'n' };
const mxArray *d_y;
static const int32_T iv57[2] = { 1, 5 };
char_T cv64[5];
static const char_T cv65[5] = { 's', 'e', 't', 'u', 'p' };
static const int8_T value[8] = { 13, 1, 1, 1, 1, 1, 1, 1 };
boolean_T anyInputSizeChanged;
boolean_T exitg2;
static const int8_T iv58[8] = { 13, 1, 1, 1, 1, 1, 1, 1 };
creal_T varargout_1[13];
creal_T b_modData[576];
creal_T ofdmData[576];
comm_PNSequence_5 hPN;
comm_PNSequence_5 *b_obj;
static const int8_T iv59[8] = { 1, 0, 0, 0, 1, 0, 0, 1 };
static const int8_T iv60[7] = { 0, 0, 0, 0, 0, 0, 1 };
int8_T pilot[12];
uint8_T tmp;
uint8_T tmp2;
int8_T pilots[48];
int32_T ia;
real_T b_pilots[48];
creal_T b_r[960];
creal_T preambles[320];
creal_T c_r[1280];
OFDMDemodulator_1 *object;
int8_T b_data[4];
int32_T exitg1;
int32_T exponent;
boolean_T b2;
int32_T i12;
const mxArray *e_y;
static const int32_T iv61[2] = { 1, 13 };
char_T cv66[13];
static const char_T cv67[13] = { 'c', 'o', 'm', 'm', ':', 'O', 'F', 'D', 'M',
':', 'x', 'x', 'x' };
static const creal_T dcv3[53] = { { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, {
0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { -1.0, -1.0 }, { 0.0, 0.0 }, {
0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0,
0.0 }, { -1.0, -1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { -1.0,
-1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.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 }, { -1.0, -1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { -
1.0, -1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0,
0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0
}, { 0.0, 0.0 }, { 1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, { 0.0, 0.0 }, {
1.0, 1.0 }, { 0.0, 0.0 }, { 0.0, 0.0 } };
static const int8_T iv62[53] = { 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1,
1, -1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 0, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1,
-1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1 };
static const int8_T iv63[48] = { 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 28, 29, 30, 31, 32, 33, 35, 36,
37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 49, 50, 51, 52, 53 };
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
emlrtStack e_st;
emlrtStack f_st;
emlrtStack g_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &c_st;
d_st.tls = c_st.tls;
e_st.prev = &d_st;
e_st.tls = d_st.tls;
f_st.prev = &e_st;
f_st.tls = e_st.tls;
g_st.prev = &f_st;
g_st.tls = f_st.tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
emxInitStruct_OFDMModulator_1(sp, &hDataMod, &s_emlrtRTEI, TRUE);
emxInitStruct_OFDMModulator(sp, &hPreambleMod, &t_emlrtRTEI, TRUE);
/* generateOFDMSignal: Generate OFDM signal based on the 802.11a standard. */
/* This function returns the time domain signal and a structure containing */
/* details about the signal itself. This information is required by the */
/* receiver to operate correctly. */
/* % System Parameters */
/* OFDM modulator FFT size */
/* Enable moving averages for estimates */
/* 1e3 */
/* Message to transmit */
/* String holder */
/* coder.varsize('payloadMessage', [1, 80], [0 1]); */
/* payloadMessage = ''; */
/* % Create Short Preamble */
/* % [-27:-17] */
/* % [-16:-1] */
/* % [0:15] */
/* [16:27] */
/* % Create modulator */
/* hPreambleMod = OFDMModulator(... */
/* 'NumGuardBandCarriers', [6; 5],... */
/* 'CyclicPrefixLength', 0,... */
/* 'FFTLength' , FFTLength,... */
/* 'NumSymbols', 1); */
/* Create modulator */
st.site = &lk_emlrtRSI;
OFDMModulator_OFDMModulator(&hPreambleMod);
/* Modulate and scale */
st.site = &mk_emlrtRSI;
SystemCore_step(&st, &hPreambleMod, shortPreambleOFDM);
st.site = &mk_emlrtRSI;
for (i = 0; i < 64; i++) {
shortPreambleOFDM[i].re *= 1.4719601443879744;
shortPreambleOFDM[i].im *= 1.4719601443879744;
}
/* Form 10 Short Preambles */
memcpy(&completeShortPreambleOFDM[0], &shortPreambleOFDM[0], sizeof(creal_T) <<
6);
memcpy(&completeShortPreambleOFDM[64], &shortPreambleOFDM[0], sizeof(creal_T) <<
6);
memcpy(&completeShortPreambleOFDM[128], &shortPreambleOFDM[0], sizeof(creal_T)
<< 5);
/* % Create Long Preamble */
/* Modulate */
st.site = &nk_emlrtRSI;
b_SystemCore_step(&st, &hPreambleMod, longPreambleOFDM);
/* Form 2 Long Preambles */
memcpy(&completeLongPreambleOFDM[0], &longPreambleOFDM[32], sizeof(creal_T) <<
5);
memcpy(&completeLongPreambleOFDM[32], &longPreambleOFDM[0], sizeof(creal_T) <<
6);
memcpy(&completeLongPreambleOFDM[96], &longPreambleOFDM[0], sizeof(creal_T) <<
6);
/* % Generate Data */
/* Use string as message */
st.site = &ok_emlrtRSI;
b_OFDMletters2bits(&st, originalData);
st.site = &pk_emlrtRSI;
for (i = 0; i < 80; i++) {
for (ib = 0; ib < 7; ib++) {
x[ib + 7 * i] = originalData[i + 80 * ib];
}
}
memcpy(&b_originalData[0], &x[0], 560U * sizeof(real_T));
/* Generate CRC */
st.site = &qk_emlrtRSI;
b_CRCGenerator_CRCGenerator(&hGen);
st.site = &rk_emlrtRSI;
e_SystemCore_step(&st, &hGen, b_originalData, dataWithCRC);
/* Add CRC */
/* Construct modulator for each subcarrier */
st.site = &sk_emlrtRSI;
BPSKModulator_BPSKModulator(&hMod);
/* BPSK */
/* Apply modulator for each subcarrier */
st.site = &tk_emlrtRSI;
f_SystemCore_step(&st, &hMod, dataWithCRC, modData);
/* Pad IFFT */
st.site = &uk_emlrtRSI;
b_st.site = &u_emlrtRSI;
emlrtRandu(varargin_1, 13);
for (k = 0; k < 13; k++) {
b_st.site = &v_emlrtRSI;
b_st.site = &v_emlrtRSI;
c_st.site = &p_emlrtRSI;
varargin_1[k] = muDoubleScalarFloor(varargin_1[k] * 2.0);
}
st.site = &uk_emlrtRSI;
obj = &hMod;
if (!obj->isReleased) {
} else {
y = NULL;
m10 = mxCreateCharArray(2, iv54);
for (i = 0; i < 45; i++) {
cv58[i] = cv59[i];
}
emlrtInitCharArrayR2013a(&st, 45, m10, cv58);
emlrtAssign(&y, m10);
b_y = NULL;
m10 = mxCreateCharArray(2, iv55);
for (i = 0; i < 4; i++) {
cv60[i] = cv61[i];
}
emlrtInitCharArrayR2013a(&st, 4, m10, cv60);
emlrtAssign(&b_y, m10);
b_st.site = &cb_emlrtRSI;
c_error(&b_st, message(&b_st, y, b_y, &emlrtMCI), &emlrtMCI);
}
if (!obj->isInitialized) {
b_st.site = &cb_emlrtRSI;
if (!obj->isInitialized) {
} else {
c_y = NULL;
m10 = mxCreateCharArray(2, iv56);
for (i = 0; i < 51; i++) {
cv62[i] = cv63[i];
}
emlrtInitCharArrayR2013a(&b_st, 51, m10, cv62);
emlrtAssign(&c_y, m10);
d_y = NULL;
m10 = mxCreateCharArray(2, iv57);
for (i = 0; i < 5; i++) {
cv64[i] = cv65[i];
}
emlrtInitCharArrayR2013a(&b_st, 5, m10, cv64);
emlrtAssign(&d_y, m10);
c_st.site = &cb_emlrtRSI;
c_error(&c_st, message(&c_st, c_y, d_y, &emlrtMCI), &emlrtMCI);
}
c_st.site = &cb_emlrtRSI;
obj->isInitialized = TRUE;
d_st.site = &db_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &cb_emlrtRSI;
e_st.site = &db_emlrtRSI;
d_st.site = &cb_emlrtRSI;
e_st.site = &db_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &cb_emlrtRSI;
d_st.site = &cb_emlrtRSI;
d_st.site = &cb_emlrtRSI;
e_st.site = &db_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &cb_emlrtRSI;
for (i = 0; i < 8; i++) {
obj->inputVarSize1[i] = (uint32_T)value[i];
}
e_st.site = &db_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &cb_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &cb_emlrtRSI;
e_st.site = &cb_emlrtRSI;
e_st.site = &cb_emlrtRSI;
f_st.site = &gg_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &cb_emlrtRSI;
d_st.site = &cb_emlrtRSI;
e_st.site = &gg_emlrtRSI;
c_st.site = &cb_emlrtRSI;
c_st.site = &cb_emlrtRSI;
c_st.site = &cb_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &gg_emlrtRSI;
d_st.site = &gg_emlrtRSI;
e_st.site = &db_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &gg_emlrtRSI;
e_st.site = NULL;
}
b_st.site = &cb_emlrtRSI;
b_st.site = &cb_emlrtRSI;
b_st.site = &cb_emlrtRSI;
c_st.site = &cb_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &gg_emlrtRSI;
b_st.site = &cb_emlrtRSI;
b_st.site = &cb_emlrtRSI;
anyInputSizeChanged = FALSE;
k = 0;
exitg2 = FALSE;
while ((exitg2 == FALSE) && (k < 8)) {
if (obj->inputVarSize1[k] != (uint32_T)iv58[k]) {
anyInputSizeChanged = TRUE;
c_st.site = &cb_emlrtRSI;
for (i = 0; i < 8; i++) {
obj->inputVarSize1[i] = (uint32_T)value[i];
}
d_st.site = &db_emlrtRSI;
exitg2 = TRUE;
} else {
k++;
}
}
if (anyInputSizeChanged) {
b_st.site = &cb_emlrtRSI;
b_st.site = &cb_emlrtRSI;
}
b_st.site = &cb_emlrtRSI;
c_st.site = &cb_emlrtRSI;
c_st.site = &cb_emlrtRSI;
d_st.site = &gg_emlrtRSI;
b_st.site = &cb_emlrtRSI;
b_st.site = &cb_emlrtRSI;
b_st.site = &cb_emlrtRSI;
d_Nondirect_stepImpl(obj, varargin_1, varargout_1);
memcpy(&b_modData[0], &modData[0], 563U * sizeof(creal_T));
memcpy(&b_modData[563], &varargout_1[0], 13U * sizeof(creal_T));
/* Calculate required data sizes for correct receiver operation */
/* Save desired message size */
/* Save number of transmitted frames */
/* Convert data into subcarrier streams */
st.site = &vk_emlrtRSI;
memcpy(&ofdmData[0], &b_modData[0], 576U * sizeof(creal_T));
/* Create Pilots */
st.site = &wk_emlrtRSI;
b_obj = &hPN;
/* System object Constructor function: comm.PNSequence */
b_obj->S0_isInitialized = FALSE;
b_obj->S1_isReleased = FALSE;
for (i = 0; i < 8; i++) {
b_obj->P0_Polynomial[i] = (uint8_T)iv59[i];
}
for (i = 0; i < 7; i++) {
b_obj->P1_IniState[i] = 1;
b_obj->P2_Mask[i] = (uint8_T)iv60[i];
}
st.site = &xk_emlrtRSI;
b_obj = &hPN;
if (!b_obj->S0_isInitialized) {
b_obj->S0_isInitialized = TRUE;
if (b_obj->S1_isReleased) {
emlrtErrorWithMessageIdR2012b(&st, &bc_emlrtRTEI,
"MATLAB:system:runtimeMethodCalledWhenReleasedCodegen", 0);
}
b_st.site = NULL;
b_st.site = NULL;
/* System object Initialization function: comm.PNSequence */
for (ib = 0; ib < 7; ib++) {
b_obj->W0_shiftReg[ib] = b_obj->P1_IniState[ib];
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, &b_st);
}
}
b_st.site = NULL;
/* System object Outputs function: comm.PNSequence */
for (ib = 0; ib < 12; ib++) {
tmp = 0;
for (i = 0; i < 7; i++) {
tmp = (uint8_T)((uint32_T)tmp + (uint8_T)((uint32_T)b_obj->P0_Polynomial[i
+ 1] * b_obj->W0_shiftReg[i]));
}
tmp &= 1;
tmp2 = 0;
for (i = 0; i < 7; i++) {
tmp2 = (uint8_T)((uint32_T)tmp2 + (uint8_T)((uint32_T)b_obj->W0_shiftReg[i]
* b_obj->P2_Mask[i]));
}
pilot[ib] = (int8_T)(tmp2 & 1);
for (i = 5; i > -1; i += -1) {
b_obj->W0_shiftReg[i + 1] = b_obj->W0_shiftReg[i];
}
b_obj->W0_shiftReg[0U] = tmp;
}
/* Create pilot */
st.site = &yk_emlrtRSI;
ib = 0;
for (i = 0; i < 4; i++) {
ia = 0;
for (k = 0; k < 12; k++) {
pilots[ib] = pilot[ia];
b_st.site = &ng_emlrtRSI;
ia++;
b_st.site = &og_emlrtRSI;
ib++;
}
}
/* Expand to all pilot tones */
st.site = &al_emlrtRSI;
for (i = 0; i < 12; i++) {
for (ib = 0; ib < 4; ib++) {
b_pilots[ib + (i << 2)] = 2.0 * (real_T)(pilots[i + 12 * ib] < 1) - 1.0;
}
}
/* Bipolar to unipolar */
st.site = &bl_emlrtRSI;
for (i = 0; i < 12; i++) {
b_pilots[3 + (i << 2)] = -b_pilots[3 + (i << 2)];
}
/* Invert last pilot */
/* Construct Modulator */
st.site = &cl_emlrtRSI;
b_OFDMModulator_OFDMModulator(&st, &hDataMod);
/* Modulate */
st.site = &dl_emlrtRSI;
d_SystemCore_step(&st, &hDataMod, ofdmData, b_pilots, b_r);
/* Add preambles to data */
memcpy(&preambles[0], &completeShortPreambleOFDM[0], 160U * sizeof(creal_T));
memcpy(&preambles[160], &completeLongPreambleOFDM[0], 160U * sizeof(creal_T));
memcpy(&c_r[0], &preambles[0], 320U * sizeof(creal_T));
memcpy(&c_r[320], &b_r[0], 960U * sizeof(creal_T));
/* Repeat frame */
st.site = &el_emlrtRSI;
ib = 0;
for (i = 0; i < 20; i++) {
ia = 0;
for (k = 0; k < 1280; k++) {
r[ib] = c_r[ia];
b_st.site = &ng_emlrtRSI;
ia++;
b_st.site = &og_emlrtRSI;
ib++;
}
}
/* Save Demodulator object data for receiver */
/* hDataDemod = get(OFDMDemodulator(hDataMod)); */
/* hPreambleDemod = get(OFDMDemodulator(hPreambleMod)); */
st.site = &fl_emlrtRSI;
object = iobj_0;
*hDataDemod = object;
b_st.site = &jj_emlrtRSI;
object = *hDataDemod;
c_st.site = &y_emlrtRSI;
d_st.site = &bb_emlrtRSI;
d_st.site = &bb_emlrtRSI;
object->isInitialized = FALSE;
object->isReleased = FALSE;
e_st.site = &cb_emlrtRSI;
f_st.site = &db_emlrtRSI;
e_st.site = &cb_emlrtRSI;
f_st.site = &db_emlrtRSI;
c_st.site = &y_emlrtRSI;
c_st.site = &ab_emlrtRSI;
b_st.site = &kj_emlrtRSI;
c_st.site = &db_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &lj_emlrtRSI;
c_st.site = &db_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &mj_emlrtRSI;
c_st.site = &db_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &nj_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &oj_emlrtRSI;
c_st.site = &db_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &pj_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &qj_emlrtRSI;
c_st.site = &db_emlrtRSI;
/* OFDMBase Base object for OFDMModulator and OFDMDemodulator System objects */
/* Copyright 2013 The MathWorks, Inc. */
/* FFTLength FFT length */
/* Specify the IFFT length. This property can be set to an integer */
/* scalar. The value must be a power of two. The default value of */
/* this property is 64. */
/* CyclicPrefixLength Cyclic prefix length */
/* Specify the cyclic prefix length. This property can be set to a */
/* non-negative interher scalar. The default value of this property is 16. */
/* NumGuardBandCarriers Number of guard bands */
/* Specify the lower and upper guard bands in frequency domain.This */
/* property can be set to a non-nagative two-element vector. */
/* The default setting of this property is [6 5]. */
/* NumSymbols Number of OFDM symbols */
/* Specify the number of OFDM symbols at the output. The default value */
/* of this property is 1. */
/* PilotCarrierIndices Pilot subcarrier indices */
/* Specify the locations where pilots are to be inserted. You can */
/* set this property to a numeric scalar, column vector, matrix, or */
/* 3-D array. The defalut value of the property is [-21; -7; 7; 21]. */
/* Nontunable ideally */
/* Constructor */
/* validateattributes(fftLen, {'numeric'}, ... */
/* {'real','scalar','integer','finite','>=',8}, ... */
/* [class(obj) '.' propName], propName); */
/* validateattributes(CPLen, {'numeric'}, ... */
/* {'real','row','integer','nonnegative','finite'}, ... */
/* [class(obj) '.' propName], propName); */
/* validateattributes(guardBands, {'numeric'}, ... */
/* {'real','integer','nonnegative','finite','size', [2, 1]}, ... */
/* [class(obj) '.' propName], propName); */
/* validateattributes(numSym, {'numeric'}, ... */
/* {'real','scalar','integer','positive','finite'}, ... */
/* [class(obj) '.' propName], propName); */
/* validateattributes(pilotIdx, {'numeric'}, ... */
/* {'real','integer','positive','finite','3d'}, ... */
/* [class(obj) '.' propName], propName); */
/* Check the 3rd dimension for numTx */
d_st.site = &uh_emlrtRSI;
e_st.site = &vh_emlrtRSI;
for (k = 0; k < 4; k++) {
b_data[k] = (int8_T)(12 + 14 * k);
}
f_st.site = &mi_emlrtRSI;
i = 0;
f_st.site = &ki_emlrtRSI;
f_st.site = &ji_emlrtRSI;
k = 1;
while (k <= 4) {
ib = b_data[k - 1];
do {
exitg1 = 0;
f_st.site = &ii_emlrtRSI;
k++;
if (k > 4) {
exitg1 = 1;
} else {
f_st.site = &hi_emlrtRSI;
frexp((real_T)ib / 2.0, &exponent);
if (muDoubleScalarAbs(ib - b_data[k - 1]) < ldexp(1.0, exponent - 53)) {
anyInputSizeChanged = TRUE;
} else {
anyInputSizeChanged = FALSE;
}
if (!anyInputSizeChanged) {
exitg1 = 1;
}
}
} while (exitg1 == 0);
f_st.site = &gi_emlrtRSI;
i++;
b_data[i - 1] = (int8_T)ib;
f_st.site = &fi_emlrtRSI;
f_st.site = &fi_emlrtRSI;
}
f_st.site = &bi_emlrtRSI;
f_st.site = &ai_emlrtRSI;
f_st.site = &wh_emlrtRSI;
if (1 > i) {
b2 = FALSE;
} else {
b2 = (i > 2147483646);
}
if (b2) {
g_st.site = &bg_emlrtRSI;
check_forloop_overflow_error(&g_st);
}
d_st.site = &uh_emlrtRSI;
d_st.site = &uh_emlrtRSI;
if (1 > i) {
i12 = 0;
} else {
i12 = i;
}
if (!(4 != i12)) {
} else {
e_y = NULL;
m10 = mxCreateCharArray(2, iv61);
for (i = 0; i < 13; i++) {
cv66[i] = cv67[i];
}
emlrtInitCharArrayR2013a(&d_st, 13, m10, cv66);
emlrtAssign(&e_y, m10);
e_st.site = &mv_emlrtRSI;
c_error(&e_st, b_message(&e_st, e_y, &g_emlrtMCI), &g_emlrtMCI);
}
/* Error message: */
/* If pilot index is 2-D, the indices per symbol must be unique; */
/* If pilot index is 3-D, the indices across transmit antennas per symbol must be unique. */
c_st.site = &db_emlrtRSI;
st.site = &gl_emlrtRSI;
object = iobj_1;
*hPreambleDemod = object;
b_st.site = &jj_emlrtRSI;
object = *hPreambleDemod;
c_st.site = &y_emlrtRSI;
d_st.site = &bb_emlrtRSI;
d_st.site = &bb_emlrtRSI;
object->isInitialized = FALSE;
object->isReleased = FALSE;
e_st.site = &cb_emlrtRSI;
f_st.site = &db_emlrtRSI;
e_st.site = &cb_emlrtRSI;
f_st.site = &db_emlrtRSI;
c_st.site = &y_emlrtRSI;
c_st.site = &ab_emlrtRSI;
b_st.site = &kj_emlrtRSI;
c_st.site = &db_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &lj_emlrtRSI;
c_st.site = &db_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &mj_emlrtRSI;
c_st.site = &db_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &nj_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &oj_emlrtRSI;
c_st.site = &db_emlrtRSI;
c_st.site = &db_emlrtRSI;
b_st.site = &pj_emlrtRSI;
c_st.site = &db_emlrtRSI;
/* Calcuate OFDM frequency bin size */
/* Calculate locations of pilots without guardbands */
/* Calculate locations of subcarrier datastreams without guardbands */
/* Remove guardband offsets */
/* Remove index offsets for pilots and guardbands */
/* dataSubcarrierIndexies([pilotLocationsWithoutGuardbands;DCNullLocation]) = [];%Remove pilot and DCNull locations */
/* Create return structure */
for (i = 0; i < 560; i++) {
tx->originalData[i] = b_originalData[i];
}
for (i = 0; i < 64; i++) {
tx->shortPreambleOFDM[i] = shortPreambleOFDM[i];
}
for (i = 0; i < 160; i++) {
tx->completeShortPreambleOFDM[i] = completeShortPreambleOFDM[i];
}
for (i = 0; i < 53; i++) {
tx->shortPreamble[i] = dcv3[i];
}
for (i = 0; i < 53; i++) {
tx->longPreamble[i] = iv62[i];
}
for (i = 0; i < 64; i++) {
tx->longPreambleOFDM[i] = longPreambleOFDM[i];
}
for (i = 0; i < 160; i++) {
tx->completeLongPreambleOFDM[i] = completeLongPreambleOFDM[i];
}
for (i = 0; i < 48; i++) {
tx->pilots[i] = b_pilots[i];
}
for (i = 0; i < 320; i++) {
tx->preambles[i] = preambles[i];
}
for (i = 0; i < 4; i++) {
tx->pilotLocationsWithoutGuardbands[i] = 6.0 + 14.0 * (real_T)i;
}
tx->dataSubcarrierIndexies.size[0] = 1;
tx->dataSubcarrierIndexies.size[1] = 48;
for (i = 0; i < 48; i++) {
tx->dataSubcarrierIndexies.data[i] = iv63[i];
}
tx->samplingFreq = 5.0E+6;
tx->FFTLength = 64.0;
tx->enableMA = TRUE;
tx->numCarriers = 48.0;
tx->padBits = 13.0;
tx->numSamples = 576.0;
tx->messageCharacters = 80.0;
tx->numFrames = 20.0;
tx->frameLength = 1280.0;
tx->freqBin = 78125.0;
tx->DecimationFactor = 0.0;
tx->receiveBufferLength = 0.0;
/* padBits: 13 */
/* numSamples: 576 */
/* messageCharacters: 80 */
/* numFrames: 1000 */
/* frameLength: 1280 */
/* freqBin: 312500 */
/* hDataDemod: [1x1 struct] */
/* hPreambleDemod: [1x1 struct] */
st.site = NULL;
b_Destructor(&hPN);
emxFreeStruct_OFDMModulator(&hPreambleMod);
emxFreeStruct_OFDMModulator_1(&hDataMod);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
}
static void sf_c2_controller1(SFc2_controller1InstanceStruct *chartInstance)
{
int32_T c2_previousEvent;
real_T c2_hoistedGlobal;
real_T c2_u;
uint32_T c2_debug_family_var_map[4];
real_T c2_nargin = 1.0;
real_T c2_nargout = 1.0;
real_T c2_y;
real_T c2_x;
real_T c2_b_x;
real_T c2_b_y;
real_T c2_c_x;
real_T c2_xk;
real_T c2_d_x;
real_T c2_e_x;
real_T c2_f_x;
real_T *c2_b_u;
real_T *c2_c_y;
c2_c_y = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c2_b_u = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 1);
_SFD_DATA_RANGE_CHECK(*c2_b_u, 0U);
_SFD_DATA_RANGE_CHECK(*c2_c_y, 1U);
c2_previousEvent = _sfEvent_;
_sfEvent_ = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 1);
c2_hoistedGlobal = *c2_b_u;
c2_u = c2_hoistedGlobal;
sf_debug_symbol_scope_push_eml(0U, 4U, 4U, c2_debug_family_names,
c2_debug_family_var_map);
sf_debug_symbol_scope_add_eml(&c2_nargin, c2_sf_marshall, 0U);
sf_debug_symbol_scope_add_eml(&c2_nargout, c2_sf_marshall, 1U);
sf_debug_symbol_scope_add_eml(&c2_u, c2_sf_marshall, 2U);
sf_debug_symbol_scope_add_eml(&c2_y, c2_sf_marshall, 3U);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0, 2);
c2_x = c2_u;
c2_b_x = c2_x;
c2_b_y = muDoubleScalarAbs(c2_b_x);
if (CV_EML_IF(0, 0, c2_b_y > 90.0)) {
_SFD_EML_CALL(0, 3);
c2_c_x = c2_u;
c2_eml_scalar_eg(chartInstance);
c2_xk = c2_c_x;
c2_d_x = c2_xk;
c2_eml_scalar_eg(chartInstance);
c2_e_x = c2_d_x / 90.0;
c2_f_x = c2_e_x;
c2_f_x = muDoubleScalarFloor(c2_f_x);
c2_u = c2_d_x - c2_f_x * 90.0;
}
_SFD_EML_CALL(0, 5);
c2_y = c2_u;
_SFD_EML_CALL(0, -5);
sf_debug_symbol_scope_pop();
*c2_c_y = c2_y;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 1);
_sfEvent_ = c2_previousEvent;
sf_debug_check_for_state_inconsistency(_controller1MachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
void drr_151213_XRayInParam(const emlrtStack *sp, const emxArray_boolean_T
*voxel_data, const real_T voxel_size_mm[3], const real_T detector_dimensions[2],
const real_T XRayIntrinsicParam[12], const real_T voxel_corner_min[3], const
real_T T_carm[16], emxArray_real_T *projection)
{
const mxArray *y;
static const int32_T iv0[2] = { 1, 32 };
const mxArray *m0;
char_T cv0[32];
int32_T i;
static const char_T cv1[32] = { 'v', 'o', 'x', 'e', 'l', '_', 'd', 'a', 't',
'a', ' ', 'm', 'u', 's', 't', ' ', 'b', 'e', ' ', '3', '-', 'd', 'i', 'm',
'e', 'n', 's', 'i', 'o', 'n', 'a', 'l' };
int32_T i0;
real_T pixel_size_mm_h;
real_T pixel_size_mm_w;
uint32_T voxDim[3];
real_T voxPlanes__max[3];
real_T source[3];
real_T pixel_size_mmel_wn[3];
real_T pixel_size_mmel_hn[3];
real_T corner[3];
int32_T ih;
int32_T iw;
real_T tstep[3];
real_T tnext[3];
real_T pixel_point_mm[3];
real_T ray_source2pixel[3];
real_T b_voxPlanes__max[3];
real_T b_ray_source2pixel[3];
real_T t_plane_min[3];
real_T t_plane_max[3];
real_T tmax;
int32_T pixel_size_mmIntensity;
boolean_T exitg8;
boolean_T exitg7;
boolean_T exitg6;
real_T t_larger[4];
real_T temp;
boolean_T exitg5;
boolean_T exitg4;
boolean_T exitg3;
real_T t_smaller[4];
int32_T itmp;
boolean_T exitg2;
boolean_T exitg1;
real_T iz;
real_T tx;
real_T ty;
real_T tz;
int32_T i1;
int32_T i2;
int32_T i3;
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
/* % Modificiation Notes */
/* 15.12.04 */
/* - Release 기존의 파일을 참고로 하여 고성영이 수정하였음. */
/* - DRR을 완벽하게 하지 않고, voxel에 한점이라도 만나면 on으로 계산함 */
/* - 계산속도가 향상되었음 */
/* - 젬스에 있는 X-ray와 테스트하여 검증하였음 */
/* 15 12 13 : The function input has been changed to utilize the x-ray */
/* intrinsic parameter provided by GEMSS % 151213 kosy */
/* %function [projection] = drr (voxel_data, voxel_size_mm, detector_dimensions, pixel_size_mm, isocenter_mm, cbct_angles_deg) */
/* Creates a 2D projection at each cbct_angle of voxel_data. the projection */
/* axis is defined by the isocenter to which the source and center of */
/* the detector are aligned. This simulation assumes standard Cone Beam CT */
/* geometry (source to isocenter distance is 100 cm and source to detector */
/* distance is 150cm). */
/* */
/* voxel_data: must be a 3 dimensional matrix (typically of CT data) */
/* voxel_size_mm: a 3 element vector listing the size (in mm) of the voxels */
/* along each dimension */
/* detector_dimension: a 2 element vector listing the dimensions (number of */
/* pixels) in each dimension (u,v) */
/* pixel_size_mm: a number defining the height and width of each pixel */
/* (assumes square pixel) */
/* isocenter_mm: a 3 element vector pointing from the origin (corner) of the */
/* matrix element(1,1,1) to the isocenter */
/* cbct_angles_deg: a list of angles to generate projections */
/* */
/* Retrun Variable */
/* projection: a 3D matrix with the 3rd dimension representing the angle of */
/* roatation */
/* */
/* { */
/* Author: Michael M. Folkerts [email protected] */
/* Institution: UCSD Physics, UTSW Radiation Oncology */
/* Updated: 2014-July. */
/* Notes: Siddon's Incremental algorithm | modified to read in 3D matlab matrix | Simplified Input | No guarantees!! */
/* */
/* References: */
/* R.L. Siddon, */
/* "Fast calculation of the exact radiological path for a three-dimensional CT */
/* array," Medical Physics 12, 252-255 (1985). */
/* */
/* F. Jacobs, E. Sundermann, B. De Sutter, M. Christiaens and I. Lemahieu, */
/* "A fast algorithm to calculate the exact radiological path through a pixel_size_mmel or voxel space," */
/* Journal of Computing and Information Technology 6, 89-94 (1998). */
/* */
/* G. Han, Z. Liang and J. You, */
/* "A fast ray tracing technique for TCT and ECT studies," */
/* IEEE Medical Imaging Conference 1999. */
/* } */
/* function [projection] = drr_good_151204 (voxel_data, voxel_size_mm, detector_dimensions, pixel_size_mm, voxel_corner_min, T_carm) */
/* if(0) */
/* voxel_data = OUTPUTgrid; */
/* voxel_size_mm = voxel_size; */
/* detector_dimensions = detector_dimension; */
/* pixel_size_mm = pixel_size; */
/* isocenter_mm = isocenter; */
/* T_carm: Transformation matrix of C-arm (that is set at the middle of */
/* detector & source) with respect to Voxel coordinates */
/* tic; */
/* this will verify the size: */
if (eml_ndims_varsized(*(int32_T (*)[3])voxel_data->size) != 3) {
st.site = &emlrtRSI;
y = NULL;
m0 = emlrtCreateCharArray(2, iv0);
for (i = 0; i < 32; i++) {
cv0[i] = cv1[i];
}
emlrtInitCharArrayR2013a(&st, 32, m0, cv0);
emlrtAssign(&y, m0);
b_st.site = &b_emlrtRSI;
error(&b_st, y, &emlrtMCI);
}
/* constants: */
/* .0001; */
/* .0001; */
/* sounce to imager(detector) distance */
/* source to axis distance %% RRI set the coordinate at the middle between source and the detector */
/* initialize memory for speed: */
i0 = projection->size[0] * projection->size[1];
pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[0],
&b_emlrtDCI, sp);
projection->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&emlrtDCI, sp);
pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[1],
&d_emlrtDCI, sp);
projection->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&c_emlrtDCI, sp);
emxEnsureCapacity(sp, (emxArray__common *)projection, i0, (int32_T)sizeof
(real_T), &emlrtRTEI);
pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[0],
&b_emlrtDCI, sp);
pixel_size_mm_w = emlrtNonNegativeCheckFastR2012b(detector_dimensions[1],
&d_emlrtDCI, sp);
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h, &emlrtDCI, sp) *
(int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w, &c_emlrtDCI, sp);
for (i0 = 0; i0 < i; i0++) {
projection->data[i0] = 0.0;
}
for (i0 = 0; i0 < 3; i0++) {
voxDim[i0] = (uint32_T)voxel_data->size[i0];
}
/* [size(voxel_data,1), size(voxel_data,2), size(voxel_data,3)]; */
/* voxDim_x = voxDim(1); */
/* voxDim_y = voxDim(2); */
/* voxDim_z = voxDim(3); */
/* difine voxel boundaries: */
/* vector from origin to source */
/* vector from origin to CENTER of detector */
/* extract the key information from the intrinsic parameters % 151213 kosy modi */
pixel_size_mm_h = 1105.0 / XRayIntrinsicParam[0];
pixel_size_mm_w = 1105.0 / XRayIntrinsicParam[4];
/* vector pointing left, parallel to detector */
/* define incremental vectors: */
/* define upper lefthand corner of detector: */
/* corner = detector + ( center_pixel_w*pixel_size_mmel.wn + center_pixel_h*pixel_size_mmel.hn ); */
for (i = 0; i < 3; i++) {
voxPlanes__max[i] = voxel_corner_min[i] + voxel_size_mm[i] * (real_T)
voxDim[i];
/* define up: */
/* up = [0,0,1]; */
/* width of projection image */
/* height of projection image */
/* direction from the detector to the source */
/* end initialization timer: */
/* init_time = toc */
/* start tracing timer: */
/* tic; */
source[i] = 552.5 * T_carm[4 + i] + T_carm[12 + i];
/* define pixel_size_mmel vectors: */
/* length of pixel_size_mmel */
pixel_size_mmel_wn[i] = -pixel_size_mm_w * T_carm[i];
pixel_size_mmel_hn[i] = -pixel_size_mm_h * T_carm[8 + i];
corner[i] = (-552.5 * T_carm[4 + i] + T_carm[12 + i]) +
(detector_dimensions[0] * (pixel_size_mm_w * T_carm[i]) +
detector_dimensions[1] * (pixel_size_mm_h * T_carm[8 + i])) / 2.0;
}
emlrtForLoopVectorCheckR2012b(1.0, 1.0, detector_dimensions[0], mxDOUBLE_CLASS,
(int32_T)detector_dimensions[0], &d_emlrtRTEI,
sp);
ih = 1;
while (ih - 1 <= (int32_T)detector_dimensions[0] - 1) {
/* if(mod(ih,100)==0),fprintf('height:\t%i...\n',ih);end */
emlrtForLoopVectorCheckR2012b(1.0, 1.0, detector_dimensions[1],
mxDOUBLE_CLASS, (int32_T)detector_dimensions[1], &c_emlrtRTEI, sp);
iw = 1;
while (iw - 1 <= (int32_T)detector_dimensions[1] - 1) {
/* pixel_point_mm = corner + (ih-1)*pixel_size_mmel.hp + (iw-1)*pixel_size_mmel.wp; %ray end point */
/* ray to be traced */
/* find parametrized (t) voxel plane (min or max) intersections: */
/* PLANE = P1 + t(P2-P1) */
/* SK added */
/* t_x = (i-x1) / (x2-x1), t_y = (j-y1) / (y2-y1), t_z = (k-z1) / (z2-z1) */
for (i = 0; i < 3; i++) {
pixel_size_mm_h = (corner[i] + ((1.0 + (real_T)(ih - 1)) - 1.0) *
pixel_size_mmel_hn[i]) + ((1.0 + (real_T)(iw - 1)) -
1.0) * pixel_size_mmel_wn[i];
/* ray end point */
pixel_size_mm_w = pixel_size_mm_h - source[i];
tstep[i] = voxel_corner_min[i] - source[i];
tnext[i] = pixel_size_mm_w + 2.2250738585072014E-308;
b_voxPlanes__max[i] = voxPlanes__max[i] - source[i];
b_ray_source2pixel[i] = pixel_size_mm_w + 2.2250738585072014E-308;
pixel_point_mm[i] = pixel_size_mm_h;
ray_source2pixel[i] = pixel_size_mm_w;
}
rdivide(tstep, tnext, t_plane_min);
rdivide(b_voxPlanes__max, b_ray_source2pixel, t_plane_max);
/* compute (parametric) intersection values */
/* tmin = max { min{tx(0), tx(Nx)}, min{ty(0), ty(Ny)], min{tz(0), tz(Nz)}, 0.0 } */
/* tmax = min { max{tx(0), tx(Nx)}, max{ty(0), ty(Ny)], max{tz(0), tz(Nz)}, 1.0 } */
/* t_larger = [ max([t_plane_min(1), t_plane_max(1)]), max([t_plane_min(2), t_plane_max(2)]), max([t_plane_min(3), t_plane_max(3)]), 1.0 ]; */
/* t_smaller = [ min([t_plane_min(1), t_plane_max(1)]), min([t_plane_min(2), t_plane_max(2)]), min([t_plane_min(3), t_plane_max(3)]), 0.0 ]; */
i = 1;
tmax = t_plane_min[0];
if (muDoubleScalarIsNaN(t_plane_min[0])) {
pixel_size_mmIntensity = 2;
exitg8 = false;
while ((!exitg8) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[0])) {
tmax = t_plane_max[0];
exitg8 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[0] > tmax)) {
tmax = t_plane_max[0];
}
i = 1;
pixel_size_mm_h = t_plane_min[1];
if (muDoubleScalarIsNaN(t_plane_min[1])) {
pixel_size_mmIntensity = 2;
exitg7 = false;
while ((!exitg7) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[1])) {
pixel_size_mm_h = t_plane_max[1];
exitg7 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[1] > pixel_size_mm_h)) {
pixel_size_mm_h = t_plane_max[1];
}
i = 1;
pixel_size_mm_w = t_plane_min[2];
if (muDoubleScalarIsNaN(t_plane_min[2])) {
pixel_size_mmIntensity = 2;
exitg6 = false;
while ((!exitg6) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[2])) {
pixel_size_mm_w = t_plane_max[2];
exitg6 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[2] > pixel_size_mm_w)) {
pixel_size_mm_w = t_plane_max[2];
}
t_larger[0] = tmax;
t_larger[1] = pixel_size_mm_h;
t_larger[2] = pixel_size_mm_w;
t_larger[3] = 1.0;
i = 1;
temp = t_plane_min[0];
if (muDoubleScalarIsNaN(t_plane_min[0])) {
pixel_size_mmIntensity = 2;
exitg5 = false;
while ((!exitg5) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[0])) {
temp = t_plane_max[0];
exitg5 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[0] < temp)) {
temp = t_plane_max[0];
}
i = 1;
pixel_size_mm_h = t_plane_min[1];
if (muDoubleScalarIsNaN(t_plane_min[1])) {
pixel_size_mmIntensity = 2;
exitg4 = false;
while ((!exitg4) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[1])) {
pixel_size_mm_h = t_plane_max[1];
exitg4 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[1] < pixel_size_mm_h)) {
pixel_size_mm_h = t_plane_max[1];
}
i = 1;
pixel_size_mm_w = t_plane_min[2];
if (muDoubleScalarIsNaN(t_plane_min[2])) {
pixel_size_mmIntensity = 2;
exitg3 = false;
while ((!exitg3) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[2])) {
pixel_size_mm_w = t_plane_max[2];
exitg3 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[2] < pixel_size_mm_w)) {
pixel_size_mm_w = t_plane_max[2];
}
t_smaller[0] = temp;
t_smaller[1] = pixel_size_mm_h;
t_smaller[2] = pixel_size_mm_w;
t_smaller[3] = 0.0;
i = 1;
itmp = 0;
if (muDoubleScalarIsNaN(temp)) {
pixel_size_mmIntensity = 1;
exitg2 = false;
while ((!exitg2) && (pixel_size_mmIntensity + 1 < 5)) {
i = pixel_size_mmIntensity + 1;
if (!muDoubleScalarIsNaN(t_smaller[pixel_size_mmIntensity])) {
temp = t_smaller[pixel_size_mmIntensity];
itmp = pixel_size_mmIntensity;
exitg2 = true;
} else {
pixel_size_mmIntensity++;
}
}
}
if (i < 4) {
while (i + 1 < 5) {
if (t_smaller[i] > temp) {
temp = t_smaller[i];
itmp = i;
}
i++;
}
}
i = 1;
if (muDoubleScalarIsNaN(tmax)) {
pixel_size_mmIntensity = 2;
exitg1 = false;
while ((!exitg1) && (pixel_size_mmIntensity < 5)) {
i = pixel_size_mmIntensity;
if (!muDoubleScalarIsNaN(t_larger[pixel_size_mmIntensity - 1])) {
tmax = t_larger[pixel_size_mmIntensity - 1];
exitg1 = true;
} else {
pixel_size_mmIntensity++;
}
}
}
if (i < 4) {
while (i + 1 < 5) {
if (t_larger[i] < tmax) {
tmax = t_larger[i];
}
i++;
}
}
for (i0 = 0; i0 < 3; i0++) {
pixel_point_mm[i0] = (real_T)(pixel_point_mm[i0] < source[i0]) * -2.0 +
1.0;
}
if (temp < tmax) {
/* if ray intersects volume */
/* find index for each dimension: */
for (i = 0; i < 3; i++) {
pixel_size_mm_h = muDoubleScalarFloor((((ray_source2pixel[i] * temp +
source[i]) - voxel_corner_min[i]) + 2.2250738585072014E-308) /
voxel_size_mm[i]);
/* (parametric) intersection values... */
/* makes 0 or 1 */
tnext[i] = (voxel_corner_min[i] + ((pixel_size_mm_h +
(pixel_point_mm[i] + 1.0) / 2.0) * voxel_size_mm[i] - source[i])) /
(ray_source2pixel[i] + 2.2250738585072014E-308);
/* parametric value for next plane intersection */
tstep[i] = muDoubleScalarAbs(voxel_size_mm[i] / (ray_source2pixel[i] +
2.2250738585072014E-308));
t_plane_min[i] = pixel_size_mm_h;
}
/* parametric step size */
/* address special cases... */
if (temp == t_plane_max[emlrtDynamicBoundsCheckFastR2012b(itmp + 1, 1, 3,
&c_emlrtBCI, sp) - 1]) {
/* if intersection is a "max" plane */
t_plane_min[itmp] = (real_T)voxDim[itmp] - 1.0;
tnext[itmp] = temp + tstep[itmp];
/* next plane crossing */
} else {
t_plane_min[itmp] = 0.0;
tnext[itmp] = temp + tstep[itmp];
/* next plane crossing */
}
/* voxel index values(add one for matlab): */
pixel_size_mm_h = t_plane_min[0] + 1.0;
pixel_size_mm_w = t_plane_min[1] + 1.0;
iz = t_plane_min[2] + 1.0;
tx = tnext[0];
ty = tnext[1];
tz = tnext[2];
pixel_size_mmIntensity = 0;
/* uncomment to generate P-matrix: */
/* pixel_size_mmNum = 1; */
/* len = norm(ray_source2pixel); % ray length */
while ((temp + 0.0001 < tmax) && (!(pixel_size_mm_h * pixel_size_mm_w *
iz == 0.0))) {
if ((tx < ty) && (tx < tz)) {
/* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */
i0 = voxel_data->size[0];
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&k_emlrtDCI, sp);
itmp = voxel_data->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w,
&l_emlrtDCI, sp);
i2 = voxel_data->size[2];
i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &m_emlrtDCI, sp);
if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0,
&j_emlrtBCI, sp) + voxel_data->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(i1, 1,
itmp, &k_emlrtBCI, sp) - 1)) + voxel_data->size[0] *
voxel_data->size[1] *
(emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2,
&l_emlrtBCI, sp) - 1)) - 1]) {
pixel_size_mmIntensity = 255;
tmax = rtMinusInf;
}
temp = tx;
tx += tstep[0];
pixel_size_mm_h += pixel_point_mm[0];
} else if (ty < tz) {
/* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */
i0 = voxel_data->size[0];
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&h_emlrtDCI, sp);
itmp = voxel_data->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w,
&i_emlrtDCI, sp);
i2 = voxel_data->size[2];
i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &j_emlrtDCI, sp);
if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0,
&g_emlrtBCI, sp) + voxel_data->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(i1, 1,
itmp, &h_emlrtBCI, sp) - 1)) + voxel_data->size[0] *
voxel_data->size[1] *
(emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2,
&i_emlrtBCI, sp) - 1)) - 1]) {
pixel_size_mmIntensity = 255;
tmax = rtMinusInf;
}
temp = ty;
ty += tstep[1];
pixel_size_mm_w += pixel_point_mm[1];
} else {
/* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */
i0 = voxel_data->size[0];
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&e_emlrtDCI, sp);
itmp = voxel_data->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w,
&f_emlrtDCI, sp);
i2 = voxel_data->size[2];
i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &g_emlrtDCI, sp);
if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0,
&d_emlrtBCI, sp) + voxel_data->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(i1, 1,
itmp, &e_emlrtBCI, sp) - 1)) + voxel_data->size[0] *
voxel_data->size[1] *
(emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2,
&f_emlrtBCI, sp) - 1)) - 1]) {
pixel_size_mmIntensity = 255;
tmax = rtMinusInf;
}
temp = tz;
tz += tstep[2];
iz += pixel_point_mm[2];
}
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* end while */
i0 = projection->size[0];
i = projection->size[1];
projection->data[(emlrtDynamicBoundsCheckFastR2012b(ih, 1, i0,
&m_emlrtBCI, sp) + projection->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(iw, 1, i,
&n_emlrtBCI, sp) - 1)) - 1] = pixel_size_mmIntensity;
} else {
/* if no intersections */
i0 = projection->size[0];
i = projection->size[1];
projection->data[(emlrtDynamicBoundsCheckFastR2012b(ih, 1, i0, &emlrtBCI,
sp) + projection->size[0] * (emlrtDynamicBoundsCheckFastR2012b(iw, 1,
i, &b_emlrtBCI, sp) - 1)) - 1] = 0.0;
}
/* if intersections */
/* uncomment to generate P-matrix: */
/* rayCount = rayCount + 1; */
iw++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* width */
/* fprintf('\n'); */
ih++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* height */
/* uncomment to generate P-matrix: */
/* matrix = matrix(1:mtxCount-1,:); */
/* stop trace timer: */
/* trace_time = toc */
/* fprintf('\n') */
/* function */
/* } */
}
static void sf_gateway_c2_Demo_AU_VA1(SFc2_Demo_AU_VA1InstanceStruct
*chartInstance)
{
real_T c2_hoistedGlobal;
real_T c2_randv;
uint32_T c2_debug_family_var_map[6];
real_T c2_randTrigger;
real_T c2_nargin = 1.0;
real_T c2_nargout = 2.0;
real_T c2_v_trigW;
real_T c2_v_trig;
real_T c2_x;
real_T c2_b_x;
real_T c2_c_x;
real_T c2_d_x;
real_T *c2_b_randv;
real_T *c2_b_v_trigW;
real_T *c2_b_v_trig;
boolean_T guard1 = false;
boolean_T guard2 = false;
c2_b_v_trig = (real_T *)ssGetOutputPortSignal(chartInstance->S, 2);
c2_b_v_trigW = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c2_b_randv = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_SFD_SYMBOL_SCOPE_PUSH(0U, 0U);
_sfTime_ = sf_get_time(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
_SFD_DATA_RANGE_CHECK(*c2_b_randv, 0U);
chartInstance->c2_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
c2_hoistedGlobal = *c2_b_randv;
c2_randv = c2_hoistedGlobal;
_SFD_SYMBOL_SCOPE_PUSH_EML(0U, 6U, 6U, c2_debug_family_names,
c2_debug_family_var_map);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_randTrigger, 0U, c2_sf_marshallOut,
c2_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_nargin, 1U, c2_sf_marshallOut,
c2_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_nargout, 2U, c2_sf_marshallOut,
c2_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML(&c2_randv, 3U, c2_sf_marshallOut);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_v_trigW, 4U, c2_sf_marshallOut,
c2_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c2_v_trig, 5U, c2_sf_marshallOut,
c2_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 3);
c2_v_trigW = 0.0;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 5);
c2_x = c2_randv;
c2_randTrigger = c2_x;
c2_b_x = c2_randTrigger;
c2_randTrigger = c2_b_x;
c2_randTrigger = muDoubleScalarFloor(c2_randTrigger);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 7);
guard2 = false;
if (CV_EML_COND(0, 1, 0, 0.0 < c2_randTrigger)) {
if (CV_EML_COND(0, 1, 1, c2_randTrigger < 30.0)) {
CV_EML_MCDC(0, 1, 0, true);
CV_EML_IF(0, 1, 0, true);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 8);
c2_v_trigW += 0.1;
} else {
guard2 = true;
}
} else {
guard2 = true;
}
if (guard2 == true) {
CV_EML_MCDC(0, 1, 0, false);
CV_EML_IF(0, 1, 0, false);
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 10);
guard1 = false;
if (CV_EML_COND(0, 1, 2, 30.0 < c2_randTrigger)) {
if (CV_EML_COND(0, 1, 3, c2_randTrigger < 60.0)) {
CV_EML_MCDC(0, 1, 1, true);
CV_EML_IF(0, 1, 1, true);
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 11);
c2_v_trigW -= 0.1;
} else {
guard1 = true;
}
} else {
guard1 = true;
}
if (guard1 == true) {
CV_EML_MCDC(0, 1, 1, false);
CV_EML_IF(0, 1, 1, false);
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 14);
if (CV_EML_IF(0, 1, 2, c2_v_trigW > 0.0)) {
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 15);
c2_v_trig = 1.0;
} else {
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 16);
if (CV_EML_IF(0, 1, 3, c2_v_trigW < 0.0)) {
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 17);
c2_v_trig = -1.0;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 18);
c2_c_x = c2_v_trigW;
c2_d_x = c2_c_x;
c2_v_trigW = muDoubleScalarAbs(c2_d_x);
} else {
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 20);
c2_v_trig = 0.0;
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, 20);
c2_v_trigW = 0.0;
}
}
_SFD_EML_CALL(0U, chartInstance->c2_sfEvent, -20);
_SFD_SYMBOL_SCOPE_POP();
*c2_b_v_trigW = c2_v_trigW;
*c2_b_v_trig = c2_v_trig;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 1U, chartInstance->c2_sfEvent);
_SFD_SYMBOL_SCOPE_POP();
_SFD_CHECK_FOR_STATE_INCONSISTENCY(_Demo_AU_VA1MachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
_SFD_DATA_RANGE_CHECK(*c2_b_v_trigW, 1U);
_SFD_DATA_RANGE_CHECK(*c2_b_v_trig, 2U);
}
static void sf_c1_Model_justmodel2(SFc1_Model_justmodel2InstanceStruct
*chartInstance)
{
int32_T c1_i2;
real_T c1_hoistedGlobal;
real_T c1_time;
uint32_T c1_debug_family_var_map[5];
real_T c1_surge;
real_T c1_nargin = 1.0;
real_T c1_nargout = 1.0;
real_T c1_Force[3];
int32_T c1_i3;
real_T c1_b;
real_T c1_y;
real_T c1_b_b;
real_T c1_b_y;
real_T c1_x;
real_T c1_b_x;
real_T c1_c_b;
real_T c1_c_y;
real_T c1_d_b;
real_T c1_d_y;
real_T c1_c_x;
real_T c1_d_x;
real_T c1_e_b;
real_T c1_e_y;
real_T c1_e_x;
real_T c1_f_x;
real_T c1_f_y;
real_T c1_varargin_1;
real_T c1_varargin_2;
real_T c1_g_x;
real_T c1_h_x;
real_T c1_xk;
real_T c1_i_x;
int32_T c1_i4;
real_T *c1_b_time;
real_T (*c1_b_Force)[3];
c1_b_Force = (real_T (*)[3])ssGetOutputPortSignal(chartInstance->S, 1);
c1_b_time = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
_SFD_DATA_RANGE_CHECK(*c1_b_time, 0U);
for (c1_i2 = 0; c1_i2 < 3; c1_i2++) {
_SFD_DATA_RANGE_CHECK((*c1_b_Force)[c1_i2], 1U);
}
chartInstance->c1_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
c1_hoistedGlobal = *c1_b_time;
c1_time = c1_hoistedGlobal;
_SFD_SYMBOL_SCOPE_PUSH_EML(0U, 5U, 5U, c1_debug_family_names,
c1_debug_family_var_map);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c1_surge, 0U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c1_nargin, 1U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c1_nargout, 2U, c1_b_sf_marshallOut,
c1_b_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML(&c1_time, 3U, c1_b_sf_marshallOut);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(c1_Force, 4U, c1_sf_marshallOut,
c1_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 3);
for (c1_i3 = 0; c1_i3 < 3; c1_i3++) {
c1_Force[c1_i3] = 0.0;
}
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 5);
c1_b = c1_time;
c1_y = 0.066666666666666666 * c1_b;
c1_b_b = c1_time;
c1_b_y = 0.5 * c1_b_b;
c1_x = c1_b_y;
c1_b_x = c1_x;
c1_b_x = muDoubleScalarCos(c1_b_x);
c1_c_b = c1_b_x;
c1_c_y = 10.0 * c1_c_b;
c1_d_b = c1_time;
c1_d_y = 0.3 * c1_d_b;
c1_c_x = c1_d_y + 0.32;
c1_d_x = c1_c_x;
c1_d_x = muDoubleScalarSin(c1_d_x);
c1_e_b = c1_d_x;
c1_e_y = 14.0 * c1_e_b;
c1_e_x = c1_c_y + c1_e_y;
c1_f_x = c1_e_x;
c1_f_y = muDoubleScalarAbs(c1_f_x);
c1_varargin_1 = c1_y + c1_f_y;
c1_varargin_2 = c1_varargin_1;
c1_g_x = c1_varargin_2;
c1_h_x = c1_g_x;
c1_eml_scalar_eg(chartInstance);
c1_xk = c1_h_x;
c1_i_x = c1_xk;
c1_eml_scalar_eg(chartInstance);
c1_surge = muDoubleScalarMin(c1_i_x, 40.0);
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, 7);
c1_Force[0] = c1_surge;
_SFD_EML_CALL(0U, chartInstance->c1_sfEvent, -7);
_SFD_SYMBOL_SCOPE_POP();
for (c1_i4 = 0; c1_i4 < 3; c1_i4++) {
(*c1_b_Force)[c1_i4] = c1_Force[c1_i4];
}
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 0U, chartInstance->c1_sfEvent);
_SFD_CHECK_FOR_STATE_INCONSISTENCY(_Model_justmodel2MachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void sf_c17_HIL_model_error(SFc17_HIL_model_errorInstanceStruct
*chartInstance)
{
real_T c17_hoistedGlobal;
real_T c17_b_hoistedGlobal;
real_T c17_alpha_pi;
real_T c17_accumulation;
uint32_T c17_debug_family_var_map[6];
real_T c17_sgn;
real_T c17_nargin = 2.0;
real_T c17_nargout = 1.0;
real_T c17_alpha_inf;
real_T c17_x;
real_T c17_b_x;
real_T c17_y;
real_T c17_c_x;
real_T c17_d_x;
real_T c17_a;
real_T c17_b_y;
real_T c17_b_a;
real_T c17_c_y;
real_T *c17_b_alpha_pi;
real_T *c17_b_alpha_inf;
real_T *c17_b_accumulation;
int32_T exitg1;
c17_b_accumulation = (real_T *)ssGetInputPortSignal(chartInstance->S, 1);
c17_b_alpha_inf = (real_T *)ssGetOutputPortSignal(chartInstance->S, 1);
c17_b_alpha_pi = (real_T *)ssGetInputPortSignal(chartInstance->S, 0);
_sfTime_ = (real_T)ssGetT(chartInstance->S);
_SFD_CC_CALL(CHART_ENTER_SFUNCTION_TAG, 16U, chartInstance->c17_sfEvent);
_SFD_DATA_RANGE_CHECK(*c17_b_alpha_pi, 0U);
_SFD_DATA_RANGE_CHECK(*c17_b_alpha_inf, 1U);
_SFD_DATA_RANGE_CHECK(*c17_b_accumulation, 2U);
chartInstance->c17_sfEvent = CALL_EVENT;
_SFD_CC_CALL(CHART_ENTER_DURING_FUNCTION_TAG, 16U, chartInstance->c17_sfEvent);
c17_hoistedGlobal = *c17_b_alpha_pi;
c17_b_hoistedGlobal = *c17_b_accumulation;
c17_alpha_pi = c17_hoistedGlobal;
c17_accumulation = c17_b_hoistedGlobal;
_SFD_SYMBOL_SCOPE_PUSH_EML(0U, 6U, 6U, c17_debug_family_names,
c17_debug_family_var_map);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c17_sgn, 0U, c17_sf_marshallOut,
c17_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c17_nargin, 1U, c17_sf_marshallOut,
c17_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c17_nargout, 2U, c17_sf_marshallOut,
c17_sf_marshallIn);
_SFD_SYMBOL_SCOPE_ADD_EML(&c17_alpha_pi, 3U, c17_sf_marshallOut);
_SFD_SYMBOL_SCOPE_ADD_EML(&c17_accumulation, 4U, c17_sf_marshallOut);
_SFD_SYMBOL_SCOPE_ADD_EML_IMPORTABLE(&c17_alpha_inf, 5U, c17_sf_marshallOut,
c17_sf_marshallIn);
CV_EML_FCN(0, 0);
_SFD_EML_CALL(0U, chartInstance->c17_sfEvent, 4);
c17_alpha_inf = c17_alpha_pi;
_SFD_EML_CALL(0U, chartInstance->c17_sfEvent, 5);
do {
exitg1 = 0;
c17_x = c17_accumulation - c17_alpha_inf;
c17_b_x = c17_x;
c17_y = muDoubleScalarAbs(c17_b_x);
if (CV_EML_WHILE(0, 1, 0, c17_y > 3.1415926535897931)) {
_SFD_EML_CALL(0U, chartInstance->c17_sfEvent, 7);
c17_c_x = c17_accumulation - c17_alpha_inf;
c17_sgn = c17_c_x;
c17_d_x = c17_sgn;
c17_sgn = c17_d_x;
c17_sgn = muDoubleScalarSign(c17_sgn);
_SFD_EML_CALL(0U, chartInstance->c17_sfEvent, 8);
c17_a = c17_sgn;
c17_b_y = c17_a * 2.0;
c17_b_a = c17_b_y;
c17_c_y = c17_b_a * 3.1415926535897931;
c17_alpha_inf += c17_c_y;
_SFD_EML_CALL(0U, chartInstance->c17_sfEvent, 5);
_SF_MEX_LISTEN_FOR_CTRL_C(chartInstance->S);
} else {
exitg1 = 1;
}
} while (exitg1 == 0);
_SFD_EML_CALL(0U, chartInstance->c17_sfEvent, -8);
_SFD_SYMBOL_SCOPE_POP();
*c17_b_alpha_inf = c17_alpha_inf;
_SFD_CC_CALL(EXIT_OUT_OF_FUNCTION_TAG, 16U, chartInstance->c17_sfEvent);
_SFD_CHECK_FOR_STATE_INCONSISTENCY(_HIL_model_errorMachineNumber_,
chartInstance->chartNumber, chartInstance->instanceNumber);
}
static void c_eml_qrsolve(const emlrtStack *sp, const emxArray_real_T *A,
emxArray_real_T *B, emxArray_real_T *Y)
{
emxArray_real_T *b_A;
emxArray_real_T *work;
int32_T mn;
int32_T i51;
int32_T ix;
emxArray_real_T *tau;
emxArray_int32_T *jpvt;
int32_T m;
int32_T n;
int32_T b_mn;
emxArray_real_T *vn1;
emxArray_real_T *vn2;
int32_T k;
boolean_T overflow;
boolean_T b12;
int32_T i;
int32_T i_i;
int32_T nmi;
int32_T mmi;
int32_T pvt;
int32_T iy;
boolean_T b13;
real_T xnorm;
int32_T i52;
real_T atmp;
real_T d16;
boolean_T b14;
boolean_T b_i;
ptrdiff_t n_t;
ptrdiff_t incx_t;
double * xix0_t;
boolean_T exitg1;
const mxArray *y;
static const int32_T iv78[2] = { 1, 8 };
const mxArray *m14;
char_T cv76[8];
static const char_T cv77[8] = { '%', '%', '%', 'd', '.', '%', 'd', 'e' };
char_T cv78[14];
uint32_T unnamed_idx_0;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
emlrtStack e_st;
emlrtStack f_st;
emlrtStack g_st;
emlrtStack h_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &c_st;
d_st.tls = c_st.tls;
e_st.prev = &d_st;
e_st.tls = d_st.tls;
f_st.prev = &e_st;
f_st.tls = e_st.tls;
g_st.prev = &f_st;
g_st.tls = f_st.tls;
h_st.prev = &g_st;
h_st.tls = g_st.tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
emxInit_real_T(sp, &b_A, 2, &m_emlrtRTEI, true);
b_emxInit_real_T(sp, &work, 1, &rb_emlrtRTEI, true);
mn = (int32_T)muDoubleScalarMin(A->size[0], A->size[1]);
st.site = &mc_emlrtRSI;
b_st.site = &nc_emlrtRSI;
c_st.site = &oc_emlrtRSI;
i51 = b_A->size[0] * b_A->size[1];
b_A->size[0] = A->size[0];
b_A->size[1] = A->size[1];
emxEnsureCapacity(&c_st, (emxArray__common *)b_A, i51, (int32_T)sizeof(real_T),
&m_emlrtRTEI);
ix = A->size[0] * A->size[1];
for (i51 = 0; i51 < ix; i51++) {
b_A->data[i51] = A->data[i51];
}
b_emxInit_real_T(&c_st, &tau, 1, &m_emlrtRTEI, true);
b_emxInit_int32_T(&c_st, &jpvt, 2, &m_emlrtRTEI, true);
m = b_A->size[0];
n = b_A->size[1];
b_mn = muIntScalarMin_sint32(b_A->size[0], b_A->size[1]);
i51 = tau->size[0];
tau->size[0] = b_mn;
emxEnsureCapacity(&c_st, (emxArray__common *)tau, i51, (int32_T)sizeof(real_T),
&n_emlrtRTEI);
d_st.site = &mf_emlrtRSI;
e_st.site = &rb_emlrtRSI;
f_st.site = &sb_emlrtRSI;
g_st.site = &tb_emlrtRSI;
eml_signed_integer_colon(&g_st, b_A->size[1], jpvt);
if ((b_A->size[0] == 0) || (b_A->size[1] == 0)) {
} else {
ix = b_A->size[1];
i51 = work->size[0];
work->size[0] = ix;
emxEnsureCapacity(&c_st, (emxArray__common *)work, i51, (int32_T)sizeof
(real_T), &m_emlrtRTEI);
for (i51 = 0; i51 < ix; i51++) {
work->data[i51] = 0.0;
}
b_emxInit_real_T(&c_st, &vn1, 1, &pb_emlrtRTEI, true);
b_emxInit_real_T(&c_st, &vn2, 1, &qb_emlrtRTEI, true);
d_st.site = &tc_emlrtRSI;
ix = b_A->size[1];
i51 = vn1->size[0];
vn1->size[0] = ix;
emxEnsureCapacity(&c_st, (emxArray__common *)vn1, i51, (int32_T)sizeof
(real_T), &pb_emlrtRTEI);
i51 = vn2->size[0];
vn2->size[0] = ix;
emxEnsureCapacity(&c_st, (emxArray__common *)vn2, i51, (int32_T)sizeof
(real_T), &qb_emlrtRTEI);
k = 1;
d_st.site = &nf_emlrtRSI;
overflow = (b_A->size[1] > 2147483646);
if (overflow) {
e_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&e_st);
}
for (ix = 0; ix + 1 <= b_A->size[1]; ix++) {
d_st.site = &sc_emlrtRSI;
vn1->data[ix] = b_eml_xnrm2(&d_st, b_A->size[0], b_A, k);
vn2->data[ix] = vn1->data[ix];
k += b_A->size[0];
}
d_st.site = &rc_emlrtRSI;
if (1 > b_mn) {
b12 = false;
} else {
b12 = (b_mn > 2147483646);
}
if (b12) {
e_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&e_st);
}
for (i = 1; i <= b_mn; i++) {
i_i = (i + (i - 1) * m) - 1;
nmi = n - i;
mmi = m - i;
d_st.site = &of_emlrtRSI;
ix = eml_ixamax(&d_st, 1 + nmi, vn1, i);
pvt = (i + ix) - 2;
if (pvt + 1 != i) {
d_st.site = &pf_emlrtRSI;
e_st.site = &bc_emlrtRSI;
f_st.site = &cc_emlrtRSI;
ix = 1 + m * pvt;
iy = 1 + m * (i - 1);
g_st.site = &dc_emlrtRSI;
if (1 > m) {
b13 = false;
} else {
b13 = (m > 2147483646);
}
if (b13) {
h_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&h_st);
}
for (k = 1; k <= m; k++) {
i51 = b_A->size[0] * b_A->size[1];
xnorm = b_A->data[emlrtDynamicBoundsCheckFastR2012b(ix, 1, i51,
&le_emlrtBCI, &f_st) - 1];
i51 = b_A->size[0] * b_A->size[1];
i52 = b_A->size[0] * b_A->size[1];
b_A->data[emlrtDynamicBoundsCheckFastR2012b(ix, 1, i51, &le_emlrtBCI,
&f_st) - 1] = b_A->data[emlrtDynamicBoundsCheckFastR2012b(iy, 1, i52,
&le_emlrtBCI, &f_st) - 1];
i51 = b_A->size[0] * b_A->size[1];
b_A->data[emlrtDynamicBoundsCheckFastR2012b(iy, 1, i51, &le_emlrtBCI,
&f_st) - 1] = xnorm;
ix++;
iy++;
}
ix = jpvt->data[pvt];
jpvt->data[pvt] = jpvt->data[i - 1];
jpvt->data[i - 1] = ix;
vn1->data[pvt] = vn1->data[i - 1];
vn2->data[pvt] = vn2->data[i - 1];
}
if (i < m) {
d_st.site = &qc_emlrtRSI;
atmp = b_A->data[i_i];
d16 = 0.0;
if (1 + mmi <= 0) {
} else {
e_st.site = &wc_emlrtRSI;
xnorm = b_eml_xnrm2(&e_st, mmi, b_A, i_i + 2);
if (xnorm != 0.0) {
xnorm = muDoubleScalarHypot(b_A->data[i_i], xnorm);
if (b_A->data[i_i] >= 0.0) {
xnorm = -xnorm;
}
if (muDoubleScalarAbs(xnorm) < 1.0020841800044864E-292) {
ix = 0;
do {
ix++;
e_st.site = &xc_emlrtRSI;
b_eml_xscal(&e_st, mmi, 9.9792015476736E+291, b_A, i_i + 2);
xnorm *= 9.9792015476736E+291;
atmp *= 9.9792015476736E+291;
} while (!(muDoubleScalarAbs(xnorm) >= 1.0020841800044864E-292));
e_st.site = &yc_emlrtRSI;
xnorm = b_eml_xnrm2(&e_st, mmi, b_A, i_i + 2);
xnorm = muDoubleScalarHypot(atmp, xnorm);
if (atmp >= 0.0) {
xnorm = -xnorm;
}
d16 = (xnorm - atmp) / xnorm;
e_st.site = &ad_emlrtRSI;
b_eml_xscal(&e_st, mmi, 1.0 / (atmp - xnorm), b_A, i_i + 2);
e_st.site = &bd_emlrtRSI;
if (1 > ix) {
b14 = false;
} else {
b14 = (ix > 2147483646);
}
if (b14) {
f_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&f_st);
}
for (k = 1; k <= ix; k++) {
xnorm *= 1.0020841800044864E-292;
}
atmp = xnorm;
} else {
d16 = (xnorm - b_A->data[i_i]) / xnorm;
atmp = 1.0 / (b_A->data[i_i] - xnorm);
e_st.site = &cd_emlrtRSI;
b_eml_xscal(&e_st, mmi, atmp, b_A, i_i + 2);
atmp = xnorm;
}
}
}
tau->data[i - 1] = d16;
} else {
atmp = b_A->data[i_i];
d_st.site = &pc_emlrtRSI;
tau->data[i - 1] = eml_matlab_zlarfg();
}
b_A->data[i_i] = atmp;
if (i < n) {
atmp = b_A->data[i_i];
b_A->data[i_i] = 1.0;
d_st.site = &qf_emlrtRSI;
eml_matlab_zlarf(&d_st, mmi + 1, nmi, i_i + 1, tau->data[i - 1], b_A, i
+ i * m, m, work);
b_A->data[i_i] = atmp;
}
d_st.site = &rf_emlrtRSI;
if (i + 1 > n) {
b_i = false;
} else {
b_i = (n > 2147483646);
}
if (b_i) {
e_st.site = &db_emlrtRSI;
check_forloop_overflow_error(&e_st);
}
for (ix = i; ix + 1 <= n; ix++) {
if (vn1->data[ix] != 0.0) {
xnorm = muDoubleScalarAbs(b_A->data[(i + b_A->size[0] * ix) - 1]) /
vn1->data[ix];
xnorm = 1.0 - xnorm * xnorm;
if (xnorm < 0.0) {
xnorm = 0.0;
}
atmp = vn1->data[ix] / vn2->data[ix];
atmp = xnorm * (atmp * atmp);
if (atmp <= 1.4901161193847656E-8) {
if (i < m) {
d_st.site = &sf_emlrtRSI;
e_st.site = &uc_emlrtRSI;
if (mmi < 1) {
xnorm = 0.0;
} else {
f_st.site = &vc_emlrtRSI;
g_st.site = &vc_emlrtRSI;
n_t = (ptrdiff_t)(mmi);
g_st.site = &vc_emlrtRSI;
incx_t = (ptrdiff_t)(1);
i51 = b_A->size[0] * b_A->size[1];
i52 = (i + m * ix) + 1;
xix0_t = (double *)(&b_A->data[emlrtDynamicBoundsCheckFastR2012b
(i52, 1, i51, &vb_emlrtBCI, &f_st) - 1]);
xnorm = dnrm2(&n_t, xix0_t, &incx_t);
}
vn1->data[ix] = xnorm;
vn2->data[ix] = vn1->data[ix];
} else {
vn1->data[ix] = 0.0;
vn2->data[ix] = 0.0;
}
} else {
d_st.site = &tf_emlrtRSI;
vn1->data[ix] *= muDoubleScalarSqrt(xnorm);
}
}
}
}
emxFree_real_T(&vn2);
emxFree_real_T(&vn1);
}
atmp = 0.0;
if (mn > 0) {
xnorm = muDoubleScalarMax(A->size[0], A->size[1]) * muDoubleScalarAbs
(b_A->data[0]) * 2.2204460492503131E-16;
k = 0;
exitg1 = false;
while ((!exitg1) && (k <= mn - 1)) {
if (muDoubleScalarAbs(b_A->data[k + b_A->size[0] * k]) <= xnorm) {
st.site = &lc_emlrtRSI;
y = NULL;
m14 = emlrtCreateCharArray(2, iv78);
for (i = 0; i < 8; i++) {
cv76[i] = cv77[i];
}
emlrtInitCharArrayR2013a(&st, 8, m14, cv76);
emlrtAssign(&y, m14);
b_st.site = &tg_emlrtRSI;
emlrt_marshallIn(&b_st, c_sprintf(&b_st, b_sprintf(&b_st, y,
emlrt_marshallOut(14.0), emlrt_marshallOut(6.0), &o_emlrtMCI),
emlrt_marshallOut(xnorm), &p_emlrtMCI), "sprintf", cv78);
st.site = &kc_emlrtRSI;
b_eml_warning(&st, atmp, cv78);
exitg1 = true;
} else {
atmp++;
k++;
}
}
}
unnamed_idx_0 = (uint32_T)A->size[1];
i51 = Y->size[0];
Y->size[0] = (int32_T)unnamed_idx_0;
emxEnsureCapacity(sp, (emxArray__common *)Y, i51, (int32_T)sizeof(real_T),
&m_emlrtRTEI);
ix = (int32_T)unnamed_idx_0;
for (i51 = 0; i51 < ix; i51++) {
Y->data[i51] = 0.0;
}
for (ix = 0; ix < mn; ix++) {
if (tau->data[ix] != 0.0) {
xnorm = B->data[ix];
i51 = A->size[0] + (int32_T)(1.0 - ((1.0 + (real_T)ix) + 1.0));
emlrtForLoopVectorCheckR2012b((1.0 + (real_T)ix) + 1.0, 1.0, A->size[0],
mxDOUBLE_CLASS, i51, &ac_emlrtRTEI, sp);
for (i = 0; i < i51; i++) {
unnamed_idx_0 = ((uint32_T)ix + i) + 2U;
xnorm += b_A->data[((int32_T)unnamed_idx_0 + b_A->size[0] * ix) - 1] *
B->data[(int32_T)unnamed_idx_0 - 1];
}
xnorm *= tau->data[ix];
if (xnorm != 0.0) {
B->data[ix] -= xnorm;
i51 = A->size[0] + (int32_T)(1.0 - ((1.0 + (real_T)ix) + 1.0));
emlrtForLoopVectorCheckR2012b((1.0 + (real_T)ix) + 1.0, 1.0, A->size[0],
mxDOUBLE_CLASS, i51, &yb_emlrtRTEI, sp);
for (i = 0; i < i51; i++) {
unnamed_idx_0 = ((uint32_T)ix + i) + 2U;
B->data[(int32_T)unnamed_idx_0 - 1] -= b_A->data[((int32_T)
unnamed_idx_0 + b_A->size[0] * ix) - 1] * xnorm;
}
}
}
}
emxFree_real_T(&tau);
emlrtForLoopVectorCheckR2012b(1.0, 1.0, atmp, mxDOUBLE_CLASS, (int32_T)atmp,
&xb_emlrtRTEI, sp);
for (i = 0; i < (int32_T)atmp; i++) {
Y->data[jpvt->data[i] - 1] = B->data[i];
}
emlrtForLoopVectorCheckR2012b(atmp, -1.0, 1.0, mxDOUBLE_CLASS, (int32_T)-(1.0
+ (-1.0 - atmp)), &wb_emlrtRTEI, sp);
for (ix = 0; ix < (int32_T)-(1.0 + (-1.0 - atmp)); ix++) {
xnorm = atmp + -(real_T)ix;
Y->data[jpvt->data[(int32_T)xnorm - 1] - 1] = eml_div(Y->data[jpvt->data
[(int32_T)xnorm - 1] - 1], b_A->data[((int32_T)xnorm + b_A->size[0] *
((int32_T)xnorm - 1)) - 1]);
for (i = 0; i < (int32_T)(xnorm - 1.0); i++) {
Y->data[jpvt->data[i] - 1] -= Y->data[jpvt->data[(int32_T)xnorm - 1] - 1] *
b_A->data[i + b_A->size[0] * ((int32_T)xnorm - 1)];
}
}
emxFree_int32_T(&jpvt);
emxFree_real_T(&work);
emxFree_real_T(&b_A);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
}
