/* Function Definitions */
void Cone(const emlrtStack *sp, real_T k, const emxArray_real_T *x, const
emxArray_real_T *gridX, const emxArray_real_T *t, emxArray_real_T
*vals)
{
int32_T t_idx_0;
int32_T i49;
int32_T l;
int32_T i50;
int32_T i51;
int32_T i52;
int32_T i53;
int32_T i54;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
/* calculate the matrix Cone for a specific space point x_k, for all times */
/* t_i in A */
/* points x_k=1:numel(spacePoints) */
t_idx_0 = t->size[1];
i49 = vals->size[0] * vals->size[1];
vals->size[0] = t_idx_0;
emxEnsureCapacity(sp, (emxArray__common *)vals, i49, (int32_T)sizeof(real_T),
&v_emlrtRTEI);
t_idx_0 = x->size[1];
i49 = vals->size[0] * vals->size[1];
vals->size[1] = t_idx_0;
emxEnsureCapacity(sp, (emxArray__common *)vals, i49, (int32_T)sizeof(real_T),
&v_emlrtRTEI);
t_idx_0 = t->size[1] * x->size[1];
for (i49 = 0; i49 < t_idx_0; i49++) {
vals->data[i49] = 0.0;
}
t_idx_0 = 1;
while (t_idx_0 - 1 <= t->size[1] - 1) {
l = 0;
while (l <= x->size[1] - 1) {
i49 = vals->size[0];
i50 = vals->size[1];
i51 = 1 + l;
i52 = x->size[1];
i53 = (int32_T)emlrtIntegerCheckFastR2012b(k, &nb_emlrtDCI, sp);
i54 = t->size[1];
st.site = &le_emlrtRSI;
vals->data[(emlrtDynamicBoundsCheckFastR2012b(t_idx_0, 1, i49,
&je_emlrtBCI, sp) + vals->size[0] * (emlrtDynamicBoundsCheckFastR2012b
(i51, 1, i50, &ke_emlrtBCI, sp) - 1)) - 1] = b_Ccoeff(&st, 1.0 + (real_T)
l, x->data[emlrtDynamicBoundsCheckFastR2012b(i53, 1, i52, &le_emlrtBCI,
sp) - 1], t->data[emlrtDynamicBoundsCheckFastR2012b(t_idx_0, 1, i54,
&me_emlrtBCI, sp) - 1], gridX);
l++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
t_idx_0++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
}
real_T b_Dcoeff(const emlrtStack *sp, const real_T y[3], real_T j, real_T x,
real_T t, const emxArray_real_T *timePoints)
{
real_T vals;
real_T a[3];
int32_T aIdx;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
/* Calculate the integral int_0^1(f(y,t_j)*A_{yj}(x,t)dy) by midpoint */
/* integration rule */
/* the spatial integration of all points y at time t_j */
for (aIdx = 0; aIdx < 3; aIdx++) {
a[aIdx] = 0.0;
}
vals = 0.0;
st.site = &q_emlrtRSI;
a[0] = Acoeff(&st, y[0], j, x, t, timePoints);
for (aIdx = 0; aIdx < 2; aIdx++) {
st.site = &r_emlrtRSI;
a[aIdx + 1] = Acoeff(&st, y[aIdx + 1], j, x, t, timePoints);
vals += 0.5 * (a[aIdx + 1] + a[aIdx]) * (y[aIdx + 1] - y[aIdx]);
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
return vals;
}
/* Function Definitions */
void PHYTransmit(testPHYTransmitStackData *SD, comm_SDRuTransmitter
*b_ObjSDRuTransmitter)
{
OFDMDemodulator *unusedU1;
OFDMDemodulator_1 *unusedU0;
OFDMDemodulator_1 b_unusedU0;
OFDMDemodulator b_unusedU1;
int32_T framesTransmitted;
/* Send Messages */
/* % Create message bits */
/* The output needs to be duplicated to long vectors to help prevent */
/* Underflow for the USRP */
emlrtPushRtStackR2012b(&ve_emlrtRSI, emlrtRootTLSGlobal);
b_generateOFDMSignal_TX2(&b_unusedU1, &b_unusedU0, &unusedU0, &unusedU1,
SD->u2.f4.dataToTx, &SD->u2.f4.unusedU2);
emlrtPopRtStackR2012b(&ve_emlrtRSI, emlrtRootTLSGlobal);
/* 30 Dupe frames created (NOTE! author shouldcreate shorter simpler function) */
/* % Run transmitter */
/* increasing value will help receiver, 10 */
/* This should be longer to help transmit over periods when the RX is */
/* cleaning its buffer */
for (framesTransmitted = 0; framesTransmitted < 10; framesTransmitted++) {
emlrtPushRtStackR2012b(&ue_emlrtRSI, emlrtRootTLSGlobal);
g_SystemCore_step(SD, b_ObjSDRuTransmitter, SD->u2.f4.dataToTx);
emlrtPopRtStackR2012b(&ue_emlrtRSI, emlrtRootTLSGlobal);
/* if mod(framesTransmitted,60) == 0 */
/* end */
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal);
}
/* obj.pSDRuTransmitter.reset;%stop transmitting? */
}
/* Function Definitions */
void PHYTransmit(testMACRouterStackData *SD, const emlrtStack *sp,
comm_SDRuTransmitter *ObjSDRuTransmitter, comm_SDRuReceiver
*ObjSDRuReceiver, real_T originNodeID, real_T destNodeID)
{
OFDMDemodulator_2 *unusedU1;
OFDMDemodulator_3 *unusedU0;
OFDMDemodulator_3 b_unusedU0;
OFDMDemodulator_2 b_unusedU1;
int32_T framesTransmitted;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
/* Send Messages */
/* % Create message bits */
/* The output needs to be duplicated to long vectors to help prevent */
/* Underflow for the USRP */
st.site = &wu_emlrtRSI;
b_generateOFDMSignal_TX2(&st, originNodeID, destNodeID, &b_unusedU1,
&b_unusedU0, &unusedU0, &unusedU1, SD->u2.f7.dataToTx, &SD->u2.f7.unusedU2);
/* 30 Dupe frames created (NOTE! author shouldcreate shorter simpler function) */
/* % Run transmitter */
/* increasing value will help receiver, 10 */
/* This should be longer to help transmit over periods when the RX is */
/* cleaning its buffer */
for (framesTransmitted = 0; framesTransmitted < 10; framesTransmitted++) {
st.site = &uu_emlrtRSI;
i_SystemCore_step(SD, &st, ObjSDRuTransmitter, SD->u2.f7.dataToTx);
/* if mod(framesTransmitted,60) == 0 */
st.site = &vu_emlrtRSI;
j_SystemCore_step(SD, &st, ObjSDRuReceiver);
/* Call used to prevent Overflow. Essentially will clean up receive buffer, will be filled with crosstalk frames */
/* end */
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* obj.pSDRuTransmitter.reset;%stop transmitting? */
}
/* Function Definitions */
void CalculateHeatSolution(const emlrtStack *sp, real_T N0, real_T N, const
emxArray_real_T *t, const emxArray_real_T *gridT, const emxArray_real_T *x,
const emxArray_real_T *u0, const emxArray_real_T *q0j, const emxArray_real_T
*q1j, const emxArray_real_T *h0j, const emxArray_real_T *h1j, const
emxArray_real_T *f, const emxArray_real_T *r, emxArray_real_T *u)
{
emxArray_real_T *eta;
int32_T i12;
real_T sTime;
int32_T loop_ub;
int32_T i13;
int32_T j;
emxArray_real_T *b_f;
int32_T i;
real_T sSpace;
int32_T tIdx;
int32_T b_i;
int32_T i14;
int32_T i15;
int32_T i16;
int32_T i17;
int32_T i18;
int32_T i19;
int32_T i20;
int32_T i21;
int32_T i22;
int32_T i23;
int32_T i24;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = sp;
b_st.tls = sp->tls;
c_st.prev = sp;
c_st.tls = sp->tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
emxInit_real_T(sp, &eta, 2, &f_emlrtRTEI, true);
/* get the solution for the inverse heat source, u(x,t), */
/* N0 - number of space points */
/* N - number of time points */
/* t - time points */
/* gridT - time points grid */
/* x space points */
/* q0j flux at x=0 du/dn */
/* q1j flux at x=1 du/dn */
/* h0j boundary condition u(0,t) */
/* u1j boundary condition u(1,t) */
/* f multiplier of the source f(x,t)r(t) size[N N0] */
/* r calculated source term size [N,1] */
i12 = eta->size[0] * eta->size[1];
eta->size[0] = 1;
sTime = emlrtNonNegativeCheckFastR2012b(N0, &eb_emlrtDCI, sp);
eta->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(sTime, &db_emlrtDCI, sp);
emxEnsureCapacity(sp, (emxArray__common *)eta, i12, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
sTime = emlrtNonNegativeCheckFastR2012b(N0, &eb_emlrtDCI, sp);
loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(sTime, &db_emlrtDCI, sp);
for (i12 = 0; i12 < loop_ub; i12++) {
eta->data[i12] = 1.0;
}
i12 = (int32_T)N0;
emlrtDynamicBoundsCheckFastR2012b(1, 1, i12, &tc_emlrtBCI, sp);
eta->data[0] = 0.5;
i12 = (int32_T)N0;
i13 = (int32_T)N0;
eta->data[emlrtDynamicBoundsCheckFastR2012b(i13, 1, i12, &uc_emlrtBCI, sp) - 1]
= 0.5;
i12 = u->size[0] * u->size[1];
sTime = emlrtNonNegativeCheckFastR2012b(N, &gb_emlrtDCI, sp);
u->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(sTime, &fb_emlrtDCI, sp);
u->size[1] = (int32_T)N0;
emxEnsureCapacity(sp, (emxArray__common *)u, i12, (int32_T)sizeof(real_T),
&e_emlrtRTEI);
sTime = emlrtNonNegativeCheckFastR2012b(N, &gb_emlrtDCI, sp);
loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(sTime, &fb_emlrtDCI, sp) *
(int32_T)N0;
for (i12 = 0; i12 < loop_ub; i12++) {
u->data[i12] = 0.0;
}
j = 1;
emxInit_real_T(sp, &b_f, 2, &e_emlrtRTEI, true);
while (j - 1 <= (int32_T)N0 - 1) {
/* space index */
emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N,
&gc_emlrtRTEI, sp);
i = 1;
while (i - 1 <= (int32_T)N - 1) {
/* time index */
sTime = 0.0;
/* cumulative sums */
sSpace = 0.0;
emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N,
&hc_emlrtRTEI, sp);
tIdx = 0;
while (tIdx <= (int32_T)N - 1) {
/* time index */
loop_ub = f->size[1];
i12 = f->size[0];
b_i = emlrtDynamicBoundsCheckFastR2012b(i, 1, i12, &sc_emlrtBCI, sp);
i12 = b_f->size[0] * b_f->size[1];
b_f->size[0] = 1;
b_f->size[1] = loop_ub;
emxEnsureCapacity(sp, (emxArray__common *)b_f, i12, (int32_T)sizeof
(real_T), &e_emlrtRTEI);
for (i12 = 0; i12 < loop_ub; i12++) {
b_f->data[b_f->size[0] * i12] = f->data[(b_i + f->size[0] * i12) - 1];
}
i12 = x->size[1];
i13 = t->size[1];
i14 = q0j->size[0];
i15 = x->size[1];
loop_ub = t->size[1];
b_i = q1j->size[0];
i16 = x->size[1];
i17 = t->size[1];
i18 = h0j->size[0];
i19 = x->size[1];
i20 = t->size[1];
i21 = h1j->size[0];
i22 = x->size[1];
i23 = t->size[1];
i24 = r->size[0];
st.site = &bb_emlrtRSI;
b_st.site = &cb_emlrtRSI;
c_st.site = &db_emlrtRSI;
sTime = ((((sTime + Acoeff(&st, 0.0, 1.0 + (real_T)tIdx, x->
data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i12, &cd_emlrtBCI, sp) -
1], t->data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i13, &dd_emlrtBCI,
sp) - 1], gridT) * q0j->data[emlrtDynamicBoundsCheckFastR2012b(tIdx +
1, 1, i14, &ed_emlrtBCI, sp) - 1]) + Acoeff(&st, 1.0, 1.0 + (real_T)
tIdx, x->data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i15,
&fd_emlrtBCI, sp) - 1], t->data[emlrtDynamicBoundsCheckFastR2012b(i, 1,
loop_ub, &gd_emlrtBCI, sp) - 1], gridT) * q1j->
data[emlrtDynamicBoundsCheckFastR2012b(tIdx + 1, 1, b_i,
&hd_emlrtBCI, sp) - 1]) - Bcoeff(&b_st, 0.0, 1.0 + (real_T)
tIdx, x->data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i16,
&id_emlrtBCI, sp) - 1], t->
data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i17,
&jd_emlrtBCI, sp) - 1], gridT) * h0j->
data[emlrtDynamicBoundsCheckFastR2012b(tIdx + 1, 1, i18,
&kd_emlrtBCI, sp) - 1]) - Bcoeff(&b_st, 1.0, 1.0 + (real_T)
tIdx, x->data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i19,
&ld_emlrtBCI, sp) - 1], t->
data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i20, &md_emlrtBCI,
sp) - 1], gridT) * h1j->
data[emlrtDynamicBoundsCheckFastR2012b(tIdx + 1, 1, i21,
&nd_emlrtBCI, sp) - 1]) + b_Dcoeff(&c_st, x, 1.0 + (real_T)
tIdx, x->data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i22,
&od_emlrtBCI, sp) - 1], t->data[emlrtDynamicBoundsCheckFastR2012b(i, 1,
i23, &pd_emlrtBCI, sp) - 1], gridT, b_f) * r->
data[emlrtDynamicBoundsCheckFastR2012b(tIdx + 1, 1, i24, &qd_emlrtBCI,
sp) - 1];
tIdx++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
loop_ub = 0;
while (loop_ub <= (int32_T)N0 - 1) {
/* space index */
i12 = x->size[1];
i13 = t->size[1];
i14 = u0->size[1];
i15 = 1 + loop_ub;
st.site = &eb_emlrtRSI;
sSpace += b_Ccoeff(&st, 1.0 + (real_T)loop_ub, x->
data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i12,
&yc_emlrtBCI, sp) - 1], t->data[emlrtDynamicBoundsCheckFastR2012b(i, 1,
i13, &ad_emlrtBCI, sp) - 1], gridT) * u0->
data[emlrtDynamicBoundsCheckFastR2012b(i15, 1, i14, &bd_emlrtBCI, sp)
- 1];
loop_ub++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
i12 = u->size[0];
i13 = u->size[1];
i14 = eta->size[1];
u->data[(emlrtDynamicBoundsCheckFastR2012b(i, 1, i12, &vc_emlrtBCI, sp) +
u->size[0] * (emlrtDynamicBoundsCheckFastR2012b(j, 1, i13,
&wc_emlrtBCI, sp) - 1)) - 1] = (sTime + sSpace) * eta->
data[emlrtDynamicBoundsCheckFastR2012b(j, 1, i14, &xc_emlrtBCI, sp) - 1];
i++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
j++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
emxFree_real_T(&b_f);
emxFree_real_T(&eta);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
}
void OFDMletters2bits(const emlrtStack *sp, const char_T str[80], real_T f[560])
{
int32_T bits_size_idx_1;
char_T bits_data[1280];
int32_T i2;
int32_T firstcol;
int32_T j;
boolean_T exitg1;
boolean_T p;
int32_T i;
boolean_T exitg2;
char_T b_bits_data[1280];
const mxArray *y;
const mxArray *m4;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
/* Encode a string of ASCII text into bits(1,0) */
st.site = &hf_emlrtRSI;
bits_size_idx_1 = 16;
for (i2 = 0; i2 < 1280; i2++) {
bits_data[i2] = '0';
}
for (firstcol = 0; firstcol < 80; firstcol++) {
for (j = 0; j < 16; j++) {
if (((uint8_T)str[firstcol] & 1 << j) != 0) {
bits_data[firstcol + 80 * (15 - j)] = '1';
}
}
}
firstcol = 16;
j = 1;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (j <= 15)) {
p = FALSE;
i = 0;
exitg2 = FALSE;
while ((exitg2 == FALSE) && (i <= 79)) {
if (bits_data[i + 80 * (j - 1)] != '0') {
p = TRUE;
exitg2 = TRUE;
} else {
i++;
}
}
if (p) {
firstcol = j;
exitg1 = TRUE;
} else {
j++;
}
}
if (firstcol > 1) {
for (j = firstcol; j < 17; j++) {
for (i = 0; i < 80; i++) {
bits_data[i + 80 * (j - firstcol)] = bits_data[i + 80 * (j - 1)];
}
}
j = 17 - firstcol;
for (i2 = 0; i2 < j; i2++) {
memcpy(&b_bits_data[80 * i2], &bits_data[80 * i2], 80U * sizeof(char_T));
}
bits_size_idx_1 = 17 - firstcol;
j = 17 - firstcol;
for (i2 = 0; i2 < j; i2++) {
memcpy(&bits_data[80 * i2], &b_bits_data[80 * i2], 80U * sizeof(char_T));
}
}
for (firstcol = 0; firstcol < 80; firstcol++) {
for (i = 0; i < 7; i++) {
i2 = 1 + i;
emlrtDynamicBoundsCheckFastR2012b(i2, 1, bits_size_idx_1, &c_emlrtBCI, sp);
y = NULL;
m4 = emlrtCreateString1(bits_data[firstcol + 80 * i]);
emlrtAssign(&y, m4);
st.site = &er_emlrtRSI;
f[firstcol + 80 * i] = emlrt_marshallIn(&st, str2double(&st, y,
&b_emlrtMCI), "str2double");
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
}
void b_OFDMletters2bits(const emlrtStack *sp, real_T f[560])
{
int32_T bits_size_idx_1;
char_T bits_data[1280];
int32_T i14;
int32_T firstcol;
static const char_T cv93[80] = { 'L', 'i', 'v', 'e', ' ', 'l', 'o', 'n', 'g',
' ', 'a', 'n', 'd', ' ', 'p', 'r', 'o', 's', 'p', 'e', 'r', ',', ' ', 'f',
'r', 'o', 'm', ' ', 't', 'h', 'e', ' ', 'C', 'o', 'm', 'm', 'u', 'n', 'i',
'c', 'a', 't', 'i', 'o', 'n', 's', ' ', 'S', 'y', 's', 't', 'e', 'm', ' ',
'T', 'o', 'o', 'l', 'b', 'o', 'x', ' ', 'T', 'e', 'a', 'm', ' ', 'a', 't',
' ', 'M', 'a', 't', 'h', 'W', 'o', 'r', 'k', 's', '!' };
uint16_T dk;
int32_T j;
boolean_T exitg1;
boolean_T p;
int32_T i;
boolean_T exitg2;
char_T b_bits_data[1280];
const mxArray *y;
const mxArray *m12;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
/* Encode a string of ASCII text into bits(1,0) */
st.site = &hf_emlrtRSI;
bits_size_idx_1 = 16;
for (i14 = 0; i14 < 1280; i14++) {
bits_data[i14] = '0';
}
for (firstcol = 0; firstcol < 80; firstcol++) {
dk = (uint16_T)cv93[firstcol];
for (j = 0; j < 16; j++) {
if ((dk & 1 << j) != 0) {
bits_data[firstcol + 80 * (15 - j)] = '1';
}
}
}
firstcol = 16;
j = 1;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (j <= 15)) {
p = FALSE;
i = 0;
exitg2 = FALSE;
while ((exitg2 == FALSE) && (i <= 79)) {
if (bits_data[i + 80 * (j - 1)] != '0') {
p = TRUE;
exitg2 = TRUE;
} else {
i++;
}
}
if (p) {
firstcol = j;
exitg1 = TRUE;
} else {
j++;
}
}
if (firstcol > 1) {
for (j = firstcol; j < 17; j++) {
for (i = 0; i < 80; i++) {
bits_data[i + 80 * (j - firstcol)] = bits_data[i + 80 * (j - 1)];
}
}
j = 17 - firstcol;
for (i14 = 0; i14 < j; i14++) {
memcpy(&b_bits_data[80 * i14], &bits_data[80 * i14], 80U * sizeof(char_T));
}
bits_size_idx_1 = 17 - firstcol;
j = 17 - firstcol;
for (i14 = 0; i14 < j; i14++) {
memcpy(&bits_data[80 * i14], &b_bits_data[80 * i14], 80U * sizeof(char_T));
}
}
for (firstcol = 0; firstcol < 80; firstcol++) {
for (i = 0; i < 7; i++) {
i14 = 1 + i;
emlrtDynamicBoundsCheckFastR2012b(i14, 1, bits_size_idx_1, &c_emlrtBCI, sp);
y = NULL;
m12 = emlrtCreateString1(bits_data[firstcol + 80 * i]);
emlrtAssign(&y, m12);
st.site = &er_emlrtRSI;
f[firstcol + 80 * i] = emlrt_marshallIn(&st, str2double(&st, y,
&b_emlrtMCI), "str2double");
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
}
void drr_151213_XRayInParam(const emlrtStack *sp, const emxArray_boolean_T
*voxel_data, const real_T voxel_size_mm[3], const real_T detector_dimensions[2],
const real_T XRayIntrinsicParam[12], const real_T voxel_corner_min[3], const
real_T T_carm[16], emxArray_real_T *projection)
{
const mxArray *y;
static const int32_T iv0[2] = { 1, 32 };
const mxArray *m0;
char_T cv0[32];
int32_T i;
static const char_T cv1[32] = { 'v', 'o', 'x', 'e', 'l', '_', 'd', 'a', 't',
'a', ' ', 'm', 'u', 's', 't', ' ', 'b', 'e', ' ', '3', '-', 'd', 'i', 'm',
'e', 'n', 's', 'i', 'o', 'n', 'a', 'l' };
int32_T i0;
real_T pixel_size_mm_h;
real_T pixel_size_mm_w;
uint32_T voxDim[3];
real_T voxPlanes__max[3];
real_T source[3];
real_T pixel_size_mmel_wn[3];
real_T pixel_size_mmel_hn[3];
real_T corner[3];
int32_T ih;
int32_T iw;
real_T tstep[3];
real_T tnext[3];
real_T pixel_point_mm[3];
real_T ray_source2pixel[3];
real_T b_voxPlanes__max[3];
real_T b_ray_source2pixel[3];
real_T t_plane_min[3];
real_T t_plane_max[3];
real_T tmax;
int32_T pixel_size_mmIntensity;
boolean_T exitg8;
boolean_T exitg7;
boolean_T exitg6;
real_T t_larger[4];
real_T temp;
boolean_T exitg5;
boolean_T exitg4;
boolean_T exitg3;
real_T t_smaller[4];
int32_T itmp;
boolean_T exitg2;
boolean_T exitg1;
real_T iz;
real_T tx;
real_T ty;
real_T tz;
int32_T i1;
int32_T i2;
int32_T i3;
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
/* % Modificiation Notes */
/* 15.12.04 */
/* - Release 기존의 파일을 참고로 하여 고성영이 수정하였음. */
/* - DRR을 완벽하게 하지 않고, voxel에 한점이라도 만나면 on으로 계산함 */
/* - 계산속도가 향상되었음 */
/* - 젬스에 있는 X-ray와 테스트하여 검증하였음 */
/* 15 12 13 : The function input has been changed to utilize the x-ray */
/* intrinsic parameter provided by GEMSS % 151213 kosy */
/* %function [projection] = drr (voxel_data, voxel_size_mm, detector_dimensions, pixel_size_mm, isocenter_mm, cbct_angles_deg) */
/* Creates a 2D projection at each cbct_angle of voxel_data. the projection */
/* axis is defined by the isocenter to which the source and center of */
/* the detector are aligned. This simulation assumes standard Cone Beam CT */
/* geometry (source to isocenter distance is 100 cm and source to detector */
/* distance is 150cm). */
/* */
/* voxel_data: must be a 3 dimensional matrix (typically of CT data) */
/* voxel_size_mm: a 3 element vector listing the size (in mm) of the voxels */
/* along each dimension */
/* detector_dimension: a 2 element vector listing the dimensions (number of */
/* pixels) in each dimension (u,v) */
/* pixel_size_mm: a number defining the height and width of each pixel */
/* (assumes square pixel) */
/* isocenter_mm: a 3 element vector pointing from the origin (corner) of the */
/* matrix element(1,1,1) to the isocenter */
/* cbct_angles_deg: a list of angles to generate projections */
/* */
/* Retrun Variable */
/* projection: a 3D matrix with the 3rd dimension representing the angle of */
/* roatation */
/* */
/* { */
/* Author: Michael M. Folkerts [email protected] */
/* Institution: UCSD Physics, UTSW Radiation Oncology */
/* Updated: 2014-July. */
/* Notes: Siddon's Incremental algorithm | modified to read in 3D matlab matrix | Simplified Input | No guarantees!! */
/* */
/* References: */
/* R.L. Siddon, */
/* "Fast calculation of the exact radiological path for a three-dimensional CT */
/* array," Medical Physics 12, 252-255 (1985). */
/* */
/* F. Jacobs, E. Sundermann, B. De Sutter, M. Christiaens and I. Lemahieu, */
/* "A fast algorithm to calculate the exact radiological path through a pixel_size_mmel or voxel space," */
/* Journal of Computing and Information Technology 6, 89-94 (1998). */
/* */
/* G. Han, Z. Liang and J. You, */
/* "A fast ray tracing technique for TCT and ECT studies," */
/* IEEE Medical Imaging Conference 1999. */
/* } */
/* function [projection] = drr_good_151204 (voxel_data, voxel_size_mm, detector_dimensions, pixel_size_mm, voxel_corner_min, T_carm) */
/* if(0) */
/* voxel_data = OUTPUTgrid; */
/* voxel_size_mm = voxel_size; */
/* detector_dimensions = detector_dimension; */
/* pixel_size_mm = pixel_size; */
/* isocenter_mm = isocenter; */
/* T_carm: Transformation matrix of C-arm (that is set at the middle of */
/* detector & source) with respect to Voxel coordinates */
/* tic; */
/* this will verify the size: */
if (eml_ndims_varsized(*(int32_T (*)[3])voxel_data->size) != 3) {
st.site = &emlrtRSI;
y = NULL;
m0 = emlrtCreateCharArray(2, iv0);
for (i = 0; i < 32; i++) {
cv0[i] = cv1[i];
}
emlrtInitCharArrayR2013a(&st, 32, m0, cv0);
emlrtAssign(&y, m0);
b_st.site = &b_emlrtRSI;
error(&b_st, y, &emlrtMCI);
}
/* constants: */
/* .0001; */
/* .0001; */
/* sounce to imager(detector) distance */
/* source to axis distance %% RRI set the coordinate at the middle between source and the detector */
/* initialize memory for speed: */
i0 = projection->size[0] * projection->size[1];
pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[0],
&b_emlrtDCI, sp);
projection->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&emlrtDCI, sp);
pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[1],
&d_emlrtDCI, sp);
projection->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&c_emlrtDCI, sp);
emxEnsureCapacity(sp, (emxArray__common *)projection, i0, (int32_T)sizeof
(real_T), &emlrtRTEI);
pixel_size_mm_h = emlrtNonNegativeCheckFastR2012b(detector_dimensions[0],
&b_emlrtDCI, sp);
pixel_size_mm_w = emlrtNonNegativeCheckFastR2012b(detector_dimensions[1],
&d_emlrtDCI, sp);
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h, &emlrtDCI, sp) *
(int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w, &c_emlrtDCI, sp);
for (i0 = 0; i0 < i; i0++) {
projection->data[i0] = 0.0;
}
for (i0 = 0; i0 < 3; i0++) {
voxDim[i0] = (uint32_T)voxel_data->size[i0];
}
/* [size(voxel_data,1), size(voxel_data,2), size(voxel_data,3)]; */
/* voxDim_x = voxDim(1); */
/* voxDim_y = voxDim(2); */
/* voxDim_z = voxDim(3); */
/* difine voxel boundaries: */
/* vector from origin to source */
/* vector from origin to CENTER of detector */
/* extract the key information from the intrinsic parameters % 151213 kosy modi */
pixel_size_mm_h = 1105.0 / XRayIntrinsicParam[0];
pixel_size_mm_w = 1105.0 / XRayIntrinsicParam[4];
/* vector pointing left, parallel to detector */
/* define incremental vectors: */
/* define upper lefthand corner of detector: */
/* corner = detector + ( center_pixel_w*pixel_size_mmel.wn + center_pixel_h*pixel_size_mmel.hn ); */
for (i = 0; i < 3; i++) {
voxPlanes__max[i] = voxel_corner_min[i] + voxel_size_mm[i] * (real_T)
voxDim[i];
/* define up: */
/* up = [0,0,1]; */
/* width of projection image */
/* height of projection image */
/* direction from the detector to the source */
/* end initialization timer: */
/* init_time = toc */
/* start tracing timer: */
/* tic; */
source[i] = 552.5 * T_carm[4 + i] + T_carm[12 + i];
/* define pixel_size_mmel vectors: */
/* length of pixel_size_mmel */
pixel_size_mmel_wn[i] = -pixel_size_mm_w * T_carm[i];
pixel_size_mmel_hn[i] = -pixel_size_mm_h * T_carm[8 + i];
corner[i] = (-552.5 * T_carm[4 + i] + T_carm[12 + i]) +
(detector_dimensions[0] * (pixel_size_mm_w * T_carm[i]) +
detector_dimensions[1] * (pixel_size_mm_h * T_carm[8 + i])) / 2.0;
}
emlrtForLoopVectorCheckR2012b(1.0, 1.0, detector_dimensions[0], mxDOUBLE_CLASS,
(int32_T)detector_dimensions[0], &d_emlrtRTEI,
sp);
ih = 1;
while (ih - 1 <= (int32_T)detector_dimensions[0] - 1) {
/* if(mod(ih,100)==0),fprintf('height:\t%i...\n',ih);end */
emlrtForLoopVectorCheckR2012b(1.0, 1.0, detector_dimensions[1],
mxDOUBLE_CLASS, (int32_T)detector_dimensions[1], &c_emlrtRTEI, sp);
iw = 1;
while (iw - 1 <= (int32_T)detector_dimensions[1] - 1) {
/* pixel_point_mm = corner + (ih-1)*pixel_size_mmel.hp + (iw-1)*pixel_size_mmel.wp; %ray end point */
/* ray to be traced */
/* find parametrized (t) voxel plane (min or max) intersections: */
/* PLANE = P1 + t(P2-P1) */
/* SK added */
/* t_x = (i-x1) / (x2-x1), t_y = (j-y1) / (y2-y1), t_z = (k-z1) / (z2-z1) */
for (i = 0; i < 3; i++) {
pixel_size_mm_h = (corner[i] + ((1.0 + (real_T)(ih - 1)) - 1.0) *
pixel_size_mmel_hn[i]) + ((1.0 + (real_T)(iw - 1)) -
1.0) * pixel_size_mmel_wn[i];
/* ray end point */
pixel_size_mm_w = pixel_size_mm_h - source[i];
tstep[i] = voxel_corner_min[i] - source[i];
tnext[i] = pixel_size_mm_w + 2.2250738585072014E-308;
b_voxPlanes__max[i] = voxPlanes__max[i] - source[i];
b_ray_source2pixel[i] = pixel_size_mm_w + 2.2250738585072014E-308;
pixel_point_mm[i] = pixel_size_mm_h;
ray_source2pixel[i] = pixel_size_mm_w;
}
rdivide(tstep, tnext, t_plane_min);
rdivide(b_voxPlanes__max, b_ray_source2pixel, t_plane_max);
/* compute (parametric) intersection values */
/* tmin = max { min{tx(0), tx(Nx)}, min{ty(0), ty(Ny)], min{tz(0), tz(Nz)}, 0.0 } */
/* tmax = min { max{tx(0), tx(Nx)}, max{ty(0), ty(Ny)], max{tz(0), tz(Nz)}, 1.0 } */
/* t_larger = [ max([t_plane_min(1), t_plane_max(1)]), max([t_plane_min(2), t_plane_max(2)]), max([t_plane_min(3), t_plane_max(3)]), 1.0 ]; */
/* t_smaller = [ min([t_plane_min(1), t_plane_max(1)]), min([t_plane_min(2), t_plane_max(2)]), min([t_plane_min(3), t_plane_max(3)]), 0.0 ]; */
i = 1;
tmax = t_plane_min[0];
if (muDoubleScalarIsNaN(t_plane_min[0])) {
pixel_size_mmIntensity = 2;
exitg8 = false;
while ((!exitg8) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[0])) {
tmax = t_plane_max[0];
exitg8 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[0] > tmax)) {
tmax = t_plane_max[0];
}
i = 1;
pixel_size_mm_h = t_plane_min[1];
if (muDoubleScalarIsNaN(t_plane_min[1])) {
pixel_size_mmIntensity = 2;
exitg7 = false;
while ((!exitg7) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[1])) {
pixel_size_mm_h = t_plane_max[1];
exitg7 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[1] > pixel_size_mm_h)) {
pixel_size_mm_h = t_plane_max[1];
}
i = 1;
pixel_size_mm_w = t_plane_min[2];
if (muDoubleScalarIsNaN(t_plane_min[2])) {
pixel_size_mmIntensity = 2;
exitg6 = false;
while ((!exitg6) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[2])) {
pixel_size_mm_w = t_plane_max[2];
exitg6 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[2] > pixel_size_mm_w)) {
pixel_size_mm_w = t_plane_max[2];
}
t_larger[0] = tmax;
t_larger[1] = pixel_size_mm_h;
t_larger[2] = pixel_size_mm_w;
t_larger[3] = 1.0;
i = 1;
temp = t_plane_min[0];
if (muDoubleScalarIsNaN(t_plane_min[0])) {
pixel_size_mmIntensity = 2;
exitg5 = false;
while ((!exitg5) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[0])) {
temp = t_plane_max[0];
exitg5 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[0] < temp)) {
temp = t_plane_max[0];
}
i = 1;
pixel_size_mm_h = t_plane_min[1];
if (muDoubleScalarIsNaN(t_plane_min[1])) {
pixel_size_mmIntensity = 2;
exitg4 = false;
while ((!exitg4) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[1])) {
pixel_size_mm_h = t_plane_max[1];
exitg4 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[1] < pixel_size_mm_h)) {
pixel_size_mm_h = t_plane_max[1];
}
i = 1;
pixel_size_mm_w = t_plane_min[2];
if (muDoubleScalarIsNaN(t_plane_min[2])) {
pixel_size_mmIntensity = 2;
exitg3 = false;
while ((!exitg3) && (pixel_size_mmIntensity < 3)) {
i = 2;
if (!muDoubleScalarIsNaN(t_plane_max[2])) {
pixel_size_mm_w = t_plane_max[2];
exitg3 = true;
} else {
pixel_size_mmIntensity = 3;
}
}
}
if ((i < 2) && (t_plane_max[2] < pixel_size_mm_w)) {
pixel_size_mm_w = t_plane_max[2];
}
t_smaller[0] = temp;
t_smaller[1] = pixel_size_mm_h;
t_smaller[2] = pixel_size_mm_w;
t_smaller[3] = 0.0;
i = 1;
itmp = 0;
if (muDoubleScalarIsNaN(temp)) {
pixel_size_mmIntensity = 1;
exitg2 = false;
while ((!exitg2) && (pixel_size_mmIntensity + 1 < 5)) {
i = pixel_size_mmIntensity + 1;
if (!muDoubleScalarIsNaN(t_smaller[pixel_size_mmIntensity])) {
temp = t_smaller[pixel_size_mmIntensity];
itmp = pixel_size_mmIntensity;
exitg2 = true;
} else {
pixel_size_mmIntensity++;
}
}
}
if (i < 4) {
while (i + 1 < 5) {
if (t_smaller[i] > temp) {
temp = t_smaller[i];
itmp = i;
}
i++;
}
}
i = 1;
if (muDoubleScalarIsNaN(tmax)) {
pixel_size_mmIntensity = 2;
exitg1 = false;
while ((!exitg1) && (pixel_size_mmIntensity < 5)) {
i = pixel_size_mmIntensity;
if (!muDoubleScalarIsNaN(t_larger[pixel_size_mmIntensity - 1])) {
tmax = t_larger[pixel_size_mmIntensity - 1];
exitg1 = true;
} else {
pixel_size_mmIntensity++;
}
}
}
if (i < 4) {
while (i + 1 < 5) {
if (t_larger[i] < tmax) {
tmax = t_larger[i];
}
i++;
}
}
for (i0 = 0; i0 < 3; i0++) {
pixel_point_mm[i0] = (real_T)(pixel_point_mm[i0] < source[i0]) * -2.0 +
1.0;
}
if (temp < tmax) {
/* if ray intersects volume */
/* find index for each dimension: */
for (i = 0; i < 3; i++) {
pixel_size_mm_h = muDoubleScalarFloor((((ray_source2pixel[i] * temp +
source[i]) - voxel_corner_min[i]) + 2.2250738585072014E-308) /
voxel_size_mm[i]);
/* (parametric) intersection values... */
/* makes 0 or 1 */
tnext[i] = (voxel_corner_min[i] + ((pixel_size_mm_h +
(pixel_point_mm[i] + 1.0) / 2.0) * voxel_size_mm[i] - source[i])) /
(ray_source2pixel[i] + 2.2250738585072014E-308);
/* parametric value for next plane intersection */
tstep[i] = muDoubleScalarAbs(voxel_size_mm[i] / (ray_source2pixel[i] +
2.2250738585072014E-308));
t_plane_min[i] = pixel_size_mm_h;
}
/* parametric step size */
/* address special cases... */
if (temp == t_plane_max[emlrtDynamicBoundsCheckFastR2012b(itmp + 1, 1, 3,
&c_emlrtBCI, sp) - 1]) {
/* if intersection is a "max" plane */
t_plane_min[itmp] = (real_T)voxDim[itmp] - 1.0;
tnext[itmp] = temp + tstep[itmp];
/* next plane crossing */
} else {
t_plane_min[itmp] = 0.0;
tnext[itmp] = temp + tstep[itmp];
/* next plane crossing */
}
/* voxel index values(add one for matlab): */
pixel_size_mm_h = t_plane_min[0] + 1.0;
pixel_size_mm_w = t_plane_min[1] + 1.0;
iz = t_plane_min[2] + 1.0;
tx = tnext[0];
ty = tnext[1];
tz = tnext[2];
pixel_size_mmIntensity = 0;
/* uncomment to generate P-matrix: */
/* pixel_size_mmNum = 1; */
/* len = norm(ray_source2pixel); % ray length */
while ((temp + 0.0001 < tmax) && (!(pixel_size_mm_h * pixel_size_mm_w *
iz == 0.0))) {
if ((tx < ty) && (tx < tz)) {
/* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */
i0 = voxel_data->size[0];
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&k_emlrtDCI, sp);
itmp = voxel_data->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w,
&l_emlrtDCI, sp);
i2 = voxel_data->size[2];
i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &m_emlrtDCI, sp);
if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0,
&j_emlrtBCI, sp) + voxel_data->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(i1, 1,
itmp, &k_emlrtBCI, sp) - 1)) + voxel_data->size[0] *
voxel_data->size[1] *
(emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2,
&l_emlrtBCI, sp) - 1)) - 1]) {
pixel_size_mmIntensity = 255;
tmax = rtMinusInf;
}
temp = tx;
tx += tstep[0];
pixel_size_mm_h += pixel_point_mm[0];
} else if (ty < tz) {
/* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */
i0 = voxel_data->size[0];
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&h_emlrtDCI, sp);
itmp = voxel_data->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w,
&i_emlrtDCI, sp);
i2 = voxel_data->size[2];
i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &j_emlrtDCI, sp);
if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0,
&g_emlrtBCI, sp) + voxel_data->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(i1, 1,
itmp, &h_emlrtBCI, sp) - 1)) + voxel_data->size[0] *
voxel_data->size[1] *
(emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2,
&i_emlrtBCI, sp) - 1)) - 1]) {
pixel_size_mmIntensity = 255;
tmax = rtMinusInf;
}
temp = ty;
ty += tstep[1];
pixel_size_mm_w += pixel_point_mm[1];
} else {
/* 실제 DRR을 그리지 않고, 한점이라도 지나면 해당 점에 포함시킴 */
i0 = voxel_data->size[0];
i = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_h,
&e_emlrtDCI, sp);
itmp = voxel_data->size[1];
i1 = (int32_T)emlrtIntegerCheckFastR2012b(pixel_size_mm_w,
&f_emlrtDCI, sp);
i2 = voxel_data->size[2];
i3 = (int32_T)emlrtIntegerCheckFastR2012b(iz, &g_emlrtDCI, sp);
if (voxel_data->data[((emlrtDynamicBoundsCheckFastR2012b(i, 1, i0,
&d_emlrtBCI, sp) + voxel_data->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(i1, 1,
itmp, &e_emlrtBCI, sp) - 1)) + voxel_data->size[0] *
voxel_data->size[1] *
(emlrtDynamicBoundsCheckFastR2012b(i3, 1, i2,
&f_emlrtBCI, sp) - 1)) - 1]) {
pixel_size_mmIntensity = 255;
tmax = rtMinusInf;
}
temp = tz;
tz += tstep[2];
iz += pixel_point_mm[2];
}
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* end while */
i0 = projection->size[0];
i = projection->size[1];
projection->data[(emlrtDynamicBoundsCheckFastR2012b(ih, 1, i0,
&m_emlrtBCI, sp) + projection->size[0] *
(emlrtDynamicBoundsCheckFastR2012b(iw, 1, i,
&n_emlrtBCI, sp) - 1)) - 1] = pixel_size_mmIntensity;
} else {
/* if no intersections */
i0 = projection->size[0];
i = projection->size[1];
projection->data[(emlrtDynamicBoundsCheckFastR2012b(ih, 1, i0, &emlrtBCI,
sp) + projection->size[0] * (emlrtDynamicBoundsCheckFastR2012b(iw, 1,
i, &b_emlrtBCI, sp) - 1)) - 1] = 0.0;
}
/* if intersections */
/* uncomment to generate P-matrix: */
/* rayCount = rayCount + 1; */
iw++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* width */
/* fprintf('\n'); */
ih++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* height */
/* uncomment to generate P-matrix: */
/* matrix = matrix(1:mtxCount-1,:); */
/* stop trace timer: */
/* trace_time = toc */
/* fprintf('\n') */
/* function */
/* } */
}
/* Function Definitions */
void CalculateC(const emlrtStack *sp, real_T N, real_T N0, const emxArray_real_T
*t, const emxArray_real_T *gridX, emxArray_real_T *C)
{
int32_T i9;
real_T d5;
real_T d6;
int32_T loop_ub;
int32_T i;
int32_T k;
int32_T b_C;
real_T d7;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
/* calculate the C matrix */
/* N- number of time points */
/* N0- number of space points */
/* t- time points */
/* gridX - grid for the space points */
i9 = C->size[0] * C->size[1];
d5 = 2.0 * N;
d5 = emlrtNonNegativeCheckFastR2012b(d5, &ab_emlrtDCI, sp);
C->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d5, &y_emlrtDCI, sp);
d5 = emlrtNonNegativeCheckFastR2012b(N0, &cb_emlrtDCI, sp);
C->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d5, &bb_emlrtDCI, sp);
emxEnsureCapacity(sp, (emxArray__common *)C, i9, (int32_T)sizeof(real_T),
&d_emlrtRTEI);
d5 = 2.0 * N;
d5 = emlrtNonNegativeCheckFastR2012b(d5, &ab_emlrtDCI, sp);
d6 = emlrtNonNegativeCheckFastR2012b(N0, &cb_emlrtDCI, sp);
loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d5, &y_emlrtDCI, sp) * (int32_T)
emlrtIntegerCheckFastR2012b(d6, &bb_emlrtDCI, sp);
for (i9 = 0; i9 < loop_ub; i9++) {
C->data[i9] = 0.0;
}
emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N,
&ec_emlrtRTEI, sp);
i = 1;
while (i - 1 <= (int32_T)N - 1) {
/* space */
emlrtForLoopVectorCheckR2012b(1.0, 1.0, N0, mxDOUBLE_CLASS, (int32_T)N0,
&fc_emlrtRTEI, sp);
k = 0;
while (k <= (int32_T)N0 - 1) {
/* time */
d5 = 2.0 * (1.0 + (real_T)(i - 1));
b_C = C->size[0];
loop_ub = C->size[1];
emlrtDynamicBoundsCheckFastR2012b(k + 1, 1, loop_ub, &mc_emlrtBCI, sp);
i9 = t->size[1];
st.site = &x_emlrtRSI;
d6 = b_Ccoeff(&st, 1.0 + (real_T)k, 0.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i9,
&nc_emlrtBCI, sp) - 1], gridX);
i9 = t->size[1];
st.site = &y_emlrtRSI;
d7 = b_Ccoeff(&st, 1.0 + (real_T)k, 1.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i, 1, i9,
&oc_emlrtBCI, sp) - 1], gridX);
i9 = (int32_T)(d5 + -1.0);
C->data[(emlrtDynamicBoundsCheckFastR2012b(i9, 1, b_C, &pc_emlrtBCI, sp) +
C->size[0] * k) - 1] = d6;
i9 = (int32_T)d5;
C->data[(emlrtDynamicBoundsCheckFastR2012b(i9, 1, b_C, &pc_emlrtBCI, sp) +
C->size[0] * k) - 1] = d7;
k++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
i++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
}
/* Function Definitions */
void update_eq_17_state(const real_T xk_data[6250], const int32_T xk_size[2],
const emxArray_real_T *vk, const real_T uk_data[250], const int32_T uk_size[1],
real_T xkPlus_data[6250], int32_T xkPlus_size[2])
{
int32_T i0;
int32_T i1;
uint8_T uv0[2];
int32_T loop_ub;
int32_T k;
real_T xdot[17];
real_T vk_data[100];
real_T wi[3];
real_T ai[3];
real_T b_xk_data[25];
real_T xk[9];
real_T b_xk[3];
real_T c_xk[3];
real_T dv0[9];
real_T B;
real_T dv1[9];
real_T d_xk[12];
real_T dv2[12];
static const int8_T b[9] = { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
real_T xkPlus[4];
real_T dv3[9];
real_T e_xk[9];
real_T c_xk_data[25];
real_T dv4[9];
uint8_T tmp_data[25];
int32_T iv0[1];
static const int32_T iv1[1] = { 17 };
real_T f_xk[17];
/* xk: 17 x 2N+1, inertial position, inertial velocity, inertial quaternion, relative position, and relative quaternion */
/* vk: 12 x 2N+1, noise on wi,(wj_est),ai,(vj_inertial) */
/* uk[wi;ai;mag_i] : 9 x 2N+1 */
/* IMU measurements of me */
emlrtVectorVectorIndexCheckR2012b(uk_size[0], 1, 1, 3, &l_emlrtECI,
emlrtRootTLSGlobal);
for (i0 = 0; i0 < 3; i0++) {
i1 = 1 + i0;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, uk_size[0], &j_emlrtBCI,
emlrtRootTLSGlobal);
}
emlrtVectorVectorIndexCheckR2012b(uk_size[0], 1, 1, 3, &k_emlrtECI,
emlrtRootTLSGlobal);
for (i0 = 0; i0 < 3; i0++) {
i1 = 4 + i0;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, uk_size[0], &k_emlrtBCI,
emlrtRootTLSGlobal);
}
for (i0 = 0; i0 < 2; i0++) {
uv0[i0] = (uint8_T)xk_size[i0];
}
xkPlus_size[0] = uv0[0];
xkPlus_size[1] = uv0[1];
loop_ub = uv0[0] * uv0[1];
for (i0 = 0; i0 < loop_ub; i0++) {
xkPlus_data[i0] = 0.0;
}
k = 0;
while (k <= xk_size[1] - 1) {
i0 = (int32_T)(1.0 + (real_T)k);
emlrtDynamicBoundsCheckFastR2012b(i0, 1, xk_size[1], &i_emlrtBCI,
emlrtRootTLSGlobal);
/* hist position relative to my. My body frame */
emlrtVectorVectorIndexCheckR2012b(xk_size[0], 1, 1, 3, &j_emlrtECI,
emlrtRootTLSGlobal);
for (i0 = 0; i0 < 3; i0++) {
i1 = 11 + i0;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, xk_size[0], &l_emlrtBCI,
emlrtRootTLSGlobal);
}
/* my velocity */
emlrtVectorVectorIndexCheckR2012b(xk_size[0], 1, 1, 3, &i_emlrtECI,
emlrtRootTLSGlobal);
for (i0 = 0; i0 < 3; i0++) {
i1 = 4 + i0;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, xk_size[0], &m_emlrtBCI,
emlrtRootTLSGlobal);
}
/* my attitude */
emlrtVectorVectorIndexCheckR2012b(xk_size[0], 1, 1, 4, &h_emlrtECI,
emlrtRootTLSGlobal);
for (i0 = 0; i0 < 4; i0++) {
i1 = 7 + i0;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, xk_size[0], &n_emlrtBCI,
emlrtRootTLSGlobal);
}
/* his attitude relative to mine. His body frame */
emlrtVectorVectorIndexCheckR2012b(xk_size[0], 1, 1, 4, &g_emlrtECI,
emlrtRootTLSGlobal);
for (i0 = 0; i0 < 4; i0++) {
i1 = 14 + i0;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, xk_size[0], &o_emlrtBCI,
emlrtRootTLSGlobal);
}
i0 = vk->size[1];
i1 = (int32_T)(1.0 + (real_T)k);
emlrtDynamicBoundsCheckFastR2012b(i1, 1, i0, &h_emlrtBCI, emlrtRootTLSGlobal);
memset(&xdot[0], 0, 17U * sizeof(real_T));
i0 = vk->size[0];
emlrtVectorVectorIndexCheckR2012b(i0, 1, 1, 3, &f_emlrtECI,
emlrtRootTLSGlobal);
i0 = vk->size[0];
for (i1 = 0; i1 < 3; i1++) {
loop_ub = 10 + i1;
emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i0, &p_emlrtBCI,
emlrtRootTLSGlobal);
}
i0 = vk->size[0];
emlrtVectorVectorIndexCheckR2012b(i0, 1, 1, 3, &e_emlrtECI,
emlrtRootTLSGlobal);
i0 = vk->size[0];
for (i1 = 0; i1 < 3; i1++) {
loop_ub = 4 + i1;
emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i0, &q_emlrtBCI,
emlrtRootTLSGlobal);
}
i0 = vk->size[0];
emlrtVectorVectorIndexCheckR2012b(i0, 1, 1, 3, &d_emlrtECI,
emlrtRootTLSGlobal);
i0 = vk->size[0];
loop_ub = vk->size[0];
for (i1 = 0; i1 < loop_ub; i1++) {
vk_data[i1] = vk->data[i1 + vk->size[0] * k];
}
for (i1 = 0; i1 < 3; i1++) {
loop_ub = 1 + i1;
wi[i1] = uk_data[i1] + vk_data[emlrtDynamicBoundsCheckFastR2012b(loop_ub,
1, i0, &r_emlrtBCI, emlrtRootTLSGlobal) - 1];
}
i0 = vk->size[0];
emlrtVectorVectorIndexCheckR2012b(i0, 1, 1, 3, &c_emlrtECI,
emlrtRootTLSGlobal);
i0 = vk->size[0];
loop_ub = vk->size[0];
for (i1 = 0; i1 < loop_ub; i1++) {
vk_data[i1] = vk->data[i1 + vk->size[0] * k];
}
for (i1 = 0; i1 < 3; i1++) {
loop_ub = 7 + i1;
ai[i1] = uk_data[i1 + 3] + vk_data[emlrtDynamicBoundsCheckFastR2012b
(loop_ub, 1, i0, &s_emlrtBCI, emlrtRootTLSGlobal) - 1];
}
/* cosine matrix */
/* Tim Woodbury */
/* modified for AERO 622 */
/* */
/* [Y] = attpar(X,I,options) */
/* Function to convert between attitude parametrizations */
/* */
/* INPUTS: */
/* X - matrix input of appropriate dimension (detailed later) */
/* I - 2 x 1 indexing vector indicating the input (I(1)) and output (I(2)) */
/* attitude parametrizations, corresponding to the numbers in the section, */
/* "I/O SPECIFICATION PARAMETERS". */
/* options - a data structure. Currently only allows output Euler angle */
/* sequence to be defined. Supported members are "seq" which should be a */
/* [3 x 1] vector describing the first, second, and third rotations in */
/* the desired output sequence. */
/* */
/* OUTPUTS: */
/* Y - output matrix of appropriate dimensions. */
/* All angles are in radians. */
/* */
/* I/O SPECIFICATION PARAMETERS: */
/* 1 - Direction cosine matrix, dimensions [3 x 3] */
/* 2 - Euler principal axis/angle, [3 x 2]. [:,1] is the principal axis; */
/* [1,2] is the principal angle (rad). */
/* 3 - 2-angle parametrization, [3 x 4] */
/* 4 - Euler angle sequence, [3 x 2]. [:,1] are the rotation angles in radians, */
/* and [2,1]-[2,2]-[2,3] is the rotation sequence. */
/* [3-1-3] sequence is default for output. Other sequences may be specified */
/* by passing an optional data structure with a [3 x 1] member "seq" whose */
/* entries [a;b;c] correspond to the sequence a-b-c. Any input sequence */
/* may be used by specifying the second column of input appropriately. */
/* 5 - Classical Rodrigues parameters [3 x 1] */
/* 6 - quaternion [4 x 1]. The scalar part of the quaternion comes FIRST. */
/* 7 - modified Rodrigues parameters [3 x 1] */
/* 8 - exponential matrix, [3 x 3] */
/* 9 - Cayley-Klein parameters, [2 x 2] */
/* check if any options are passed */
/* %check if output and inp are the same - if so do nothing */
/* for each inp, convert to DCM */
/* quaternion */
/* disp('Input value specified as quaternion.'); */
/* convert DCM to output form */
/* DCM */
/* disp('Output value specified as direction cosine matrix.'); */
/* time rate of my position */
loop_ub = xk_size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
b_xk_data[i0] = xk_data[i0 + xk_size[0] * k];
}
xk[0] = ((xk_data[xk_size[0] * k + 7] * xk_data[xk_size[0] * k + 7] -
xk_data[xk_size[0] * k + 8] * xk_data[xk_size[0] * k + 8]) -
xk_data[xk_size[0] * k + 9] * xk_data[xk_size[0] * k + 9]) +
xk_data[xk_size[0] * k + 6] * xk_data[xk_size[0] * k + 6];
xk[1] = 2.0 * (xk_data[xk_size[0] * k + 7] * xk_data[xk_size[0] * k + 8] +
xk_data[xk_size[0] * k + 9] * xk_data[xk_size[0] * k + 6]);
xk[2] = 2.0 * (xk_data[xk_size[0] * k + 7] * xk_data[xk_size[0] * k + 9] -
xk_data[xk_size[0] * k + 8] * xk_data[xk_size[0] * k + 6]);
xk[3] = 2.0 * (xk_data[xk_size[0] * k + 7] * xk_data[xk_size[0] * k + 8] -
xk_data[xk_size[0] * k + 9] * xk_data[xk_size[0] * k + 6]);
xk[4] = ((xk_data[xk_size[0] * k + 8] * xk_data[xk_size[0] * k + 8] -
xk_data[xk_size[0] * k + 7] * xk_data[xk_size[0] * k + 7]) -
xk_data[xk_size[0] * k + 9] * xk_data[xk_size[0] * k + 9]) +
xk_data[xk_size[0] * k + 6] * xk_data[xk_size[0] * k + 6];
xk[5] = 2.0 * (xk_data[xk_size[0] * k + 8] * xk_data[xk_size[0] * k + 9] +
xk_data[xk_size[0] * k + 7] * xk_data[xk_size[0] * k + 6]);
xk[6] = 2.0 * (xk_data[xk_size[0] * k + 7] * xk_data[xk_size[0] * k + 9] +
xk_data[xk_size[0] * k + 8] * xk_data[xk_size[0] * k + 6]);
xk[7] = 2.0 * (xk_data[xk_size[0] * k + 8] * xk_data[xk_size[0] * k + 9] -
xk_data[xk_size[0] * k + 7] * xk_data[xk_size[0] * k + 6]);
xk[8] = ((xk_data[xk_size[0] * k + 9] * xk_data[xk_size[0] * k + 9] -
xk_data[xk_size[0] * k + 7] * xk_data[xk_size[0] * k + 7]) -
xk_data[xk_size[0] * k + 8] * xk_data[xk_size[0] * k + 8]) +
xk_data[xk_size[0] * k + 6] * xk_data[xk_size[0] * k + 6];
for (i0 = 0; i0 < 3; i0++) {
b_xk[i0] = b_xk_data[i0 + 3];
}
for (i0 = 0; i0 < 3; i0++) {
c_xk[i0] = 0.0;
for (i1 = 0; i1 < 3; i1++) {
c_xk[i0] += xk[i0 + 3 * i1] * b_xk[i1];
}
xdot[i0] = c_xk[i0];
}
/* time rate of my velocity */
/* returns the cross product matrix of the vector x */
loop_ub = xk_size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
b_xk_data[i0] = xk_data[i0 + xk_size[0] * k];
}
dv0[0] = 0.0;
dv0[3] = -wi[2];
dv0[6] = wi[1];
dv0[1] = wi[2];
dv0[4] = 0.0;
dv0[7] = -wi[0];
dv0[2] = -wi[1];
dv0[5] = wi[0];
dv0[8] = 0.0;
for (i0 = 0; i0 < 3; i0++) {
b_xk[i0] = b_xk_data[i0 + 3];
}
for (i0 = 0; i0 < 3; i0++) {
B = 0.0;
for (i1 = 0; i1 < 3; i1++) {
B += dv0[i0 + 3 * i1] * b_xk[i1];
}
c_xk[i0] = ai[i0] - B;
}
for (i0 = 0; i0 < 3; i0++) {
xdot[3 + i0] = c_xk[i0];
}
/* time rate of my attitude */
/* A matrix for qin */
/* returns the cross product matrix of the vector x */
loop_ub = xk_size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
b_xk_data[i0] = xk_data[i0 + xk_size[0] * k];
}
dv1[0] = 0.0;
dv1[3] = -xk_data[xk_size[0] * k + 9];
dv1[6] = xk_data[xk_size[0] * k + 8];
dv1[1] = xk_data[xk_size[0] * k + 9];
dv1[4] = 0.0;
dv1[7] = -xk_data[xk_size[0] * k + 7];
dv1[2] = -xk_data[xk_size[0] * k + 8];
dv1[5] = xk_data[xk_size[0] * k + 7];
dv1[8] = 0.0;
for (i0 = 0; i0 < 3; i0++) {
d_xk[i0 << 2] = -b_xk_data[i0 + 7];
for (i1 = 0; i1 < 3; i1++) {
d_xk[(i1 + (i0 << 2)) + 1] = xk_data[xk_size[0] * k + 6] * (real_T)b[i1
+ 3 * i0] + dv1[i1 + 3 * i0];
}
for (i1 = 0; i1 < 4; i1++) {
dv2[i1 + (i0 << 2)] = 0.5 * d_xk[i1 + (i0 << 2)];
}
}
for (i0 = 0; i0 < 4; i0++) {
xkPlus[i0] = 0.0;
for (i1 = 0; i1 < 3; i1++) {
xkPlus[i0] += dv2[i0 + (i1 << 2)] * wi[i1];
}
xdot[6 + i0] = xkPlus[i0];
}
/* relative attitude cosine matrix */
/* Tim Woodbury */
/* modified for AERO 622 */
/* */
/* [Y] = attpar(X,I,options) */
/* Function to convert between attitude parametrizations */
/* */
/* INPUTS: */
/* X - matrix input of appropriate dimension (detailed later) */
/* I - 2 x 1 indexing vector indicating the input (I(1)) and output (I(2)) */
/* attitude parametrizations, corresponding to the numbers in the section, */
/* "I/O SPECIFICATION PARAMETERS". */
/* options - a data structure. Currently only allows output Euler angle */
/* sequence to be defined. Supported members are "seq" which should be a */
/* [3 x 1] vector describing the first, second, and third rotations in */
/* the desired output sequence. */
/* */
/* OUTPUTS: */
/* Y - output matrix of appropriate dimensions. */
/* All angles are in radians. */
/* */
/* I/O SPECIFICATION PARAMETERS: */
/* 1 - Direction cosine matrix, dimensions [3 x 3] */
/* 2 - Euler principal axis/angle, [3 x 2]. [:,1] is the principal axis; */
/* [1,2] is the principal angle (rad). */
/* 3 - 2-angle parametrization, [3 x 4] */
/* 4 - Euler angle sequence, [3 x 2]. [:,1] are the rotation angles in radians, */
/* and [2,1]-[2,2]-[2,3] is the rotation sequence. */
/* [3-1-3] sequence is default for output. Other sequences may be specified */
/* by passing an optional data structure with a [3 x 1] member "seq" whose */
/* entries [a;b;c] correspond to the sequence a-b-c. Any input sequence */
/* may be used by specifying the second column of input appropriately. */
/* 5 - Classical Rodrigues parameters [3 x 1] */
/* 6 - quaternion [4 x 1]. The scalar part of the quaternion comes FIRST. */
/* 7 - modified Rodrigues parameters [3 x 1] */
/* 8 - exponential matrix, [3 x 3] */
/* 9 - Cayley-Klein parameters, [2 x 2] */
/* check if any options are passed */
/* %check if output and inp are the same - if so do nothing */
/* for each inp, convert to DCM */
/* quaternion */
/* disp('Input value specified as quaternion.'); */
/* convert DCM to output form */
/* DCM */
/* disp('Output value specified as direction cosine matrix.'); */
/* relative angular velocity in j frame */
/* A matrix for q_ji */
/* returns the cross product matrix of the vector x */
/* time rate of relative attitude */
loop_ub = xk_size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
b_xk_data[i0] = xk_data[i0 + xk_size[0] * k];
}
dv3[0] = 0.0;
dv3[3] = -xk_data[xk_size[0] * k + 16];
dv3[6] = xk_data[xk_size[0] * k + 15];
dv3[1] = xk_data[xk_size[0] * k + 16];
dv3[4] = 0.0;
dv3[7] = -xk_data[xk_size[0] * k + 14];
dv3[2] = -xk_data[xk_size[0] * k + 15];
dv3[5] = xk_data[xk_size[0] * k + 14];
dv3[8] = 0.0;
for (i0 = 0; i0 < 3; i0++) {
d_xk[i0 << 2] = -b_xk_data[i0 + 14];
for (i1 = 0; i1 < 3; i1++) {
d_xk[(i1 + (i0 << 2)) + 1] = xk_data[xk_size[0] * k + 13] * (real_T)b[i1
+ 3 * i0] + dv3[i1 + 3 * i0];
}
}
loop_ub = vk->size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
vk_data[i0] = vk->data[i0 + vk->size[0] * k];
}
e_xk[0] = ((xk_data[xk_size[0] * k + 14] * xk_data[xk_size[0] * k + 14] -
xk_data[xk_size[0] * k + 15] * xk_data[xk_size[0] * k + 15]) -
xk_data[xk_size[0] * k + 16] * xk_data[xk_size[0] * k + 16]) +
xk_data[xk_size[0] * k + 13] * xk_data[xk_size[0] * k + 13];
e_xk[3] = 2.0 * (xk_data[xk_size[0] * k + 14] * xk_data[xk_size[0] * k + 15]
+ xk_data[xk_size[0] * k + 16] * xk_data[xk_size[0] * k +
13]);
e_xk[6] = 2.0 * (xk_data[xk_size[0] * k + 14] * xk_data[xk_size[0] * k + 16]
- xk_data[xk_size[0] * k + 15] * xk_data[xk_size[0] * k +
13]);
e_xk[1] = 2.0 * (xk_data[xk_size[0] * k + 14] * xk_data[xk_size[0] * k + 15]
- xk_data[xk_size[0] * k + 16] * xk_data[xk_size[0] * k +
13]);
e_xk[4] = ((xk_data[xk_size[0] * k + 15] * xk_data[xk_size[0] * k + 15] -
xk_data[xk_size[0] * k + 14] * xk_data[xk_size[0] * k + 14]) -
xk_data[xk_size[0] * k + 16] * xk_data[xk_size[0] * k + 16]) +
xk_data[xk_size[0] * k + 13] * xk_data[xk_size[0] * k + 13];
e_xk[7] = 2.0 * (xk_data[xk_size[0] * k + 15] * xk_data[xk_size[0] * k + 16]
+ xk_data[xk_size[0] * k + 14] * xk_data[xk_size[0] * k +
13]);
e_xk[2] = 2.0 * (xk_data[xk_size[0] * k + 14] * xk_data[xk_size[0] * k + 16]
+ xk_data[xk_size[0] * k + 15] * xk_data[xk_size[0] * k +
13]);
e_xk[5] = 2.0 * (xk_data[xk_size[0] * k + 15] * xk_data[xk_size[0] * k + 16]
- xk_data[xk_size[0] * k + 14] * xk_data[xk_size[0] * k +
13]);
e_xk[8] = ((xk_data[xk_size[0] * k + 16] * xk_data[xk_size[0] * k + 16] -
xk_data[xk_size[0] * k + 14] * xk_data[xk_size[0] * k + 14]) -
xk_data[xk_size[0] * k + 15] * xk_data[xk_size[0] * k + 15]) +
xk_data[xk_size[0] * k + 13] * xk_data[xk_size[0] * k + 13];
for (i0 = 0; i0 < 3; i0++) {
for (i1 = 0; i1 < 4; i1++) {
dv2[i1 + (i0 << 2)] = 0.5 * d_xk[i1 + (i0 << 2)];
}
}
for (i0 = 0; i0 < 3; i0++) {
B = 0.0;
for (i1 = 0; i1 < 3; i1++) {
B += e_xk[i0 + 3 * i1] * wi[i1];
}
c_xk[i0] = vk_data[i0 + 3] - B;
}
for (i0 = 0; i0 < 4; i0++) {
xkPlus[i0] = 0.0;
for (i1 = 0; i1 < 3; i1++) {
xkPlus[i0] += dv2[i0 + (i1 << 2)] * c_xk[i1];
}
xdot[13 + i0] = xkPlus[i0];
}
/* time rate of relative position */
/* returns the cross product matrix of the vector x */
loop_ub = vk->size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
vk_data[i0] = vk->data[i0 + vk->size[0] * k];
}
loop_ub = xk_size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
b_xk_data[i0] = xk_data[i0 + xk_size[0] * k];
}
loop_ub = xk_size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
c_xk_data[i0] = xk_data[i0 + xk_size[0] * k];
}
dv4[0] = 0.0;
dv4[3] = -wi[2];
dv4[6] = wi[1];
dv4[1] = wi[2];
dv4[4] = 0.0;
dv4[7] = -wi[0];
dv4[2] = -wi[1];
dv4[5] = wi[0];
dv4[8] = 0.0;
for (i0 = 0; i0 < 3; i0++) {
b_xk[i0] = c_xk_data[i0 + 10];
}
for (i0 = 0; i0 < 3; i0++) {
B = 0.0;
for (i1 = 0; i1 < 3; i1++) {
B += dv4[i0 + 3 * i1] * b_xk[i1];
}
c_xk[i0] = (vk_data[i0 + 9] - b_xk_data[i0 + 3]) - B;
}
for (i0 = 0; i0 < 3; i0++) {
xdot[10 + i0] = c_xk[i0];
}
emlrtSizeEqCheck1DFastR2012b(xk_size[0], 17, &b_emlrtECI, emlrtRootTLSGlobal);
loop_ub = uv0[0];
for (i0 = 0; i0 < loop_ub; i0++) {
tmp_data[i0] = (uint8_T)i0;
}
i0 = uv0[1];
i1 = (int32_T)(1.0 + (real_T)k);
emlrtDynamicBoundsCheckFastR2012b(i1, 1, i0, &g_emlrtBCI, emlrtRootTLSGlobal);
iv0[0] = uv0[0];
emlrtSubAssignSizeCheckR2012b(iv0, 1, iv1, 1, &emlrtECI, emlrtRootTLSGlobal);
loop_ub = xk_size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
b_xk_data[i0] = xk_data[i0 + xk_size[0] * k];
}
loop_ub = xk_size[0];
for (i0 = 0; i0 < loop_ub; i0++) {
c_xk_data[i0] = b_xk_data[i0];
}
for (i0 = 0; i0 < 17; i0++) {
f_xk[i0] = c_xk_data[i0] + Ts * xdot[i0];
}
loop_ub = uv0[0];
for (i0 = 0; i0 < loop_ub; i0++) {
xkPlus_data[tmp_data[i0] + uv0[0] * k] = f_xk[i0];
}
/* re-normalize */
i0 = uv0[1];
i1 = (int32_T)(1.0 + (real_T)k);
emlrtDynamicBoundsCheckFastR2012b(i1, 1, i0, &f_emlrtBCI, emlrtRootTLSGlobal);
for (i0 = 0; i0 < 4; i0++) {
i1 = uv0[0];
loop_ub = 7 + i0;
emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i1, &t_emlrtBCI,
emlrtRootTLSGlobal);
}
i0 = uv0[1];
i1 = 1 + k;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, i0, &e_emlrtBCI, emlrtRootTLSGlobal);
for (i0 = 0; i0 < 4; i0++) {
i1 = uv0[0];
loop_ub = 7 + i0;
xkPlus[i0] = xkPlus_data[(emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i1,
&u_emlrtBCI, emlrtRootTLSGlobal) + uv0[0] * k) - 1];
}
B = norm(xkPlus);
i0 = uv0[1];
i1 = 1 + k;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, i0, &d_emlrtBCI, emlrtRootTLSGlobal);
for (i0 = 0; i0 < 4; i0++) {
xkPlus[i0] = xkPlus_data[(i0 + uv0[0] * k) + 6] / B;
}
for (i0 = 0; i0 < 4; i0++) {
i1 = uv0[0];
loop_ub = 7 + i0;
xkPlus_data[(emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i1, &v_emlrtBCI,
emlrtRootTLSGlobal) + uv0[0] * k) - 1] = xkPlus[i0];
}
i0 = uv0[1];
i1 = (int32_T)(1.0 + (real_T)k);
emlrtDynamicBoundsCheckFastR2012b(i1, 1, i0, &c_emlrtBCI, emlrtRootTLSGlobal);
for (i0 = 0; i0 < 4; i0++) {
i1 = uv0[0];
loop_ub = 14 + i0;
emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i1, &w_emlrtBCI,
emlrtRootTLSGlobal);
}
i0 = uv0[1];
i1 = 1 + k;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, i0, &b_emlrtBCI, emlrtRootTLSGlobal);
for (i0 = 0; i0 < 4; i0++) {
i1 = uv0[0];
loop_ub = 14 + i0;
xkPlus[i0] = xkPlus_data[(emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i1,
&x_emlrtBCI, emlrtRootTLSGlobal) + uv0[0] * k) - 1];
}
B = norm(xkPlus);
i0 = uv0[1];
i1 = 1 + k;
emlrtDynamicBoundsCheckFastR2012b(i1, 1, i0, &emlrtBCI, emlrtRootTLSGlobal);
for (i0 = 0; i0 < 4; i0++) {
xkPlus[i0] = xkPlus_data[(i0 + uv0[0] * k) + 13] / B;
}
for (i0 = 0; i0 < 4; i0++) {
i1 = uv0[0];
loop_ub = 14 + i0;
xkPlus_data[(emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i1, &y_emlrtBCI,
emlrtRootTLSGlobal) + uv0[0] * k) - 1] = xkPlus[i0];
}
k++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal);
}
}
/* Function Definitions */
real_T Dcoeff(const emlrtStack *sp, const emxArray_real_T *y, real_T j, const
emxArray_real_T *x, real_T t, const emxArray_real_T *timePoints,
const emxArray_real_T *f)
{
real_T vals;
emxArray_real_T *a;
int32_T i11;
int32_T unnamed_idx_1;
emxArray_real_T *r4;
int32_T i12;
int32_T i13;
int32_T i14;
int32_T i15;
int32_T i16;
int32_T i17;
int32_T i18;
int32_T i19;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
emxInit_real_T(sp, &a, 2, &e_emlrtRTEI, true);
/* Calculate the integral int_0^1(f(y,t_j)*A_{yj}(x,t)dy) by midpoint */
/* integration rule */
/* the spatial integration of all points y at time t_j */
i11 = a->size[0] * a->size[1];
a->size[0] = 1;
emxEnsureCapacity(sp, (emxArray__common *)a, i11, (int32_T)sizeof(real_T),
&d_emlrtRTEI);
unnamed_idx_1 = y->size[1];
i11 = a->size[0] * a->size[1];
a->size[1] = unnamed_idx_1;
emxEnsureCapacity(sp, (emxArray__common *)a, i11, (int32_T)sizeof(real_T),
&d_emlrtRTEI);
unnamed_idx_1 = y->size[1];
for (i11 = 0; i11 < unnamed_idx_1; i11++) {
a->data[i11] = 0.0;
}
emxInit_real_T(sp, &r4, 2, &d_emlrtRTEI, true);
vals = 0.0;
i11 = y->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i11, &ib_emlrtBCI, sp);
st.site = &q_emlrtRSI;
b_Acoeff(&st, y->data[0], j, x, t, timePoints, r4);
i11 = r4->size[1];
emlrtSizeEqCheck1DFastR2012b(1, i11, &c_emlrtECI, sp);
unnamed_idx_1 = y->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, unnamed_idx_1, &jb_emlrtBCI, sp);
i11 = r4->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i11, &kb_emlrtBCI, sp);
a->data[0] = r4->data[0];
unnamed_idx_1 = 2;
while (unnamed_idx_1 - 2 <= y->size[1] - 2) {
i11 = y->size[1];
st.site = &r_emlrtRSI;
b_Acoeff(&st, y->data[emlrtDynamicBoundsCheckFastR2012b(unnamed_idx_1, 1,
i11, &mb_emlrtBCI, sp) - 1], j, x, t, timePoints, r4);
i11 = r4->size[1];
emlrtSizeEqCheck1DFastR2012b(1, i11, &d_emlrtECI, sp);
i11 = r4->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i11, &lb_emlrtBCI, sp);
i11 = a->size[1];
a->data[emlrtDynamicBoundsCheckFastR2012b(unnamed_idx_1, 1, i11,
&nb_emlrtBCI, sp) - 1] = r4->data[0];
i11 = a->size[1];
i12 = f->size[1];
i13 = a->size[1];
i14 = unnamed_idx_1 - 1;
i15 = f->size[1];
i16 = unnamed_idx_1 - 1;
i17 = y->size[1];
i18 = y->size[1];
i19 = unnamed_idx_1 - 1;
vals += 0.5 * (a->data[emlrtDynamicBoundsCheckFastR2012b(unnamed_idx_1, 1,
i11, &ob_emlrtBCI, sp) - 1] * f->data[emlrtDynamicBoundsCheckFastR2012b
(unnamed_idx_1, 1, i12, &pb_emlrtBCI, sp) - 1] + a->
data[emlrtDynamicBoundsCheckFastR2012b(i14, 1, i13,
&qb_emlrtBCI, sp) - 1] * f->data[emlrtDynamicBoundsCheckFastR2012b(i16, 1,
i15, &rb_emlrtBCI, sp) - 1]) * (y->data[emlrtDynamicBoundsCheckFastR2012b
(unnamed_idx_1, 1, i17, &sb_emlrtBCI, sp) - 1] - y->
data[emlrtDynamicBoundsCheckFastR2012b(i19, 1, i18, &tb_emlrtBCI, sp) - 1]);
unnamed_idx_1++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
emxFree_real_T(&r4);
emxFree_real_T(&a);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
return vals;
}
/* 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);
}
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[17];
int32_T j;
int32_T b_i;
real_T normA;
real_T y[289];
real_T F[289];
boolean_T exitg2;
real_T s;
boolean_T exitg1;
static const real_T theta[5] = { 0.01495585217958292, 0.253939833006323,
0.95041789961629319, 2.097847961257068, 5.3719203511481517 };
static const int8_T iv2[5] = { 3, 5, 7, 9, 13 };
int32_T eint;
real_T b_y[289];
real_T beta1;
char_T TRANSB;
char_T TRANSA;
ptrdiff_t m_t;
ptrdiff_t n_t;
ptrdiff_t k_t;
ptrdiff_t lda_t;
ptrdiff_t ldb_t;
ptrdiff_t ldc_t;
double * alpha1_t;
double * Aia0_t;
double * Bib0_t;
double * beta1_t;
double * Cic0_t;
emlrtPushRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
Q[0] = -k2 * A - L2 * J;
Q[17] = k2 * A;
Q[34] = L2 * J;
Q[51] = 0.0;
Q[68] = 0.0;
Q[85] = 0.0;
Q[102] = 0.0;
Q[119] = 0.0;
Q[136] = 0.0;
Q[153] = 0.0;
Q[170] = 0.0;
Q[187] = 0.0;
Q[204] = 0.0;
Q[221] = 0.0;
Q[238] = 0.0;
Q[255] = 0.0;
Q[272] = 0.0;
Q[1] = k1;
Q[18] = ((-k1 - k4 * A) - H2) - L2 * J;
Q[35] = 0.0;
Q[52] = L2 * J;
Q[69] = 0.0;
Q[86] = 0.0;
Q[103] = k4 * A;
Q[120] = 0.0;
Q[137] = 0.0;
Q[154] = 0.0;
Q[171] = 0.0;
Q[188] = 0.0;
Q[205] = 0.0;
Q[222] = H2;
Q[239] = 0.0;
Q[256] = 0.0;
Q[273] = 0.0;
Q[2] = L1;
Q[19] = 0.0;
Q[36] = (-k8 * A - L1) - L4 * J;
Q[53] = k8 * A;
Q[70] = L4 * J;
Q[87] = 0.0;
Q[104] = 0.0;
Q[121] = 0.0;
Q[138] = 0.0;
Q[155] = 0.0;
Q[172] = 0.0;
Q[189] = 0.0;
Q[206] = 0.0;
Q[223] = 0.0;
Q[240] = 0.0;
Q[257] = 0.0;
Q[274] = 0.0;
Q[3] = 0.0;
Q[20] = L1;
Q[37] = k7;
Q[54] = ((-k7 - k10 * A) - L1) - L4 * J;
Q[71] = 0.0;
Q[88] = L4 * J;
Q[105] = 0.0;
Q[122] = 0.0;
Q[139] = k10 * A;
Q[156] = 0.0;
Q[173] = 0.0;
Q[190] = 0.0;
Q[207] = 0.0;
Q[224] = 0.0;
Q[241] = 0.0;
Q[258] = 0.0;
Q[275] = 0.0;
Q[4] = 0.0;
Q[21] = 0.0;
Q[38] = L3;
Q[55] = 0.0;
Q[72] = -k8 * alpha * A - L3;
Q[89] = k8 * alpha * A;
Q[106] = 0.0;
Q[123] = 0.0;
Q[140] = 0.0;
Q[157] = 0.0;
Q[174] = 0.0;
Q[191] = 0.0;
Q[208] = 0.0;
Q[225] = 0.0;
Q[242] = 0.0;
Q[259] = 0.0;
Q[276] = 0.0;
Q[5] = 0.0;
Q[22] = 0.0;
Q[39] = 0.0;
Q[56] = L3;
Q[73] = k7;
Q[90] = (-k7 - k10 * alpha * A) - L3;
Q[107] = 0.0;
Q[124] = 0.0;
Q[141] = 0.0;
Q[158] = 0.0;
Q[175] = k10 * alpha * A;
Q[192] = 0.0;
Q[209] = 0.0;
Q[226] = 0.0;
Q[243] = 0.0;
Q[260] = 0.0;
Q[277] = 0.0;
Q[6] = 0.0;
Q[23] = k3;
Q[40] = 0.0;
Q[57] = 0.0;
Q[74] = 0.0;
Q[91] = 0.0;
Q[108] = ((-k3 - k6 * A) - H2) - L2 * J;
Q[125] = k6 * A;
Q[142] = L2 * J;
Q[159] = 0.0;
Q[176] = 0.0;
Q[193] = 0.0;
Q[210] = 0.0;
Q[227] = 0.0;
Q[244] = H2;
Q[261] = 0.0;
Q[278] = 0.0;
Q[7] = 0.0;
Q[24] = 0.0;
Q[41] = 0.0;
Q[58] = 0.0;
Q[75] = 0.0;
Q[92] = 0.0;
Q[109] = k5;
Q[126] = (-k5 - H2) - L2 * J;
Q[143] = 0.0;
Q[160] = L2 * J;
Q[177] = 0.0;
Q[194] = 0.0;
Q[211] = 0.0;
Q[228] = 0.0;
Q[245] = 0.0;
Q[262] = H2;
Q[279] = 0.0;
Q[8] = 0.0;
Q[25] = 0.0;
Q[42] = 0.0;
Q[59] = k9;
Q[76] = 0.0;
Q[93] = 0.0;
Q[110] = L1;
Q[127] = 0.0;
Q[144] = ((-k9 - k12 * A) - L1) - L4 * J;
Q[161] = k12 * A;
Q[178] = L4 * J;
Q[195] = 0.0;
Q[212] = 0.0;
Q[229] = 0.0;
Q[246] = 0.0;
Q[263] = 0.0;
Q[280] = 0.0;
Q[9] = 0.0;
Q[26] = 0.0;
Q[43] = 0.0;
Q[60] = 0.0;
Q[77] = 0.0;
Q[94] = 0.0;
Q[111] = 0.0;
Q[128] = L1;
Q[145] = k11;
Q[162] = (-k11 - L1) - L4 * J;
Q[179] = 0.0;
Q[196] = L4 * J;
Q[213] = 0.0;
Q[230] = 0.0;
Q[247] = 0.0;
Q[264] = 0.0;
Q[281] = 0.0;
Q[10] = 0.0;
Q[27] = 0.0;
Q[44] = 0.0;
Q[61] = 0.0;
Q[78] = 0.0;
Q[95] = k9;
Q[112] = 0.0;
Q[129] = 0.0;
Q[146] = L3;
Q[163] = 0.0;
Q[180] = (-k9 - k12 * alpha * A) - L3;
Q[197] = k12 * alpha * A;
Q[214] = 0.0;
Q[231] = 0.0;
Q[248] = 0.0;
Q[265] = 0.0;
Q[282] = 0.0;
Q[11] = 0.0;
Q[28] = 0.0;
Q[45] = 0.0;
Q[62] = 0.0;
Q[79] = 0.0;
Q[96] = 0.0;
Q[113] = 0.0;
Q[130] = 0.0;
Q[147] = 0.0;
Q[164] = L3;
Q[181] = k11;
Q[198] = -k11 - L3;
Q[215] = 0.0;
Q[232] = 0.0;
Q[249] = 0.0;
Q[266] = 0.0;
Q[283] = 0.0;
Q[12] = H1;
Q[29] = 0.0;
Q[46] = 0.0;
Q[63] = 0.0;
Q[80] = 0.0;
Q[97] = 0.0;
Q[114] = 0.0;
Q[131] = 0.0;
Q[148] = 0.0;
Q[165] = 0.0;
Q[182] = 0.0;
Q[199] = 0.0;
Q[216] = -k2 * A - H1;
Q[233] = k2 * A;
Q[250] = 0.0;
Q[267] = 0.0;
Q[284] = 0.0;
Q[13] = 0.0;
Q[30] = 0.0;
Q[47] = 0.0;
Q[64] = 0.0;
Q[81] = 0.0;
Q[98] = 0.0;
Q[115] = 0.0;
Q[132] = 0.0;
Q[149] = 0.0;
Q[166] = 0.0;
Q[183] = 0.0;
Q[200] = 0.0;
Q[217] = k1;
Q[234] = -k1 - k4 * A;
Q[251] = k4 * A;
Q[268] = 0.0;
Q[285] = 0.0;
Q[14] = 0.0;
Q[31] = 0.0;
Q[48] = 0.0;
Q[65] = 0.0;
Q[82] = 0.0;
Q[99] = 0.0;
Q[116] = 0.0;
Q[133] = 0.0;
Q[150] = 0.0;
Q[167] = 0.0;
Q[184] = 0.0;
Q[201] = 0.0;
Q[218] = 0.0;
Q[235] = k3;
Q[252] = -k3 - k6 * A;
Q[269] = k6 * A;
Q[286] = 0.0;
Q[15] = 0.0;
Q[32] = 0.0;
Q[49] = 0.0;
Q[66] = 0.0;
Q[83] = 0.0;
Q[100] = 0.0;
Q[117] = 0.0;
Q[134] = 0.0;
Q[151] = 0.0;
Q[168] = 0.0;
Q[185] = 0.0;
Q[202] = 0.0;
Q[219] = 0.0;
Q[236] = 0.0;
Q[253] = k5;
Q[270] = -k5 - H3;
Q[287] = H3;
Q[16] = H4;
Q[33] = 0.0;
Q[50] = 0.0;
Q[67] = 0.0;
Q[84] = 0.0;
Q[101] = 0.0;
Q[118] = 0.0;
Q[135] = 0.0;
Q[152] = 0.0;
Q[169] = 0.0;
Q[186] = 0.0;
Q[203] = 0.0;
Q[220] = 0.0;
Q[237] = 0.0;
Q[254] = 0.0;
Q[271] = 0.0;
Q[288] = -H4;
Q_dirty |= 1U;
emlrtPopRtStackR2012b(&db_emlrtRSI, emlrtRootTLSGlobal);
i = 0;
while (i <= T->size[0] - 1) {
emlrtPushRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
memcpy(&hoistedGlobal[0], &p0[0], 17U * sizeof(real_T));
j = T->size[0];
b_i = (int32_T)(1.0 + (real_T)i);
emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &bd_emlrtBCI,
emlrtRootTLSGlobal);
normA = T->data[i];
for (j = 0; j < 289; j++) {
y[j] = Q[j] * normA;
}
normA = 0.0;
j = 0;
exitg2 = FALSE;
while ((exitg2 == FALSE) && (j < 17)) {
s = 0.0;
for (b_i = 0; b_i < 17; b_i++) {
s += muDoubleScalarAbs(y[b_i + 17 * j]);
}
if (muDoubleScalarIsNaN(s)) {
normA = rtNaN;
exitg2 = TRUE;
} else {
if (s > normA) {
normA = s;
}
j++;
}
}
if (normA <= 5.3719203511481517) {
b_i = 0;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (b_i < 5)) {
if (normA <= theta[b_i]) {
emlrtPushRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
PadeApproximantOfDegree(y, iv2[b_i], F);
emlrtPopRtStackR2012b(&fb_emlrtRSI, emlrtRootTLSGlobal);
exitg1 = TRUE;
} else {
b_i++;
}
}
} else {
normA /= 5.3719203511481517;
if ((!muDoubleScalarIsInf(normA)) && (!muDoubleScalarIsNaN(normA))) {
normA = frexp(normA, &eint);
j = eint;
} else {
j = 0;
}
s = j;
if (normA == 0.5) {
s = (real_T)j - 1.0;
}
normA = muDoubleScalarPower(2.0, s);
emlrtPushRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal);
for (j = 0; j < 289; j++) {
b_y[j] = y[j] / normA;
}
PadeApproximantOfDegree(b_y, 13.0, F);
emlrtPopRtStackR2012b(&gb_emlrtRSI, emlrtRootTLSGlobal);
emlrtForLoopVectorCheckR2012b(1.0, 1.0, s, mxDOUBLE_CLASS, (int32_T)s,
&l_emlrtRTEI, emlrtRootTLSGlobal);
for (j = 0; j < (int32_T)s; j++) {
emlrtPushRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal);
memcpy(&y[0], &F[0], 289U * sizeof(real_T));
emlrtPushRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal);
normA = 1.0;
beta1 = 0.0;
TRANSB = 'N';
TRANSA = 'N';
memset(&F[0], 0, 289U * sizeof(real_T));
emlrtPushRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
m_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&wb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&xb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
n_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&xb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&yb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
k_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&yb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ac_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
lda_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ac_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&bc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldb_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&bc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&cc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
ldc_t = (ptrdiff_t)(17);
emlrtPopRtStackR2012b(&jc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&cc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&dc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
alpha1_t = (double *)(&normA);
emlrtPopRtStackR2012b(&dc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Aia0_t = (double *)(&y[0]);
emlrtPopRtStackR2012b(&ec_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&fc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Bib0_t = (double *)(&y[0]);
emlrtPopRtStackR2012b(&fc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
beta1_t = (double *)(&beta1);
emlrtPopRtStackR2012b(&gc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&hc_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
Cic0_t = (double *)(&F[0]);
emlrtPopRtStackR2012b(&hc_emlrtRSI, emlrtRootTLSGlobal);
emlrtPushRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
emlrt_checkEscapedGlobals();
dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, alpha1_t, Aia0_t, &lda_t,
Bib0_t, &ldb_t, beta1_t, Cic0_t, &ldc_t);
emlrtPopRtStackR2012b(&ic_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&vb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&ub_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&tb_emlrtRSI, emlrtRootTLSGlobal);
emlrtPopRtStackR2012b(&hb_emlrtRSI, emlrtRootTLSGlobal);
}
}
for (j = 0; j < 17; j++) {
p0[j] = 0.0;
for (b_i = 0; b_i < 17; b_i++) {
p0[j] += hoistedGlobal[b_i] * F[b_i + 17 * j];
}
}
p0_dirty |= 1U;
emlrtPopRtStackR2012b(&eb_emlrtRSI, emlrtRootTLSGlobal);
j = I->size[0];
b_i = 1 + i;
normA = Acell * 1.0E+12 * (g1 * (p0[6] + p0[7]) * (V - E1) + g2 * (((p0[8] +
p0[9]) + p0[10]) + p0[11]) * (V - E2)) - I->
data[emlrtDynamicBoundsCheckFastR2012b(b_i, 1, j, &cd_emlrtBCI,
emlrtRootTLSGlobal) - 1];
normA = muDoubleScalarAbs(normA);
err += normA * normA;
err_dirty |= 1U;
i++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, emlrtRootTLSGlobal);
}
}
/* Function Definitions */
real_T Dcoeff(const emlrtStack *sp, const emxArray_real_T *y, real_T j, const
emxArray_real_T *x, real_T t, const emxArray_real_T *gridT, const
emxArray_real_T *f)
{
real_T vals;
emxArray_real_T *a;
int32_T i57;
int32_T unnamed_idx_1;
emxArray_real_T *r7;
int32_T i58;
int32_T i59;
int32_T i60;
int32_T i61;
int32_T i62;
int32_T i63;
int32_T i64;
int32_T i65;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
emxInit_real_T(sp, &a, 2, &c_emlrtRTEI, true);
/* Calculate the integral int_0^1(f(y,t_j)*A_{yj}(x,t)dy) by midpoint */
/* integration rule */
/* the spatial integration of all points y at time t_j */
i57 = a->size[0] * a->size[1];
a->size[0] = 1;
emxEnsureCapacity(sp, (emxArray__common *)a, i57, (int32_T)sizeof(real_T),
&g_emlrtRTEI);
unnamed_idx_1 = y->size[1];
i57 = a->size[0] * a->size[1];
a->size[1] = unnamed_idx_1;
emxEnsureCapacity(sp, (emxArray__common *)a, i57, (int32_T)sizeof(real_T),
&g_emlrtRTEI);
unnamed_idx_1 = y->size[1];
for (i57 = 0; i57 < unnamed_idx_1; i57++) {
a->data[i57] = 0.0;
}
emxInit_real_T(sp, &r7, 2, &g_emlrtRTEI, true);
vals = 0.0;
i57 = y->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i57, &kb_emlrtBCI, sp);
st.site = &v_emlrtRSI;
b_Acoeff(&st, y->data[0], j, x, t, gridT, r7);
i57 = r7->size[1];
emlrtSizeEqCheck1DFastR2012b(1, i57, &k_emlrtECI, sp);
unnamed_idx_1 = y->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, unnamed_idx_1, &jb_emlrtBCI, sp);
i57 = r7->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i57, &pe_emlrtBCI, sp);
a->data[0] = r7->data[0];
/* y = 0:1/(numel(y)-2):1; */
unnamed_idx_1 = 2;
while (unnamed_idx_1 - 2 <= f->size[1] - 2) {
i57 = y->size[1];
st.site = &w_emlrtRSI;
b_Acoeff(&st, y->data[emlrtDynamicBoundsCheckFastR2012b(unnamed_idx_1, 1,
i57, &hc_emlrtBCI, sp) - 1], j, x, t, gridT, r7);
i57 = r7->size[1];
emlrtSizeEqCheck1DFastR2012b(1, i57, &l_emlrtECI, sp);
i57 = r7->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i57, &qe_emlrtBCI, sp);
i57 = a->size[1];
a->data[emlrtDynamicBoundsCheckFastR2012b(unnamed_idx_1, 1, i57,
&gc_emlrtBCI, sp) - 1] = r7->data[0];
i57 = a->size[1];
i58 = f->size[1];
i59 = a->size[1];
i60 = unnamed_idx_1 - 1;
i61 = f->size[1];
i62 = unnamed_idx_1 - 1;
i63 = y->size[1];
i64 = y->size[1];
i65 = unnamed_idx_1 - 1;
vals += 0.5 * (a->data[emlrtDynamicBoundsCheckFastR2012b(unnamed_idx_1, 1,
i57, &ic_emlrtBCI, sp) - 1] * f->data[emlrtDynamicBoundsCheckFastR2012b
(unnamed_idx_1, 1, i58, &ib_emlrtBCI, sp) - 1] + a->
data[emlrtDynamicBoundsCheckFastR2012b(i60, 1, i59,
&jc_emlrtBCI, sp) - 1] * f->data[emlrtDynamicBoundsCheckFastR2012b(i62, 1,
i61, &hb_emlrtBCI, sp) - 1]) * (y->data[emlrtDynamicBoundsCheckFastR2012b
(unnamed_idx_1, 1, i63, &kc_emlrtBCI, sp) - 1] - y->
data[emlrtDynamicBoundsCheckFastR2012b(i65, 1, i64, &lc_emlrtBCI, sp) - 1]);
unnamed_idx_1++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
emxFree_real_T(&r7);
emxFree_real_T(&a);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
return vals;
}
real_T b_Dcoeff(const emlrtStack *sp, const emxArray_real_T *y, real_T j, real_T
x, real_T t, const emxArray_real_T *gridT, const emxArray_real_T
*f)
{
real_T vals;
emxArray_real_T *a;
int32_T i25;
int32_T unnamed_idx_1;
int32_T i26;
int32_T i27;
int32_T i28;
int32_T i29;
int32_T i30;
int32_T i31;
int32_T i32;
int32_T i33;
emlrtStack st;
st.prev = sp;
st.tls = sp->tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
emxInit_real_T(sp, &a, 2, &c_emlrtRTEI, true);
/* Calculate the integral int_0^1(f(y,t_j)*A_{yj}(x,t)dy) by midpoint */
/* integration rule */
/* the spatial integration of all points y at time t_j */
i25 = a->size[0] * a->size[1];
a->size[0] = 1;
emxEnsureCapacity(sp, (emxArray__common *)a, i25, (int32_T)sizeof(real_T),
&g_emlrtRTEI);
unnamed_idx_1 = y->size[1];
i25 = a->size[0] * a->size[1];
a->size[1] = unnamed_idx_1;
emxEnsureCapacity(sp, (emxArray__common *)a, i25, (int32_T)sizeof(real_T),
&g_emlrtRTEI);
unnamed_idx_1 = y->size[1];
for (i25 = 0; i25 < unnamed_idx_1; i25++) {
a->data[i25] = 0.0;
}
vals = 0.0;
unnamed_idx_1 = y->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, unnamed_idx_1, &jb_emlrtBCI, sp);
i25 = y->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i25, &kb_emlrtBCI, sp);
st.site = &v_emlrtRSI;
a->data[0] = Acoeff(&st, y->data[0], j, x, t, gridT);
/* y = 0:1/(numel(y)-2):1; */
unnamed_idx_1 = 2;
while (unnamed_idx_1 - 2 <= f->size[1] - 2) {
i25 = a->size[1];
i26 = y->size[1];
st.site = &w_emlrtRSI;
a->data[emlrtDynamicBoundsCheckFastR2012b(unnamed_idx_1, 1, i25,
&gc_emlrtBCI, sp) - 1] = Acoeff(&st, y->
data[emlrtDynamicBoundsCheckFastR2012b(unnamed_idx_1, 1, i26, &hc_emlrtBCI,
sp) - 1], j, x, t, gridT);
i25 = a->size[1];
i26 = f->size[1];
i27 = a->size[1];
i28 = unnamed_idx_1 - 1;
i29 = f->size[1];
i30 = unnamed_idx_1 - 1;
i31 = y->size[1];
i32 = y->size[1];
i33 = unnamed_idx_1 - 1;
vals += 0.5 * (a->data[emlrtDynamicBoundsCheckFastR2012b(unnamed_idx_1, 1,
i25, &ic_emlrtBCI, sp) - 1] * f->data[emlrtDynamicBoundsCheckFastR2012b
(unnamed_idx_1, 1, i26, &ib_emlrtBCI, sp) - 1] + a->
data[emlrtDynamicBoundsCheckFastR2012b(i28, 1, i27,
&jc_emlrtBCI, sp) - 1] * f->data[emlrtDynamicBoundsCheckFastR2012b(i30, 1,
i29, &hb_emlrtBCI, sp) - 1]) * (y->data[emlrtDynamicBoundsCheckFastR2012b
(unnamed_idx_1, 1, i31, &kc_emlrtBCI, sp) - 1] - y->
data[emlrtDynamicBoundsCheckFastR2012b(i33, 1, i32, &lc_emlrtBCI, sp) - 1]);
unnamed_idx_1++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
emxFree_real_T(&a);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
return vals;
}
void locateShortpreamble(const emlrtStack *sp, const real_T M_data[1224], real_T
*preambleEstimatedLocation, real_T *numPeaks)
{
int32_T ixstart;
real_T thresholdNorm;
int32_T ix;
boolean_T exitg1;
boolean_T b_M_data[1224];
int32_T ii_size[1];
int32_T ii_data[1224];
int32_T MLocations_size_idx_0;
int32_T loop_ub;
real_T MLocations_data[1224];
int16_T unnamed_idx_0;
int32_T peaks_data[1224];
int32_T i20;
real_T b_MLocations_data[1224];
int32_T MLocations_size[1];
real_T MLocations[8];
int32_T ib_size[1];
int32_T ib_data[8];
int32_T ia_size[1];
int32_T ia_data[8];
int32_T c_size[1];
real_T c_data[8];
int32_T peaks_size[1];
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;
/* Locate of the start of the actual preamble from timing metric */
/* % Find peaks of correlation */
/* Adjust threshold */
st.site = &pp_emlrtRSI;
b_st.site = &we_emlrtRSI;
ixstart = 1;
thresholdNorm = M_data[0];
if (muDoubleScalarIsNaN(M_data[0])) {
ix = 2;
exitg1 = FALSE;
while ((exitg1 == FALSE) && (ix <= 1224)) {
ixstart = ix;
if (!muDoubleScalarIsNaN(M_data[ix - 1])) {
thresholdNorm = M_data[ix - 1];
exitg1 = TRUE;
} else {
ix++;
}
}
}
if (ixstart < 1224) {
while (ixstart + 1 <= 1224) {
if (M_data[ixstart] > thresholdNorm) {
thresholdNorm = M_data[ixstart];
}
ixstart++;
}
}
st.site = &pp_emlrtRSI;
thresholdNorm *= 0.6;
st.site = &qp_emlrtRSI;
for (ixstart = 0; ixstart < 1224; ixstart++) {
b_M_data[ixstart] = (M_data[ixstart] > thresholdNorm);
}
b_st.site = &vc_emlrtRSI;
b_eml_find(b_M_data, ii_data, ii_size);
/* Correct estimate to start of preamble not its center */
MLocations_size_idx_0 = ii_size[0];
loop_ub = ii_size[0];
for (ixstart = 0; ixstart < loop_ub; ixstart++) {
MLocations_data[ixstart] = (real_T)ii_data[ixstart] - 9.0;
}
/* Frame Detection */
unnamed_idx_0 = (int16_T)ii_size[0];
loop_ub = (int16_T)ii_size[0];
for (ixstart = 0; ixstart < loop_ub; ixstart++) {
peaks_data[ixstart] = 0;
}
/* Determine correct peak */
st.site = &rp_emlrtRSI;
ix = 0;
while (ix <= ii_size[0] - 1) {
ixstart = ix + 1;
emlrtDynamicBoundsCheckFastR2012b(ixstart, 1, ii_size[0], &cb_emlrtBCI, sp);
if (ix + 1 > ii_size[0]) {
ixstart = 1;
i20 = 1;
} else {
ixstart = emlrtDynamicBoundsCheckFastR2012b(ix + 1, 1, ii_size[0],
&db_emlrtBCI, sp);
i20 = emlrtDynamicBoundsCheckFastR2012b(ii_size[0], 1, ii_size[0],
&db_emlrtBCI, sp) + 1;
}
emlrtVectorVectorIndexCheckR2012b(ii_size[0], 1, 1, i20 - ixstart,
&s_emlrtECI, sp);
st.site = &sp_emlrtRSI;
b_st.site = &eq_emlrtRSI;
MLocations_size[0] = i20 - ixstart;
loop_ub = i20 - ixstart;
for (i20 = 0; i20 < loop_ub; i20++) {
b_MLocations_data[i20] = MLocations_data[(ixstart + i20) - 1];
}
for (ixstart = 0; ixstart < 8; ixstart++) {
MLocations[ixstart] = MLocations_data[ix] + (16.0 + 16.0 * (real_T)ixstart);
}
c_st.site = &fq_emlrtRSI;
do_vectors(&c_st, b_MLocations_data, MLocations_size, MLocations, c_data,
c_size, ia_data, ia_size, ib_data, ib_size);
st.site = &sp_emlrtRSI;
ixstart = (int16_T)ii_size[0];
peaks_data[emlrtDynamicBoundsCheckFastR2012b(ix + 1, 1, ixstart,
&gb_emlrtBCI, sp) - 1] = c_size[0];
ix++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
/* Have at least 5 peaks for positive match */
/* (TUNABLE) */
peaks_size[0] = (int16_T)ii_size[0];
loop_ub = (int16_T)ii_size[0];
for (ixstart = 0; ixstart < loop_ub; ixstart++) {
b_M_data[ixstart] = (peaks_data[ixstart] < 7);
}
st.site = &tp_emlrtRSI;
eml_li_find(&st, b_M_data, peaks_size, ii_data, ii_size);
loop_ub = ii_size[0];
for (ixstart = 0; ixstart < loop_ub; ixstart++) {
i20 = (int16_T)MLocations_size_idx_0;
peaks_data[emlrtDynamicBoundsCheckFastR2012b(ii_data[ixstart], 1, i20,
&eb_emlrtBCI, sp) - 1] = 0;
}
/* Pick earliest peak in time */
if (!(unnamed_idx_0 == 0)) {
st.site = &up_emlrtRSI;
b_st.site = &ir_emlrtRSI;
ixstart = peaks_data[0];
loop_ub = 1;
if (unnamed_idx_0 > 1) {
for (ix = 2; ix <= unnamed_idx_0; ix++) {
if (peaks_data[ix - 1] > ixstart) {
ixstart = peaks_data[ix - 1];
loop_ub = ix;
}
}
}
*numPeaks = ixstart;
if (ixstart > 0) {
*preambleEstimatedLocation =
MLocations_data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1,
MLocations_size_idx_0, &fb_emlrtBCI, sp) - 1];
} else {
*preambleEstimatedLocation = -1.0;
/* no desirable location found */
}
} else {
*preambleEstimatedLocation = -1.0;
*numPeaks = 0.0;
}
/* Normalize max peaks found */
st.site = &vp_emlrtRSI;
b_st.site = &j_emlrtRSI;
*numPeaks /= 8.0;
}
/* Function Definitions */
void OFDMbits2letters(const emlrtStack *sp, const boolean_T bits_data[560],
const int32_T bits_size[2], real_T Letters_data[80],
int32_T Letters_size[1])
{
real_T a;
int32_T i32;
int32_T i33;
boolean_T p;
const mxArray *y;
static const int32_T iv237[2] = { 1, 28 };
const mxArray *m43;
char_T cv284[28];
int32_T i;
static const char_T cv285[28] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'N', 'o', 'n', 'I', 'n', 't', 'e', 'g', 'e', 'r', 'I',
'n', 'p', 'u', 't' };
const mxArray *b_y;
const mxArray *c_y;
int32_T maxdimlen;
boolean_T y_data[560];
const mxArray *d_y;
static const int32_T iv238[2] = { 1, 40 };
char_T cv286[40];
static const char_T cv287[40] = { 'C', 'o', 'd', 'e', 'r', ':', 'M', 'A', 'T',
'L', 'A', 'B', ':', 'g', 'e', 't', 'R', 'e', 's', 'h', 'a', 'p', 'e', 'D',
'i', 'm', 's', '_', 'n', 'o', 't', 'S', 'a', 'm', 'e', 'N', 'u', 'm', 'e',
'l' };
boolean_T b_bits_data[560];
char_T s[7];
int32_T exitg1;
const mxArray *e_y;
static const int32_T iv239[2] = { 1, 34 };
char_T cv288[34];
static const char_T cv289[34] = { 'M', 'A', 'T', 'L', 'A', 'B', ':', 'b', 'i',
'n', '2', 'd', 'e', 'c', ':', 'I', 'l', 'l', 'e', 'g', 'a', 'l', 'B', 'i',
'n', 'a', 'r', 'y', 'S', 't', 'r', 'i', 'n', 'g' };
real_T varargin_1;
real_T p2;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
emlrtStack e_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &b_st;
d_st.tls = b_st.tls;
e_st.prev = &st;
e_st.tls = st.tls;
/* OFDMbits2letters: Convert input bits from a double array to ascii */
/* integers, which can be converted to letters by the char() function */
/* Make input into column */
/* Trim extra bits */
st.site = &qab_emlrtRSI;
st.site = &qab_emlrtRSI;
b_st.site = &m_emlrtRSI;
c_st.site = &n_emlrtRSI;
a = (real_T)(bits_size[0] * bits_size[1]) / 7.0;
st.site = &qab_emlrtRSI;
b_floor(&a);
st.site = &qab_emlrtRSI;
a *= 7.0;
if (1.0 > a) {
i32 = 0;
} else {
i32 = bits_size[0] * bits_size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i32, &rb_emlrtBCI, sp);
i32 = bits_size[0] * bits_size[1];
i33 = (int32_T)a;
i32 = emlrtDynamicBoundsCheckFastR2012b(i33, 1, i32, &rb_emlrtBCI, sp);
}
emlrtVectorVectorIndexCheckR2012b(bits_size[0] * bits_size[1], 1, 1, i32,
&x_emlrtECI, sp);
/* Shape into letters */
st.site = &rab_emlrtRSI;
st.site = &rab_emlrtRSI;
b_st.site = &m_emlrtRSI;
c_st.site = &n_emlrtRSI;
a = (real_T)i32 / 7.0;
st.site = &rab_emlrtRSI;
b_st.site = &tab_emlrtRSI;
c_st.site = &uab_emlrtRSI;
if (a != muDoubleScalarFloor(a)) {
p = FALSE;
} else {
p = TRUE;
}
if (p) {
c_st.site = &uab_emlrtRSI;
p = TRUE;
} else {
p = FALSE;
}
if (p) {
} else {
y = NULL;
m43 = mxCreateCharArray(2, iv237);
for (i = 0; i < 28; i++) {
cv284[i] = cv285[i];
}
emlrtInitCharArrayR2013a(&b_st, 28, m43, cv284);
emlrtAssign(&y, m43);
b_y = NULL;
m43 = mxCreateNumericMatrix(1, 1, mxINT32_CLASS, mxREAL);
*(int32_T *)mxGetData(m43) = MIN_int32_T;
emlrtAssign(&b_y, m43);
c_y = NULL;
m43 = mxCreateNumericMatrix(1, 1, mxINT32_CLASS, mxREAL);
*(int32_T *)mxGetData(m43) = MAX_int32_T;
emlrtAssign(&c_y, m43);
c_st.site = &uab_emlrtRSI;
d_st.site = &bcb_emlrtRSI;
c_error(&c_st, c_message(&d_st, y, b_y, c_y, &ac_emlrtMCI), &bc_emlrtMCI);
}
c_st.site = &ny_emlrtRSI;
c_st.site = &ny_emlrtRSI;
b_st.site = &ky_emlrtRSI;
c_st.site = &af_emlrtRSI;
maxdimlen = i32;
if (1 > i32) {
maxdimlen = 1;
}
b_st.site = &ky_emlrtRSI;
c_st.site = &af_emlrtRSI;
if (i32 < maxdimlen) {
} else {
maxdimlen = i32;
}
if (7 > maxdimlen) {
b_st.site = &jy_emlrtRSI;
c_eml_error(&b_st);
}
if ((int8_T)(int32_T)a > maxdimlen) {
b_st.site = &jy_emlrtRSI;
c_eml_error(&b_st);
}
b_st.site = &iy_emlrtRSI;
c_st.site = &v_emlrtRSI;
if (i32 == 7 * (int32_T)a) {
} else {
d_y = NULL;
m43 = mxCreateCharArray(2, iv238);
for (i = 0; i < 40; i++) {
cv286[i] = cv287[i];
}
emlrtInitCharArrayR2013a(&st, 40, m43, cv286);
emlrtAssign(&d_y, m43);
b_st.site = &iy_emlrtRSI;
e_st.site = &rbb_emlrtRSI;
c_error(&b_st, b_message(&e_st, d_y, &tb_emlrtMCI), &ub_emlrtMCI);
}
b_st.site = &hy_emlrtRSI;
c_st.site = &dg_emlrtRSI;
for (maxdimlen = 0; maxdimlen + 1 <= i32; maxdimlen++) {
y_data[maxdimlen] = bits_data[maxdimlen];
}
for (i32 = 0; i32 < 7; i32++) {
maxdimlen = (int32_T)a;
for (i33 = 0; i33 < maxdimlen; i33++) {
b_bits_data[i33 + (int32_T)a * i32] = y_data[i32 + 7 * i33];
}
}
/* Convert bits to letters */
Letters_size[0] = (int32_T)a;
maxdimlen = (int32_T)a;
for (i32 = 0; i32 < maxdimlen; i32++) {
Letters_data[i32] = 0.0;
}
i = 0;
while (i <= (int32_T)a - 1) {
st.site = &sab_emlrtRSI;
i32 = (int32_T)a;
i33 = 1 + i;
emlrtDynamicBoundsCheckFastR2012b(i33, 1, i32, &qb_emlrtBCI, &st);
b_st.site = &of_emlrtRSI;
b_st.site = &vab_emlrtRSI;
for (maxdimlen = 0; maxdimlen < 7; maxdimlen++) {
s[maxdimlen] = '0';
if (b_bits_data[i + (int32_T)a * maxdimlen]) {
s[maxdimlen] = '1';
}
}
st.site = &sab_emlrtRSI;
b_st.site = &wab_emlrtRSI;
maxdimlen = 0;
do {
exitg1 = 0;
if (maxdimlen < 7) {
if ((s[maxdimlen] != '0') && (s[maxdimlen] != '1')) {
p = FALSE;
exitg1 = 1;
} else {
maxdimlen++;
}
} else {
p = TRUE;
exitg1 = 1;
}
} while (exitg1 == 0);
if (p) {
} else {
e_y = NULL;
m43 = mxCreateCharArray(2, iv239);
for (maxdimlen = 0; maxdimlen < 34; maxdimlen++) {
cv288[maxdimlen] = cv289[maxdimlen];
}
emlrtInitCharArrayR2013a(&st, 34, m43, cv288);
emlrtAssign(&e_y, m43);
b_st.site = &wab_emlrtRSI;
e_st.site = &qbb_emlrtRSI;
c_error(&b_st, b_message(&e_st, e_y, &cc_emlrtMCI), &dc_emlrtMCI);
}
b_st.site = &xab_emlrtRSI;
varargin_1 = 0.0;
p2 = 1.0;
for (maxdimlen = 0; maxdimlen < 7; maxdimlen++) {
if (s[6 - maxdimlen] == '1') {
varargin_1 += p2;
}
p2 += p2;
}
st.site = &sab_emlrtRSI;
i32 = (int32_T)varargin_1;
emlrtDynamicBoundsCheckFastR2012b(i32, 0, 255, &emlrtBCI, &st);
i32 = (int32_T)a;
i33 = 1 + i;
Letters_data[emlrtDynamicBoundsCheckFastR2012b(i33, 1, i32, &sb_emlrtBCI, sp)
- 1] = (int8_T)varargin_1;
i++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
}
/* 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 */
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;
}
/* Function Definitions */
void CalculateABBStarD(const emlrtStack *sp, real_T N, const emxArray_real_T *t,
const emxArray_real_T *gridT, const emxArray_real_T *x, const emxArray_real_T *
f, emxArray_real_T *A, emxArray_real_T *B, emxArray_real_T *Bstar,
emxArray_real_T *D)
{
int32_T i4;
real_T d1;
real_T d2;
int32_T loop_ub;
int32_T i;
emxArray_real_T *a;
int32_T j;
int32_T deltaij;
int32_T b_A;
real_T d3;
real_T d4;
real_T b1j0i;
real_T b1j1i;
int32_T i5;
int32_T i6;
int32_T i7;
int32_T i8;
emlrtStack st;
emlrtStack b_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
/* Calculate A and B, B*, and D */
/* N is the number of time points */
/* grid T is the time points grid on which the solution is calculated */
/* f is the multiplicative function for the source f(x,t)*r(t), size [N, */
/* N0], with N0 the number of space points */
i4 = A->size[0] * A->size[1];
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &j_emlrtDCI, sp);
A->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &i_emlrtDCI, sp);
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &l_emlrtDCI, sp);
A->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &k_emlrtDCI, sp);
emxEnsureCapacity(sp, (emxArray__common *)A, i4, (int32_T)sizeof(real_T),
&b_emlrtRTEI);
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &j_emlrtDCI, sp);
d2 = 2.0 * N;
d2 = emlrtNonNegativeCheckFastR2012b(d2, &l_emlrtDCI, sp);
loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d1, &i_emlrtDCI, sp) * (int32_T)
emlrtIntegerCheckFastR2012b(d2, &k_emlrtDCI, sp);
for (i4 = 0; i4 < loop_ub; i4++) {
A->data[i4] = 0.0;
}
i4 = B->size[0] * B->size[1];
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &n_emlrtDCI, sp);
B->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &m_emlrtDCI, sp);
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &p_emlrtDCI, sp);
B->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &o_emlrtDCI, sp);
emxEnsureCapacity(sp, (emxArray__common *)B, i4, (int32_T)sizeof(real_T),
&b_emlrtRTEI);
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &n_emlrtDCI, sp);
d2 = 2.0 * N;
d2 = emlrtNonNegativeCheckFastR2012b(d2, &p_emlrtDCI, sp);
loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d1, &m_emlrtDCI, sp) * (int32_T)
emlrtIntegerCheckFastR2012b(d2, &o_emlrtDCI, sp);
for (i4 = 0; i4 < loop_ub; i4++) {
B->data[i4] = 0.0;
}
i4 = Bstar->size[0] * Bstar->size[1];
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &r_emlrtDCI, sp);
Bstar->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &q_emlrtDCI, sp);
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &t_emlrtDCI, sp);
Bstar->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &s_emlrtDCI, sp);
emxEnsureCapacity(sp, (emxArray__common *)Bstar, i4, (int32_T)sizeof(real_T),
&b_emlrtRTEI);
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &r_emlrtDCI, sp);
d2 = 2.0 * N;
d2 = emlrtNonNegativeCheckFastR2012b(d2, &t_emlrtDCI, sp);
loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d1, &q_emlrtDCI, sp) * (int32_T)
emlrtIntegerCheckFastR2012b(d2, &s_emlrtDCI, sp);
for (i4 = 0; i4 < loop_ub; i4++) {
Bstar->data[i4] = 0.0;
}
i4 = D->size[0] * D->size[1];
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &v_emlrtDCI, sp);
D->size[0] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &u_emlrtDCI, sp);
d1 = emlrtNonNegativeCheckFastR2012b(N, &x_emlrtDCI, sp);
D->size[1] = (int32_T)emlrtIntegerCheckFastR2012b(d1, &w_emlrtDCI, sp);
emxEnsureCapacity(sp, (emxArray__common *)D, i4, (int32_T)sizeof(real_T),
&b_emlrtRTEI);
d1 = 2.0 * N;
d1 = emlrtNonNegativeCheckFastR2012b(d1, &v_emlrtDCI, sp);
d2 = emlrtNonNegativeCheckFastR2012b(N, &x_emlrtDCI, sp);
loop_ub = (int32_T)emlrtIntegerCheckFastR2012b(d1, &u_emlrtDCI, sp) * (int32_T)
emlrtIntegerCheckFastR2012b(d2, &w_emlrtDCI, sp);
for (i4 = 0; i4 < loop_ub; i4++) {
D->data[i4] = 0.0;
}
emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N,
&dc_emlrtRTEI, sp);
i = 0;
emxInit_real_T(sp, &a, 2, &c_emlrtRTEI, true);
while (i <= (int32_T)N - 1) {
/* time */
emlrtForLoopVectorCheckR2012b(1.0, 1.0, N, mxDOUBLE_CLASS, (int32_T)N,
&cc_emlrtRTEI, sp);
j = 0;
while (j <= (int32_T)N - 1) {
/* time */
deltaij = (1.0 + (real_T)i == 1.0 + (real_T)j);
d1 = 2.0 * (1.0 + (real_T)i);
loop_ub = A->size[0];
d2 = 2.0 * (1.0 + (real_T)j);
b_A = A->size[1];
i4 = t->size[1];
st.site = &n_emlrtRSI;
d3 = Acoeff(&st, 0.0, 1.0 + (real_T)j, 0.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4,
&qb_emlrtBCI, sp) - 1], gridT);
i4 = t->size[1];
st.site = &n_emlrtRSI;
d4 = Acoeff(&st, 1.0, 1.0 + (real_T)j, 0.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4,
&rb_emlrtBCI, sp) - 1], gridT);
i4 = t->size[1];
st.site = &o_emlrtRSI;
b1j0i = Acoeff(&st, 0.0, 1.0 + (real_T)j, 1.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4,
&sb_emlrtBCI, sp) - 1], gridT);
i4 = t->size[1];
st.site = &o_emlrtRSI;
b1j1i = Acoeff(&st, 1.0, 1.0 + (real_T)j, 1.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4,
&tb_emlrtBCI, sp) - 1], gridT);
i4 = (int32_T)(d1 + -1.0);
i5 = (int32_T)(d2 + -1.0);
A->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &ub_emlrtBCI,
sp) + A->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A,
&vb_emlrtBCI, sp) - 1)) - 1] = d3;
i4 = (int32_T)(d1 + -1.0);
i5 = (int32_T)d2;
A->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &ub_emlrtBCI,
sp) + A->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A,
&vb_emlrtBCI, sp) - 1)) - 1] = d4;
i4 = (int32_T)d1;
i5 = (int32_T)(d2 + -1.0);
A->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &ub_emlrtBCI,
sp) + A->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A,
&vb_emlrtBCI, sp) - 1)) - 1] = b1j0i;
i4 = (int32_T)d1;
i5 = (int32_T)d2;
A->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &ub_emlrtBCI,
sp) + A->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A,
&vb_emlrtBCI, sp) - 1)) - 1] = b1j1i;
/* temp terms */
i4 = t->size[1];
st.site = &p_emlrtRSI;
b1j0i = Bcoeff(&st, 1.0, 1.0 + (real_T)j, 0.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4,
&wb_emlrtBCI, sp) - 1], gridT);
i4 = t->size[1];
st.site = &q_emlrtRSI;
b1j1i = Bcoeff(&st, 1.0, 1.0 + (real_T)j, 1.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4,
&xb_emlrtBCI, sp) - 1], gridT);
d1 = 2.0 * (1.0 + (real_T)i);
loop_ub = B->size[0];
d2 = 2.0 * (1.0 + (real_T)j);
b_A = B->size[1];
i4 = t->size[1];
st.site = &r_emlrtRSI;
d3 = Bcoeff(&st, 0.0, 1.0 + (real_T)j, 0.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4,
&yb_emlrtBCI, sp) - 1], gridT);
i4 = t->size[1];
st.site = &s_emlrtRSI;
d4 = Bcoeff(&st, 0.0, 1.0 + (real_T)j, 1.0, t->
data[emlrtDynamicBoundsCheckFastR2012b(i + 1, 1, i4,
&ac_emlrtBCI, sp) - 1], gridT);
i4 = (int32_T)(d1 + -1.0);
i5 = (int32_T)(d2 + -1.0);
B->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &bc_emlrtBCI,
sp) + B->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A,
&cc_emlrtBCI, sp) - 1)) - 1] = d3 + 0.5 * (real_T)deltaij;
i4 = (int32_T)(d1 + -1.0);
i5 = (int32_T)d2;
B->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &bc_emlrtBCI,
sp) + B->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A,
&cc_emlrtBCI, sp) - 1)) - 1] = b1j0i;
i4 = (int32_T)d1;
i5 = (int32_T)(d2 + -1.0);
B->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &bc_emlrtBCI,
sp) + B->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A,
&cc_emlrtBCI, sp) - 1)) - 1] = d4;
i4 = (int32_T)d1;
i5 = (int32_T)d2;
B->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub, &bc_emlrtBCI,
sp) + B->size[0] * (emlrtDynamicBoundsCheckFastR2012b(i5, 1, b_A,
&cc_emlrtBCI, sp) - 1)) - 1] = b1j1i + 0.5 * (real_T)deltaij;
d1 = 2.0 * (1.0 + (real_T)i);
loop_ub = Bstar->size[0];
d2 = 2.0 * (1.0 + (real_T)j);
b_A = Bstar->size[1];
i4 = (int32_T)(d1 + -1.0);
i5 = (int32_T)(d2 + -1.0);
Bstar->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub,
&dc_emlrtBCI, sp) + Bstar->size[0] * (emlrtDynamicBoundsCheckFastR2012b
(i5, 1, b_A, &ec_emlrtBCI, sp) - 1)) - 1] = b1j0i;
i4 = (int32_T)(d1 + -1.0);
i5 = (int32_T)d2;
Bstar->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub,
&dc_emlrtBCI, sp) + Bstar->size[0] * (emlrtDynamicBoundsCheckFastR2012b
(i5, 1, b_A, &ec_emlrtBCI, sp) - 1)) - 1] = -b1j0i;
i4 = (int32_T)d1;
i5 = (int32_T)(d2 + -1.0);
Bstar->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub,
&dc_emlrtBCI, sp) + Bstar->size[0] * (emlrtDynamicBoundsCheckFastR2012b
(i5, 1, b_A, &ec_emlrtBCI, sp) - 1)) - 1] = b1j1i + (real_T)deltaij /
2.0;
i4 = (int32_T)d1;
i5 = (int32_T)d2;
Bstar->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, loop_ub,
&dc_emlrtBCI, sp) + Bstar->size[0] * (emlrtDynamicBoundsCheckFastR2012b
(i5, 1, b_A, &ec_emlrtBCI, sp) - 1)) - 1] = -b1j1i - 0.5 * (real_T)
deltaij;
st.site = &t_emlrtRSI;
i4 = t->size[1];
i5 = i + 1;
emlrtDynamicBoundsCheckFastR2012b(i5, 1, i4, &pb_emlrtBCI, &st);
i4 = f->size[0];
i5 = i + 1;
emlrtDynamicBoundsCheckFastR2012b(i5, 1, i4, &ob_emlrtBCI, &st);
/* Calculate the integral int_0^1(f(y,t_j)*A_{yj}(x,t)dy) by midpoint */
/* integration rule */
/* the spatial integration of all points y at time t_j */
i4 = a->size[0] * a->size[1];
a->size[0] = 1;
emxEnsureCapacity(&st, (emxArray__common *)a, i4, (int32_T)sizeof(real_T),
&b_emlrtRTEI);
loop_ub = x->size[1];
i4 = a->size[0] * a->size[1];
a->size[1] = loop_ub;
emxEnsureCapacity(&st, (emxArray__common *)a, i4, (int32_T)sizeof(real_T),
&b_emlrtRTEI);
loop_ub = x->size[1];
for (i4 = 0; i4 < loop_ub; i4++) {
a->data[i4] = 0.0;
}
b1j0i = 0.0;
loop_ub = x->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, loop_ub, &jb_emlrtBCI, &st);
i4 = x->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i4, &kb_emlrtBCI, &st);
b_st.site = &v_emlrtRSI;
a->data[0] = Acoeff(&b_st, x->data[0], 1.0 + (real_T)j, 0.0, t->data[i],
gridT);
/* y = 0:1/(numel(y)-2):1; */
i4 = f->size[1];
loop_ub = 2;
while (loop_ub - 2 <= i4 - 2) {
i5 = a->size[1];
b_A = x->size[1];
b_st.site = &w_emlrtRSI;
a->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &gc_emlrtBCI,
&st) - 1] = Acoeff(&b_st, x->data[emlrtDynamicBoundsCheckFastR2012b
(loop_ub, 1, b_A, &hc_emlrtBCI, &st) - 1], 1.0 +
(real_T)j, 0.0, t->data[i], gridT);
i5 = f->size[1];
emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &ib_emlrtBCI, &st);
i5 = f->size[1];
b_A = loop_ub - 1;
emlrtDynamicBoundsCheckFastR2012b(b_A, 1, i5, &hb_emlrtBCI, &st);
i5 = a->size[1];
b_A = a->size[1];
deltaij = loop_ub - 1;
i6 = x->size[1];
i7 = x->size[1];
i8 = loop_ub - 1;
b1j0i += 0.5 * (a->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5,
&ic_emlrtBCI, &st) - 1] * f->data[i + f->size[0] * (loop_ub - 1)] +
a->data[emlrtDynamicBoundsCheckFastR2012b(deltaij, 1,
b_A, &jc_emlrtBCI, &st) - 1] * f->data[i + f->size[0] * (loop_ub - 2)])
* (x->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i6,
&kc_emlrtBCI, &st) - 1] - x->
data[emlrtDynamicBoundsCheckFastR2012b(i8, 1, i7, &lc_emlrtBCI, &st)
- 1]);
loop_ub++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, &st);
}
st.site = &u_emlrtRSI;
i4 = t->size[1];
i5 = i + 1;
emlrtDynamicBoundsCheckFastR2012b(i5, 1, i4, &nb_emlrtBCI, &st);
i4 = f->size[0];
i5 = i + 1;
emlrtDynamicBoundsCheckFastR2012b(i5, 1, i4, &mb_emlrtBCI, &st);
/* Calculate the integral int_0^1(f(y,t_j)*A_{yj}(x,t)dy) by midpoint */
/* integration rule */
/* the spatial integration of all points y at time t_j */
i4 = a->size[0] * a->size[1];
a->size[0] = 1;
emxEnsureCapacity(&st, (emxArray__common *)a, i4, (int32_T)sizeof(real_T),
&b_emlrtRTEI);
loop_ub = x->size[1];
i4 = a->size[0] * a->size[1];
a->size[1] = loop_ub;
emxEnsureCapacity(&st, (emxArray__common *)a, i4, (int32_T)sizeof(real_T),
&b_emlrtRTEI);
loop_ub = x->size[1];
for (i4 = 0; i4 < loop_ub; i4++) {
a->data[i4] = 0.0;
}
b1j1i = 0.0;
loop_ub = x->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, loop_ub, &jb_emlrtBCI, &st);
i4 = x->size[1];
emlrtDynamicBoundsCheckFastR2012b(1, 1, i4, &kb_emlrtBCI, &st);
b_st.site = &v_emlrtRSI;
a->data[0] = Acoeff(&b_st, x->data[0], 1.0 + (real_T)j, 1.0, t->data[i],
gridT);
/* y = 0:1/(numel(y)-2):1; */
i4 = f->size[1];
loop_ub = 2;
while (loop_ub - 2 <= i4 - 2) {
i5 = a->size[1];
b_A = x->size[1];
b_st.site = &w_emlrtRSI;
a->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &gc_emlrtBCI,
&st) - 1] = Acoeff(&b_st, x->data[emlrtDynamicBoundsCheckFastR2012b
(loop_ub, 1, b_A, &hc_emlrtBCI, &st) - 1], 1.0 +
(real_T)j, 1.0, t->data[i], gridT);
i5 = f->size[1];
emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5, &ib_emlrtBCI, &st);
i5 = f->size[1];
b_A = loop_ub - 1;
emlrtDynamicBoundsCheckFastR2012b(b_A, 1, i5, &hb_emlrtBCI, &st);
i5 = a->size[1];
b_A = a->size[1];
deltaij = loop_ub - 1;
i6 = x->size[1];
i7 = x->size[1];
i8 = loop_ub - 1;
b1j1i += 0.5 * (a->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i5,
&ic_emlrtBCI, &st) - 1] * f->data[i + f->size[0] * (loop_ub - 1)] +
a->data[emlrtDynamicBoundsCheckFastR2012b(deltaij, 1,
b_A, &jc_emlrtBCI, &st) - 1] * f->data[i + f->size[0] * (loop_ub - 2)])
* (x->data[emlrtDynamicBoundsCheckFastR2012b(loop_ub, 1, i6,
&kc_emlrtBCI, &st) - 1] - x->
data[emlrtDynamicBoundsCheckFastR2012b(i8, 1, i7, &lc_emlrtBCI, &st)
- 1]);
loop_ub++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, &st);
}
d1 = 2.0 * (1.0 + (real_T)i);
b_A = D->size[0];
loop_ub = D->size[1];
emlrtDynamicBoundsCheckFastR2012b(j + 1, 1, loop_ub, &lb_emlrtBCI, sp);
i4 = (int32_T)(d1 + -1.0);
D->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, b_A, &fc_emlrtBCI, sp) +
D->size[0] * j) - 1] = b1j0i;
i4 = (int32_T)d1;
D->data[(emlrtDynamicBoundsCheckFastR2012b(i4, 1, b_A, &fc_emlrtBCI, sp) +
D->size[0] * j) - 1] = b1j1i;
j++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
i++;
emlrtBreakCheckFastR2012b(emlrtBreakCheckR2012bFlagVar, sp);
}
emxFree_real_T(&a);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
}
