/* Function Definitions */
real_T compressedindex(const emlrtStack *sp, const emxArray_real_T *x, const
emxArray_real_T *ctable, real_T range, real_T dims)
{
real_T y;
real_T py;
int32_T i;
int32_T i2;
int32_T i3;
real_T d4;
int32_T k;
int32_T vlen;
boolean_T p;
boolean_T b_p;
int32_T exitg1;
int32_T b_k;
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 = &c_st;
d_st.tls = c_st.tls;
e_st.prev = &d_st;
e_st.tls = d_st.tls;
/* for a given vector, find its index within the transition space matrix */
/* workspace; */
py = 1.0;
range++;
emlrtForLoopVectorCheckR2012b(1.0, 1.0, dims - 2.0, mxDOUBLE_CLASS, (int32_T)
(dims - 2.0), (emlrtRTEInfo *)&o_emlrtRTEI, sp);
i = 0;
while (i <= (int32_T)(dims - 2.0) - 1) {
i2 = x->size[1];
if (!((i + 1 >= 1) && (i + 1 <= i2))) {
emlrtDynamicBoundsCheckR2012b(i + 1, 1, i2, (emlrtBCInfo *)&bb_emlrtBCI,
sp);
}
if (x->data[i] == 0.0) {
} else {
i2 = x->size[1];
if (!((i + 1 >= 1) && (i + 1 <= i2))) {
emlrtDynamicBoundsCheckR2012b(i + 1, 1, i2, (emlrtBCInfo *)&cb_emlrtBCI,
sp);
}
d4 = range - (x->data[i] - 1.0);
if (d4 > range) {
i3 = 1;
i2 = 1;
} else {
if (d4 != (int32_T)muDoubleScalarFloor(d4)) {
emlrtIntegerCheckR2012b(d4, (emlrtDCInfo *)&k_emlrtDCI, sp);
}
i2 = ctable->size[0];
i3 = (int32_T)d4;
if (!((i3 >= 1) && (i3 <= i2))) {
emlrtDynamicBoundsCheckR2012b(i3, 1, i2, (emlrtBCInfo *)&x_emlrtBCI,
sp);
}
if (range != (int32_T)muDoubleScalarFloor(range)) {
emlrtIntegerCheckR2012b(range, (emlrtDCInfo *)&k_emlrtDCI, sp);
}
i2 = ctable->size[0];
k = (int32_T)range;
if (!((k >= 1) && (k <= i2))) {
emlrtDynamicBoundsCheckR2012b(k, 1, i2, (emlrtBCInfo *)&x_emlrtBCI, sp);
}
i2 = k + 1;
}
st.site = &l_emlrtRSI;
d4 = dims - (1.0 + (real_T)i);
if (d4 != (int32_T)muDoubleScalarFloor(d4)) {
emlrtIntegerCheckR2012b(d4, (emlrtDCInfo *)&l_emlrtDCI, &st);
}
k = ctable->size[1];
vlen = (int32_T)d4;
if (!((vlen >= 1) && (vlen <= k))) {
emlrtDynamicBoundsCheckR2012b(vlen, 1, k, (emlrtBCInfo *)&y_emlrtBCI,
&st);
}
b_st.site = &m_emlrtRSI;
if ((i2 - i3 == 1) || (i2 - i3 != 1)) {
p = true;
} else {
p = false;
}
if (p) {
} else {
emlrtErrorWithMessageIdR2012b(&b_st, &p_emlrtRTEI,
"Coder:toolbox:autoDimIncompatibility", 0);
}
p = false;
b_p = false;
k = 0;
do {
exitg1 = 0;
if (k < 2) {
if (k + 1 <= 1) {
b_k = i2 - i3;
} else {
b_k = 1;
}
if (b_k != 0) {
exitg1 = 1;
} else {
k++;
}
} else {
b_p = true;
exitg1 = 1;
}
} while (exitg1 == 0);
if (!b_p) {
} else {
p = true;
}
if (!p) {
} else {
emlrtErrorWithMessageIdR2012b(&b_st, &q_emlrtRTEI,
"Coder:toolbox:UnsupportedSpecialEmpty", 0);
}
c_st.site = &n_emlrtRSI;
if (i2 - i3 == 0) {
y = 0.0;
} else {
vlen = i2 - i3;
y = ctable->data[(i3 + ctable->size[0] * ((int32_T)(dims - (1.0 +
(real_T)i)) - 1)) - 1];
d_st.site = &o_emlrtRSI;
if ((!(2 > i2 - i3)) && (i2 - i3 > 2147483646)) {
e_st.site = &j_emlrtRSI;
check_forloop_overflow_error(&e_st);
}
for (k = 0; k + 2 <= vlen; k++) {
y += ctable->data[(i3 + k) + ctable->size[0] * ((int32_T)(dims - (1.0
+ (real_T)i)) - 1)];
}
}
py += y;
i2 = x->size[1];
if (!((i + 1 >= 1) && (i + 1 <= i2))) {
emlrtDynamicBoundsCheckR2012b(i + 1, 1, i2, (emlrtBCInfo *)&db_emlrtBCI,
sp);
}
range -= x->data[i];
}
i++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
i2 = x->size[1];
i3 = x->size[1] - 1;
if (!((i3 >= 1) && (i3 <= i2))) {
emlrtDynamicBoundsCheckR2012b(i3, 1, i2, (emlrtBCInfo *)&ab_emlrtBCI, sp);
}
return py + x->data[i3 - 1];
}
/* Function Definitions */
void compmat(const emlrtStack *sp, const emxArray_uint8_T *x, real_T dims,
emxArray_real_T *y)
{
int32_T i1;
real_T d3;
int32_T ii;
int32_T i;
emxArray_boolean_T *b_x;
emxArray_int32_T *b_ii;
int32_T nx;
int32_T idx;
boolean_T overflow;
boolean_T exitg1;
boolean_T guard1 = false;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
st.prev = sp;
st.tls = sp->tls;
b_st.prev = &st;
b_st.tls = st.tls;
c_st.prev = &b_st;
c_st.tls = b_st.tls;
d_st.prev = &c_st;
d_st.tls = c_st.tls;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
/* UNTITLED Summary of this function goes here */
/* Detailed explanation goes here */
i1 = y->size[0] * y->size[1];
y->size[0] = 1;
if (!(dims >= 0.0)) {
emlrtNonNegativeCheckR2012b(dims, (emlrtDCInfo *)&j_emlrtDCI, sp);
}
d3 = dims;
if (d3 != (int32_T)muDoubleScalarFloor(d3)) {
emlrtIntegerCheckR2012b(d3, (emlrtDCInfo *)&i_emlrtDCI, sp);
}
y->size[1] = (int32_T)d3;
emxEnsureCapacity(sp, (emxArray__common *)y, i1, (int32_T)sizeof(real_T),
&f_emlrtRTEI);
if (!(dims >= 0.0)) {
emlrtNonNegativeCheckR2012b(dims, (emlrtDCInfo *)&j_emlrtDCI, sp);
}
if (d3 != (int32_T)muDoubleScalarFloor(d3)) {
emlrtIntegerCheckR2012b(d3, (emlrtDCInfo *)&i_emlrtDCI, sp);
}
ii = (int32_T)d3;
for (i1 = 0; i1 < ii; i1++) {
y->data[i1] = 0.0;
}
emlrtForLoopVectorCheckR2012b(1.0, 1.0, dims, mxDOUBLE_CLASS, (int32_T)dims,
(emlrtRTEInfo *)&n_emlrtRTEI, sp);
i = 0;
emxInit_boolean_T(sp, &b_x, 2, &f_emlrtRTEI, true);
emxInit_int32_T(sp, &b_ii, 2, &g_emlrtRTEI, true);
while (i <= (int32_T)dims - 1) {
st.site = &k_emlrtRSI;
i1 = b_x->size[0] * b_x->size[1];
b_x->size[0] = 1;
b_x->size[1] = x->size[1];
emxEnsureCapacity(&st, (emxArray__common *)b_x, i1, (int32_T)sizeof
(boolean_T), &f_emlrtRTEI);
ii = x->size[0] * x->size[1];
for (i1 = 0; i1 < ii; i1++) {
b_x->data[i1] = (x->data[i1] == 1.0 + (real_T)i);
}
b_st.site = &h_emlrtRSI;
nx = b_x->size[1];
idx = 0;
i1 = b_ii->size[0] * b_ii->size[1];
b_ii->size[0] = 1;
b_ii->size[1] = b_x->size[1];
emxEnsureCapacity(&b_st, (emxArray__common *)b_ii, i1, (int32_T)sizeof
(int32_T), &f_emlrtRTEI);
c_st.site = &i_emlrtRSI;
overflow = ((!(1 > b_x->size[1])) && (b_x->size[1] > 2147483646));
if (overflow) {
d_st.site = &j_emlrtRSI;
check_forloop_overflow_error(&d_st);
}
ii = 1;
exitg1 = false;
while ((!exitg1) && (ii <= nx)) {
guard1 = false;
if (b_x->data[ii - 1]) {
idx++;
b_ii->data[idx - 1] = ii;
if (idx >= nx) {
exitg1 = true;
} else {
guard1 = true;
}
} else {
guard1 = true;
}
if (guard1) {
ii++;
}
}
if (idx <= b_x->size[1]) {
} else {
emlrtErrorWithMessageIdR2012b(&b_st, &k_emlrtRTEI,
"Coder:builtins:AssertionFailed", 0);
}
if (b_x->size[1] == 1) {
if (idx == 0) {
i1 = b_ii->size[0] * b_ii->size[1];
b_ii->size[0] = 1;
b_ii->size[1] = 0;
emxEnsureCapacity(&b_st, (emxArray__common *)b_ii, i1, (int32_T)sizeof
(int32_T), &f_emlrtRTEI);
}
} else {
i1 = b_ii->size[0] * b_ii->size[1];
if (1 > idx) {
b_ii->size[1] = 0;
} else {
b_ii->size[1] = idx;
}
emxEnsureCapacity(&b_st, (emxArray__common *)b_ii, i1, (int32_T)sizeof
(int32_T), &b_emlrtRTEI);
}
i1 = y->size[1];
if (!((i + 1 >= 1) && (i + 1 <= i1))) {
emlrtDynamicBoundsCheckR2012b(i + 1, 1, i1, (emlrtBCInfo *)&w_emlrtBCI, sp);
}
y->data[i] = b_ii->size[1];
i++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
emxFree_int32_T(&b_ii);
emxFree_boolean_T(&b_x);
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
}
/* Function Definitions */
void occflow(const emlrtStack *sp, const emxArray_real_T *cgridvec,
emxArray_real_T *cgridvecprev, emxArray_real_T *context, const
emxArray_real_T *nei_idx, const emxArray_real_T *nei_weight, real_T
nei_filter_n, const emxArray_real_T *nei4u_idx, const
emxArray_real_T *nei4u_weight, real_T nei4u_filter_n, real_T occval,
real_T minthreshold, real_T maxthreshold, real_T reinitval, real_T
intensifyrate, real_T nocc_attenuaterate, real_T
unknown_attenuaterate, real_T sigm_coef, real_T
do_attenuation_first, emxArray_real_T *predvec, emxArray_real_T
*maxvec)
{
emxArray_boolean_T *x;
int32_T ix;
int32_T idx;
emxArray_boolean_T *r0;
int32_T nx;
emxArray_int32_T *ii;
boolean_T overflow;
int32_T iy;
boolean_T exitg6;
boolean_T guard3 = false;
boolean_T guard4 = false;
emxArray_real_T *newlyoccidx;
boolean_T exitg5;
boolean_T guard2 = false;
boolean_T b_guard3 = false;
emxArray_real_T *occidx;
boolean_T exitg4;
boolean_T guard1 = false;
boolean_T b_guard2 = false;
emxArray_real_T *noccidx;
int32_T nrnocc;
int32_T j;
emxArray_real_T *curr_col;
emxArray_real_T *updt_col;
emxArray_real_T *z;
int32_T coccidx;
boolean_T b_guard1 = false;
int32_T ixstart;
int32_T n;
real_T mtmp;
boolean_T exitg3;
int32_T varargin_1[2];
int32_T k;
int32_T iv3[2];
int32_T iv4[2];
real_T d0;
emxArray_real_T *tempcontext;
emxArray_real_T *b_nei4u_weight;
real_T sumval;
int32_T m;
int32_T iv5[2];
boolean_T b_ix;
boolean_T exitg2;
boolean_T b_ixstart;
int32_T varargin_2[2];
boolean_T p;
boolean_T exitg1;
emlrtStack st;
emlrtStack b_st;
emlrtStack c_st;
emlrtStack d_st;
emlrtStack e_st;
emlrtStack f_st;
(void)unknown_attenuaterate;
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;
emlrtHeapReferenceStackEnterFcnR2012b(sp);
emxInit_boolean_T(sp, &x, 1, &emlrtRTEI, true);
/* */
/* Occupancy flow with vector input */
/* */
/* Compute indices first */
ix = x->size[0];
x->size[0] = cgridvec->size[0];
emxEnsureCapacity(sp, (emxArray__common *)x, ix, (int32_T)sizeof(boolean_T),
&emlrtRTEI);
idx = cgridvec->size[0];
for (ix = 0; ix < idx; ix++) {
x->data[ix] = (cgridvec->data[ix] == occval);
}
emxInit_boolean_T(sp, &r0, 1, &emlrtRTEI, true);
ix = r0->size[0];
r0->size[0] = cgridvecprev->size[0];
emxEnsureCapacity(sp, (emxArray__common *)r0, ix, (int32_T)sizeof(boolean_T),
&emlrtRTEI);
idx = cgridvecprev->size[0];
for (ix = 0; ix < idx; ix++) {
r0->data[ix] = (cgridvecprev->data[ix] != occval);
}
ix = x->size[0];
nx = r0->size[0];
if (ix != nx) {
emlrtSizeEqCheck1DR2012b(ix, nx, &emlrtECI, sp);
}
st.site = &emlrtRSI;
ix = x->size[0];
emxEnsureCapacity(&st, (emxArray__common *)x, ix, (int32_T)sizeof(boolean_T),
&emlrtRTEI);
idx = x->size[0];
for (ix = 0; ix < idx; ix++) {
x->data[ix] = (x->data[ix] && r0->data[ix]);
}
emxFree_boolean_T(&r0);
emxInit_int32_T(&st, &ii, 1, &l_emlrtRTEI, true);
b_st.site = &i_emlrtRSI;
nx = x->size[0];
idx = 0;
ix = ii->size[0];
ii->size[0] = x->size[0];
emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T),
&emlrtRTEI);
c_st.site = &j_emlrtRSI;
if (1 > x->size[0]) {
overflow = false;
} else {
overflow = (x->size[0] > 2147483646);
}
if (overflow) {
d_st.site = &l_emlrtRSI;
check_forloop_overflow_error(&d_st);
}
iy = 1;
exitg6 = false;
while ((!exitg6) && (iy <= nx)) {
guard3 = false;
if (x->data[iy - 1]) {
idx++;
ii->data[idx - 1] = iy;
if (idx >= nx) {
exitg6 = true;
} else {
guard3 = true;
}
} else {
guard3 = true;
}
if (guard3) {
iy++;
}
}
if (idx <= x->size[0]) {
} else {
emlrtErrorWithMessageIdR2012b(&b_st, &s_emlrtRTEI,
"Coder:builtins:AssertionFailed", 0);
}
if (x->size[0] == 1) {
if (idx == 0) {
ix = ii->size[0];
ii->size[0] = 0;
emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof
(int32_T), &emlrtRTEI);
}
} else {
if (1 > idx) {
ix = 0;
} else {
ix = idx;
}
c_st.site = &k_emlrtRSI;
overflow = !(ii->size[0] != 1);
guard4 = false;
if (overflow) {
overflow = false;
if (ix != 1) {
overflow = true;
}
if (overflow) {
overflow = true;
} else {
guard4 = true;
}
} else {
guard4 = true;
}
if (guard4) {
overflow = false;
}
d_st.site = &m_emlrtRSI;
if (!overflow) {
} else {
emlrtErrorWithMessageIdR2012b(&d_st, &t_emlrtRTEI,
"Coder:FE:PotentialVectorVector", 0);
}
nx = ii->size[0];
ii->size[0] = ix;
emxEnsureCapacity(&b_st, (emxArray__common *)ii, nx, (int32_T)sizeof(int32_T),
&c_emlrtRTEI);
}
emxInit_real_T(&b_st, &newlyoccidx, 1, &f_emlrtRTEI, true);
ix = newlyoccidx->size[0];
newlyoccidx->size[0] = ii->size[0];
emxEnsureCapacity(&st, (emxArray__common *)newlyoccidx, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = ii->size[0];
for (ix = 0; ix < idx; ix++) {
newlyoccidx->data[ix] = ii->data[ix];
}
st.site = &b_emlrtRSI;
ix = x->size[0];
x->size[0] = cgridvec->size[0];
emxEnsureCapacity(&st, (emxArray__common *)x, ix, (int32_T)sizeof(boolean_T),
&emlrtRTEI);
idx = cgridvec->size[0];
for (ix = 0; ix < idx; ix++) {
x->data[ix] = (cgridvec->data[ix] == occval);
}
b_st.site = &i_emlrtRSI;
nx = x->size[0];
idx = 0;
ix = ii->size[0];
ii->size[0] = x->size[0];
emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T),
&emlrtRTEI);
c_st.site = &j_emlrtRSI;
if (1 > x->size[0]) {
overflow = false;
} else {
overflow = (x->size[0] > 2147483646);
}
if (overflow) {
d_st.site = &l_emlrtRSI;
check_forloop_overflow_error(&d_st);
}
iy = 1;
exitg5 = false;
while ((!exitg5) && (iy <= nx)) {
guard2 = false;
if (x->data[iy - 1]) {
idx++;
ii->data[idx - 1] = iy;
if (idx >= nx) {
exitg5 = true;
} else {
guard2 = true;
}
} else {
guard2 = true;
}
if (guard2) {
iy++;
}
}
if (idx <= x->size[0]) {
} else {
emlrtErrorWithMessageIdR2012b(&b_st, &s_emlrtRTEI,
"Coder:builtins:AssertionFailed", 0);
}
if (x->size[0] == 1) {
if (idx == 0) {
ix = ii->size[0];
ii->size[0] = 0;
emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof
(int32_T), &emlrtRTEI);
}
} else {
if (1 > idx) {
ix = 0;
} else {
ix = idx;
}
c_st.site = &k_emlrtRSI;
overflow = !(ii->size[0] != 1);
b_guard3 = false;
if (overflow) {
overflow = false;
if (ix != 1) {
overflow = true;
}
if (overflow) {
overflow = true;
} else {
b_guard3 = true;
}
} else {
b_guard3 = true;
}
if (b_guard3) {
overflow = false;
}
d_st.site = &m_emlrtRSI;
if (!overflow) {
} else {
emlrtErrorWithMessageIdR2012b(&d_st, &t_emlrtRTEI,
"Coder:FE:PotentialVectorVector", 0);
}
nx = ii->size[0];
ii->size[0] = ix;
emxEnsureCapacity(&b_st, (emxArray__common *)ii, nx, (int32_T)sizeof(int32_T),
&c_emlrtRTEI);
}
emxInit_real_T(&b_st, &occidx, 1, &g_emlrtRTEI, true);
ix = occidx->size[0];
occidx->size[0] = ii->size[0];
emxEnsureCapacity(&st, (emxArray__common *)occidx, ix, (int32_T)sizeof(real_T),
&emlrtRTEI);
idx = ii->size[0];
for (ix = 0; ix < idx; ix++) {
occidx->data[ix] = ii->data[ix];
}
st.site = &c_emlrtRSI;
ix = x->size[0];
x->size[0] = cgridvec->size[0];
emxEnsureCapacity(&st, (emxArray__common *)x, ix, (int32_T)sizeof(boolean_T),
&emlrtRTEI);
idx = cgridvec->size[0];
for (ix = 0; ix < idx; ix++) {
x->data[ix] = (cgridvec->data[ix] != occval);
}
b_st.site = &i_emlrtRSI;
nx = x->size[0];
idx = 0;
ix = ii->size[0];
ii->size[0] = x->size[0];
emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T),
&emlrtRTEI);
c_st.site = &j_emlrtRSI;
if (1 > x->size[0]) {
overflow = false;
} else {
overflow = (x->size[0] > 2147483646);
}
if (overflow) {
d_st.site = &l_emlrtRSI;
check_forloop_overflow_error(&d_st);
}
iy = 1;
exitg4 = false;
while ((!exitg4) && (iy <= nx)) {
guard1 = false;
if (x->data[iy - 1]) {
idx++;
ii->data[idx - 1] = iy;
if (idx >= nx) {
exitg4 = true;
} else {
guard1 = true;
}
} else {
guard1 = true;
}
if (guard1) {
iy++;
}
}
if (idx <= x->size[0]) {
} else {
emlrtErrorWithMessageIdR2012b(&b_st, &s_emlrtRTEI,
"Coder:builtins:AssertionFailed", 0);
}
if (x->size[0] == 1) {
if (idx == 0) {
ix = ii->size[0];
ii->size[0] = 0;
emxEnsureCapacity(&b_st, (emxArray__common *)ii, ix, (int32_T)sizeof
(int32_T), &emlrtRTEI);
}
} else {
if (1 > idx) {
ix = 0;
} else {
ix = idx;
}
c_st.site = &k_emlrtRSI;
overflow = !(ii->size[0] != 1);
b_guard2 = false;
if (overflow) {
overflow = false;
if (ix != 1) {
overflow = true;
}
if (overflow) {
overflow = true;
} else {
b_guard2 = true;
}
} else {
b_guard2 = true;
}
if (b_guard2) {
overflow = false;
}
d_st.site = &m_emlrtRSI;
if (!overflow) {
} else {
emlrtErrorWithMessageIdR2012b(&d_st, &t_emlrtRTEI,
"Coder:FE:PotentialVectorVector", 0);
}
nx = ii->size[0];
ii->size[0] = ix;
emxEnsureCapacity(&b_st, (emxArray__common *)ii, nx, (int32_T)sizeof(int32_T),
&c_emlrtRTEI);
}
emxFree_boolean_T(&x);
emxInit_real_T(&b_st, &noccidx, 1, &h_emlrtRTEI, true);
ix = noccidx->size[0];
noccidx->size[0] = ii->size[0];
emxEnsureCapacity(&st, (emxArray__common *)noccidx, ix, (int32_T)sizeof(real_T),
&emlrtRTEI);
idx = ii->size[0];
for (ix = 0; ix < idx; ix++) {
noccidx->data[ix] = ii->data[ix];
}
nrnocc = noccidx->size[0] - 1;
/* 1 Intensify newly occupied cells */
j = 0;
emxInit_real_T1(sp, &curr_col, 2, &i_emlrtRTEI, true);
emxInit_real_T1(sp, &updt_col, 2, &j_emlrtRTEI, true);
emxInit_real_T1(sp, &z, 2, &emlrtRTEI, true);
while (j <= newlyoccidx->size[0] - 1) {
/* For newly occupied cells */
ix = newlyoccidx->size[0];
if (!((j + 1 >= 1) && (j + 1 <= ix))) {
emlrtDynamicBoundsCheckR2012b(j + 1, 1, ix, &eb_emlrtBCI, sp);
}
coccidx = (int32_T)newlyoccidx->data[j] - 1;
ix = context->size[0];
nx = (int32_T)newlyoccidx->data[j];
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &emlrtBCI, sp);
}
st.site = &d_emlrtRSI;
b_st.site = &n_emlrtRSI;
c_st.site = &o_emlrtRSI;
ix = context->size[1];
b_guard1 = false;
if (ix == 1) {
b_guard1 = true;
} else {
ix = context->size[1];
if (ix != 1) {
b_guard1 = true;
} else {
overflow = false;
}
}
if (b_guard1) {
overflow = true;
}
if (overflow) {
} else {
emlrtErrorWithMessageIdR2012b(&c_st, &u_emlrtRTEI,
"Coder:toolbox:autoDimIncompatibility", 0);
}
ix = context->size[1];
if (ix > 0) {
} else {
emlrtErrorWithMessageIdR2012b(&c_st, &v_emlrtRTEI,
"Coder:toolbox:eml_min_or_max_varDimZero", 0);
}
d_st.site = &p_emlrtRSI;
ixstart = 1;
n = context->size[1];
nx = (int32_T)newlyoccidx->data[j];
mtmp = context->data[nx - 1];
ix = context->size[1];
if (ix > 1) {
if (muDoubleScalarIsNaN(mtmp)) {
e_st.site = &r_emlrtRSI;
ix = context->size[1];
if (2 > ix) {
overflow = false;
} else {
ix = context->size[1];
overflow = (ix > 2147483646);
}
if (overflow) {
f_st.site = &l_emlrtRSI;
check_forloop_overflow_error(&f_st);
}
ix = 2;
exitg3 = false;
while ((!exitg3) && (ix <= n)) {
ixstart = ix;
if (!muDoubleScalarIsNaN(context->data[coccidx + context->size[0] *
(ix - 1)])) {
mtmp = context->data[coccidx + context->size[0] * (ix - 1)];
exitg3 = true;
} else {
ix++;
}
}
}
ix = context->size[1];
if (ixstart < ix) {
e_st.site = &q_emlrtRSI;
ix = context->size[1];
if (ixstart + 1 > ix) {
overflow = false;
} else {
ix = context->size[1];
overflow = (ix > 2147483646);
}
if (overflow) {
f_st.site = &l_emlrtRSI;
check_forloop_overflow_error(&f_st);
}
for (ix = ixstart + 1; ix <= n; ix++) {
if (context->data[coccidx + context->size[0] * (ix - 1)] > mtmp) {
mtmp = context->data[coccidx + context->size[0] * (ix - 1)];
}
}
}
}
if (mtmp < minthreshold) {
idx = context->size[1];
iy = context->size[0];
nx = (int32_T)newlyoccidx->data[j];
if (!((nx >= 1) && (nx <= iy))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, iy, &b_emlrtBCI, sp);
}
for (ix = 0; ix < idx; ix++) {
context->data[(nx + context->size[0] * ix) - 1] = reinitval;
}
/* Reinitialize */
} else {
idx = context->size[1];
nx = (int32_T)newlyoccidx->data[j];
ix = updt_col->size[0] * updt_col->size[1];
updt_col->size[0] = 1;
updt_col->size[1] = idx;
emxEnsureCapacity(sp, (emxArray__common *)updt_col, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
for (ix = 0; ix < idx; ix++) {
updt_col->data[updt_col->size[0] * ix] = intensifyrate * context->data
[(nx + context->size[0] * ix) - 1];
}
/* Intensify */
st.site = &e_emlrtRSI;
b_st.site = &s_emlrtRSI;
c_st.site = &o_emlrtRSI;
d_st.site = &t_emlrtRSI;
ix = curr_col->size[0] * curr_col->size[1];
curr_col->size[0] = 1;
curr_col->size[1] = updt_col->size[1];
emxEnsureCapacity(&d_st, (emxArray__common *)curr_col, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = updt_col->size[0] * updt_col->size[1];
for (ix = 0; ix < idx; ix++) {
curr_col->data[ix] = updt_col->data[ix];
}
e_st.site = &u_emlrtRSI;
for (ix = 0; ix < 2; ix++) {
varargin_1[ix] = updt_col->size[ix];
}
ix = z->size[0] * z->size[1];
z->size[0] = 1;
z->size[1] = updt_col->size[1];
emxEnsureCapacity(&e_st, (emxArray__common *)z, ix, (int32_T)sizeof(real_T),
&d_emlrtRTEI);
iy = updt_col->size[1];
ix = updt_col->size[0] * updt_col->size[1];
updt_col->size[0] = 1;
updt_col->size[1] = varargin_1[1];
emxEnsureCapacity(&e_st, (emxArray__common *)updt_col, ix, (int32_T)sizeof
(real_T), &e_emlrtRTEI);
if (dimagree(updt_col, curr_col)) {
} else {
emlrtErrorWithMessageIdR2012b(&e_st, &x_emlrtRTEI, "MATLAB:dimagree", 0);
}
e_st.site = &v_emlrtRSI;
if (1 > z->size[1]) {
overflow = false;
} else {
overflow = (z->size[1] > 2147483646);
}
if (overflow) {
f_st.site = &l_emlrtRSI;
check_forloop_overflow_error(&f_st);
}
for (k = 0; k + 1 <= iy; k++) {
updt_col->data[k] = muDoubleScalarMin(curr_col->data[k], maxthreshold);
}
/* Max-thesholding */
ix = context->size[0];
nx = (int32_T)newlyoccidx->data[j];
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &c_emlrtBCI, sp);
}
idx = context->size[1];
ix = ii->size[0];
ii->size[0] = idx;
emxEnsureCapacity(sp, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T),
&emlrtRTEI);
for (ix = 0; ix < idx; ix++) {
ii->data[ix] = ix;
}
iv3[0] = 1;
iv3[1] = ii->size[0];
emlrtSubAssignSizeCheckR2012b(iv3, 2, *(int32_T (*)[2])updt_col->size, 2,
&b_emlrtECI, sp);
nx = (int32_T)newlyoccidx->data[j];
idx = updt_col->size[1];
for (ix = 0; ix < idx; ix++) {
context->data[(nx + context->size[0] * ii->data[ix]) - 1] =
updt_col->data[updt_col->size[0] * ix];
}
}
j++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
emxFree_real_T(&z);
/* 2 Attenuate unoccupied cells */
if (do_attenuation_first == 1.0) {
j = 0;
while (j <= nrnocc) {
/* For unoccupied cells */
ix = noccidx->size[0];
nx = j + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &d_emlrtBCI, sp);
}
ix = context->size[0];
nx = (int32_T)noccidx->data[j];
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &e_emlrtBCI, sp);
}
idx = context->size[1];
iy = (int32_T)noccidx->data[j];
ix = updt_col->size[0] * updt_col->size[1];
updt_col->size[0] = 1;
updt_col->size[1] = idx;
emxEnsureCapacity(sp, (emxArray__common *)updt_col, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
for (ix = 0; ix < idx; ix++) {
updt_col->data[updt_col->size[0] * ix] = context->data[(iy +
context->size[0] * ix) - 1] * nocc_attenuaterate;
}
/* Attenuate */
ix = context->size[0];
nx = (int32_T)noccidx->data[j];
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &f_emlrtBCI, sp);
}
idx = context->size[1];
ix = ii->size[0];
ii->size[0] = idx;
emxEnsureCapacity(sp, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T),
&emlrtRTEI);
for (ix = 0; ix < idx; ix++) {
ii->data[ix] = ix;
}
iv4[0] = 1;
iv4[1] = ii->size[0];
emlrtSubAssignSizeCheckR2012b(iv4, 2, *(int32_T (*)[2])updt_col->size, 2,
&c_emlrtECI, sp);
iy = (int32_T)noccidx->data[j];
idx = updt_col->size[1];
for (ix = 0; ix < idx; ix++) {
context->data[(iy + context->size[0] * ii->data[ix]) - 1] =
updt_col->data[updt_col->size[0] * ix];
}
j++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
}
/* 4 Propagation */
j = 0;
while (j <= occidx->size[0] - 1) {
/* For occupied cells */
ix = occidx->size[0];
if (!((j + 1 >= 1) && (j + 1 <= ix))) {
emlrtDynamicBoundsCheckR2012b(j + 1, 1, ix, &bb_emlrtBCI, sp);
}
idx = context->size[1];
ix = context->size[0];
iy = (int32_T)occidx->data[j];
if (!((iy >= 1) && (iy <= ix))) {
emlrtDynamicBoundsCheckR2012b(iy, 1, ix, &g_emlrtBCI, sp);
}
ix = curr_col->size[0] * curr_col->size[1];
curr_col->size[0] = 1;
curr_col->size[1] = idx;
emxEnsureCapacity(sp, (emxArray__common *)curr_col, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
for (ix = 0; ix < idx; ix++) {
curr_col->data[curr_col->size[0] * ix] = context->data[(iy + context->
size[0] * ix) - 1];
}
ix = nei_idx->size[0];
nx = (int32_T)occidx->data[j];
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &h_emlrtBCI, sp);
}
ix = nei_weight->size[0];
nx = (int32_T)occidx->data[j];
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &i_emlrtBCI, sp);
}
emlrtForLoopVectorCheckR2012b(1.0, 1.0, nei_filter_n, mxDOUBLE_CLASS,
(int32_T)nei_filter_n, &p_emlrtRTEI, sp);
k = 0;
while (k <= (int32_T)nei_filter_n - 1) {
/* For all neighbor cells */
ix = curr_col->size[1];
nx = k + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &j_emlrtBCI, sp);
}
ix = nei_idx->size[1];
nx = k + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &k_emlrtBCI, sp);
}
ix = nei_weight->size[1];
nx = k + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &l_emlrtBCI, sp);
}
iy = (int32_T)occidx->data[j];
if (nei_idx->data[(iy + nei_idx->size[0] * k) - 1] != 0.0) {
/* If properly connected, propagate */
iy = (int32_T)occidx->data[j];
d0 = nei_idx->data[(iy + nei_idx->size[0] * k) - 1];
if (d0 != (int32_T)muDoubleScalarFloor(d0)) {
emlrtIntegerCheckR2012b(d0, &emlrtDCI, sp);
}
ix = context->size[0];
nx = (int32_T)d0;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &m_emlrtBCI, sp);
}
ix = context->size[1];
nx = k + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &n_emlrtBCI, sp);
}
/* Maximum value thresholding */
iy = (int32_T)occidx->data[j];
idx = (int32_T)occidx->data[j];
nx = (int32_T)occidx->data[j];
ix = context->size[0];
nx = (int32_T)nei_idx->data[(nx + nei_idx->size[0] * k) - 1];
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &cb_emlrtBCI, sp);
}
ix = context->size[1];
if (!((k + 1 >= 1) && (k + 1 <= ix))) {
emlrtDynamicBoundsCheckR2012b(k + 1, 1, ix, &db_emlrtBCI, sp);
}
context->data[(nx + context->size[0] * k) - 1] = muDoubleScalarMax
(context->data[((int32_T)nei_idx->data[(iy + nei_idx->size[0] * k) - 1]
+ context->size[0] * k) - 1], muDoubleScalarMin
(nei_weight->data[(idx + nei_weight->size[0] * k) - 1] *
curr_col->data[k], maxthreshold));
/* Make sure current context propagation does not weaken the flow information */
}
k++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
j++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
emxFree_real_T(&occidx);
emxInit_real_T1(sp, &tempcontext, 2, &k_emlrtRTEI, true);
/* 5 Uncertainty in acceleration */
ix = tempcontext->size[0] * tempcontext->size[1];
tempcontext->size[0] = context->size[0];
tempcontext->size[1] = context->size[1];
emxEnsureCapacity(sp, (emxArray__common *)tempcontext, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = context->size[0] * context->size[1];
for (ix = 0; ix < idx; ix++) {
tempcontext->data[ix] = context->data[ix];
}
emlrtForLoopVectorCheckR2012b(1.0, 1.0, nei_filter_n, mxDOUBLE_CLASS, (int32_T)
nei_filter_n, &q_emlrtRTEI, sp);
j = 0;
emxInit_real_T1(sp, &b_nei4u_weight, 2, &emlrtRTEI, true);
while (j <= (int32_T)nei_filter_n - 1) {
/* For all context level */
k = 0;
while (k <= nei_idx->size[0] - 1) {
/* For all cells */
sumval = 0.0;
emlrtForLoopVectorCheckR2012b(1.0, 1.0, nei4u_filter_n, mxDOUBLE_CLASS,
(int32_T)nei4u_filter_n, &r_emlrtRTEI, sp);
m = 0;
while (m <= (int32_T)nei4u_filter_n - 1) {
ix = nei4u_idx->size[0];
nx = k + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &o_emlrtBCI, sp);
}
ix = nei4u_idx->size[1];
nx = m + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &p_emlrtBCI, sp);
}
ix = nei4u_weight->size[0];
nx = k + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &q_emlrtBCI, sp);
}
ix = nei4u_weight->size[1];
nx = m + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &r_emlrtBCI, sp);
}
idx = nei4u_weight->size[1];
ix = nei4u_weight->size[0];
nx = 1 + k;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &s_emlrtBCI, sp);
}
ix = b_nei4u_weight->size[0] * b_nei4u_weight->size[1];
b_nei4u_weight->size[0] = 1;
b_nei4u_weight->size[1] = idx;
emxEnsureCapacity(sp, (emxArray__common *)b_nei4u_weight, ix, (int32_T)
sizeof(real_T), &emlrtRTEI);
for (ix = 0; ix < idx; ix++) {
b_nei4u_weight->data[b_nei4u_weight->size[0] * ix] =
nei4u_weight->data[(nx + nei4u_weight->size[0] * ix) - 1];
}
st.site = &f_emlrtRSI;
mtmp = sum(&st, b_nei4u_weight);
if (nei4u_idx->data[k + nei4u_idx->size[0] * m] != 0.0) {
d0 = nei4u_idx->data[k + nei4u_idx->size[0] * m];
if (d0 != (int32_T)muDoubleScalarFloor(d0)) {
emlrtIntegerCheckR2012b(d0, &b_emlrtDCI, sp);
}
ix = context->size[0];
nx = (int32_T)d0;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &t_emlrtBCI, sp);
}
ix = context->size[1];
nx = j + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &u_emlrtBCI, sp);
}
sumval += nei4u_weight->data[k + nei4u_weight->size[0] * m] / mtmp *
context->data[((int32_T)nei4u_idx->data[k + nei4u_idx->size[0] * m]
+ context->size[0] * j) - 1];
}
m++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
ix = tempcontext->size[0];
nx = 1 + k;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &y_emlrtBCI, sp);
}
ix = tempcontext->size[1];
if (!((j + 1 >= 1) && (j + 1 <= ix))) {
emlrtDynamicBoundsCheckR2012b(j + 1, 1, ix, &ab_emlrtBCI, sp);
}
tempcontext->data[(nx + tempcontext->size[0] * j) - 1] = sumval;
k++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
j++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
emxFree_real_T(&b_nei4u_weight);
ix = context->size[0] * context->size[1];
context->size[0] = tempcontext->size[0];
context->size[1] = tempcontext->size[1];
emxEnsureCapacity(sp, (emxArray__common *)context, ix, (int32_T)sizeof(real_T),
&emlrtRTEI);
idx = tempcontext->size[1];
for (ix = 0; ix < idx; ix++) {
iy = tempcontext->size[0];
for (nx = 0; nx < iy; nx++) {
context->data[nx + context->size[0] * ix] = tempcontext->data[nx +
tempcontext->size[0] * ix];
}
}
if (do_attenuation_first == 0.0) {
/* 2 Attenuate unoccupied cells */
j = 0;
while (j <= nrnocc) {
/* For unoccupied cells, attenuate */
ix = noccidx->size[0];
nx = j + 1;
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &v_emlrtBCI, sp);
}
ix = context->size[0];
nx = (int32_T)noccidx->data[j];
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &w_emlrtBCI, sp);
}
idx = context->size[1];
iy = (int32_T)noccidx->data[j];
ix = updt_col->size[0] * updt_col->size[1];
updt_col->size[0] = 1;
updt_col->size[1] = idx;
emxEnsureCapacity(sp, (emxArray__common *)updt_col, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
for (ix = 0; ix < idx; ix++) {
updt_col->data[updt_col->size[0] * ix] = context->data[(iy +
context->size[0] * ix) - 1] * nocc_attenuaterate;
}
ix = context->size[0];
nx = (int32_T)noccidx->data[j];
if (!((nx >= 1) && (nx <= ix))) {
emlrtDynamicBoundsCheckR2012b(nx, 1, ix, &x_emlrtBCI, sp);
}
idx = context->size[1];
ix = ii->size[0];
ii->size[0] = idx;
emxEnsureCapacity(sp, (emxArray__common *)ii, ix, (int32_T)sizeof(int32_T),
&emlrtRTEI);
for (ix = 0; ix < idx; ix++) {
ii->data[ix] = ix;
}
iv5[0] = 1;
iv5[1] = ii->size[0];
emlrtSubAssignSizeCheckR2012b(iv5, 2, *(int32_T (*)[2])updt_col->size, 2,
&d_emlrtECI, sp);
iy = (int32_T)noccidx->data[j];
idx = updt_col->size[1];
for (ix = 0; ix < idx; ix++) {
context->data[(iy + context->size[0] * ii->data[ix]) - 1] =
updt_col->data[updt_col->size[0] * ix];
}
j++;
if (*emlrtBreakCheckR2012bFlagVar != 0) {
emlrtBreakCheckR2012b(sp);
}
}
}
emxFree_int32_T(&ii);
emxFree_real_T(&updt_col);
emxFree_real_T(&noccidx);
/* 6 Prediction */
st.site = &g_emlrtRSI;
ix = tempcontext->size[0] * tempcontext->size[1];
tempcontext->size[0] = context->size[1];
tempcontext->size[1] = context->size[0];
emxEnsureCapacity(&st, (emxArray__common *)tempcontext, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = context->size[0];
for (ix = 0; ix < idx; ix++) {
iy = context->size[1];
for (nx = 0; nx < iy; nx++) {
tempcontext->data[nx + tempcontext->size[0] * ix] = context->data[ix +
context->size[0] * nx];
}
}
b_st.site = &n_emlrtRSI;
c_st.site = &o_emlrtRSI;
if (((tempcontext->size[0] == 1) && (tempcontext->size[1] == 1)) ||
(tempcontext->size[0] != 1)) {
overflow = true;
} else {
overflow = false;
}
if (overflow) {
} else {
emlrtErrorWithMessageIdR2012b(&c_st, &u_emlrtRTEI,
"Coder:toolbox:autoDimIncompatibility", 0);
}
if (tempcontext->size[0] > 0) {
} else {
emlrtErrorWithMessageIdR2012b(&c_st, &v_emlrtRTEI,
"Coder:toolbox:eml_min_or_max_varDimZero", 0);
}
ix = curr_col->size[0] * curr_col->size[1];
curr_col->size[0] = 1;
curr_col->size[1] = tempcontext->size[1];
emxEnsureCapacity(&c_st, (emxArray__common *)curr_col, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
n = tempcontext->size[0];
ix = 0;
iy = -1;
d_st.site = &ab_emlrtRSI;
if (1 > tempcontext->size[1]) {
overflow = false;
} else {
overflow = (tempcontext->size[1] > 2147483646);
}
if (overflow) {
e_st.site = &l_emlrtRSI;
check_forloop_overflow_error(&e_st);
}
for (nx = 1; nx <= tempcontext->size[1]; nx++) {
d_st.site = &bb_emlrtRSI;
ixstart = ix;
idx = ix + n;
mtmp = tempcontext->data[ix];
if (n > 1) {
if (muDoubleScalarIsNaN(tempcontext->data[ix])) {
e_st.site = &r_emlrtRSI;
if (ix + 2 > idx) {
b_ix = false;
} else {
b_ix = (idx > 2147483646);
}
if (b_ix) {
f_st.site = &l_emlrtRSI;
check_forloop_overflow_error(&f_st);
}
k = ix + 1;
exitg2 = false;
while ((!exitg2) && (k + 1 <= idx)) {
ixstart = k;
if (!muDoubleScalarIsNaN(tempcontext->data[k])) {
mtmp = tempcontext->data[k];
exitg2 = true;
} else {
k++;
}
}
}
if (ixstart + 1 < idx) {
e_st.site = &q_emlrtRSI;
if (ixstart + 2 > idx) {
b_ixstart = false;
} else {
b_ixstart = (idx > 2147483646);
}
if (b_ixstart) {
f_st.site = &l_emlrtRSI;
check_forloop_overflow_error(&f_st);
}
for (k = ixstart + 1; k + 1 <= idx; k++) {
if (tempcontext->data[k] > mtmp) {
mtmp = tempcontext->data[k];
}
}
}
}
iy++;
curr_col->data[iy] = mtmp;
ix += n;
}
emxFree_real_T(&tempcontext);
ix = maxvec->size[0];
maxvec->size[0] = curr_col->size[1];
emxEnsureCapacity(sp, (emxArray__common *)maxvec, ix, (int32_T)sizeof(real_T),
&emlrtRTEI);
idx = curr_col->size[1];
for (ix = 0; ix < idx; ix++) {
maxvec->data[ix] = curr_col->data[curr_col->size[0] * ix];
}
emxFree_real_T(&curr_col);
st.site = &h_emlrtRSI;
/* sigm_a <= if we increase the value, than the sigm function gets peaky! */
b_st.site = &cb_emlrtRSI;
ix = predvec->size[0];
predvec->size[0] = maxvec->size[0];
emxEnsureCapacity(&b_st, (emxArray__common *)predvec, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = maxvec->size[0];
for (ix = 0; ix < idx; ix++) {
predvec->data[ix] = -sigm_coef * maxvec->data[ix];
}
c_st.site = &cb_emlrtRSI;
b_exp(&c_st, predvec);
ix = predvec->size[0];
emxEnsureCapacity(&b_st, (emxArray__common *)predvec, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = predvec->size[0];
for (ix = 0; ix < idx; ix++) {
predvec->data[ix] = 1.0 - predvec->data[ix];
}
ix = newlyoccidx->size[0];
newlyoccidx->size[0] = maxvec->size[0];
emxEnsureCapacity(&b_st, (emxArray__common *)newlyoccidx, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = maxvec->size[0];
for (ix = 0; ix < idx; ix++) {
newlyoccidx->data[ix] = -sigm_coef * maxvec->data[ix];
}
c_st.site = &cb_emlrtRSI;
b_exp(&c_st, newlyoccidx);
ix = newlyoccidx->size[0];
emxEnsureCapacity(&b_st, (emxArray__common *)newlyoccidx, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = newlyoccidx->size[0];
for (ix = 0; ix < idx; ix++) {
newlyoccidx->data[ix]++;
}
varargin_1[0] = predvec->size[0];
varargin_1[1] = 1;
varargin_2[0] = newlyoccidx->size[0];
varargin_2[1] = 1;
overflow = false;
p = true;
k = 0;
exitg1 = false;
while ((!exitg1) && (k < 2)) {
if (!(varargin_1[k] == varargin_2[k])) {
p = false;
exitg1 = true;
} else {
k++;
}
}
if (!p) {
} else {
overflow = true;
}
if (overflow) {
} else {
emlrtErrorWithMessageIdR2012b(&b_st, &w_emlrtRTEI, "MATLAB:dimagree", 0);
}
ix = predvec->size[0];
emxEnsureCapacity(&b_st, (emxArray__common *)predvec, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = predvec->size[0];
for (ix = 0; ix < idx; ix++) {
predvec->data[ix] /= newlyoccidx->data[ix];
}
emxFree_real_T(&newlyoccidx);
/* 7 Save previous grid */
ix = cgridvecprev->size[0];
cgridvecprev->size[0] = cgridvec->size[0];
emxEnsureCapacity(sp, (emxArray__common *)cgridvecprev, ix, (int32_T)sizeof
(real_T), &emlrtRTEI);
idx = cgridvec->size[0];
for (ix = 0; ix < idx; ix++) {
cgridvecprev->data[ix] = cgridvec->data[ix];
}
emlrtHeapReferenceStackLeaveFcnR2012b(sp);
}
