File: bmlms.c1 /* 2 * bmlms.c 3 * 4 * Code generation for function 'bmlms' 5 * 6 */ 7 8 /* Include files */ 9 #include "rt_nonfinite.h" 10 #include "gjbf.h" 11 #include "bmlms.h" 12 #include "mclms.h" 13 #include "gjbf_emxutil.h" 14 #include "CCAF.h" 15 #include "optwbm.h" 16 #include "AMC.h" 17 #include "targbm.h" 18 #include "all.h" 19 #include "isfinite.h" 20 #include "mod.h" 21 #include "gjbf_mexutil.h" 22 #include "gjbf_data.h" 23 #include "blas.h" 24 25 /* Variable Definitions */ 26 static emlrtRSInfo bc_emlrtRSI = { 102, "bmlms", 27 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 28 29 static emlrtRSInfo cc_emlrtRSI = { 100, "bmlms", 30 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 31 32 static emlrtRSInfo dc_emlrtRSI = { 95, "bmlms", 33 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 34 35 static emlrtRSInfo ec_emlrtRSI = { 88, "bmlms", 36 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 37 38 static emlrtRSInfo fc_emlrtRSI = { 51, "bmlms", 39 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 40 41 static emlrtRSInfo gc_emlrtRSI = { 50, "bmlms", 42 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 43 44 static emlrtRSInfo hc_emlrtRSI = { 48, "bmlms", 45 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 46 47 static emlrtRSInfo ic_emlrtRSI = { 47, "bmlms", 48 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 49 50 static emlrtRSInfo jc_emlrtRSI = { 40, "bmlms", 51 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 52 53 static emlrtRSInfo kc_emlrtRSI = { 35, "bmlms", 54 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 55 56 static emlrtRSInfo lc_emlrtRSI = { 27, "bmlms", 57 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 58 59 static emlrtRSInfo mc_emlrtRSI = { 26, "bmlms", 60 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 61 62 static emlrtRSInfo nc_emlrtRSI = { 24, "bmlms", 63 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 64 65 static emlrtRSInfo oc_emlrtRSI = { 21, "bmlms", 66 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 67 68 static emlrtRSInfo pc_emlrtRSI = { 17, "bmlms", 69 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 70 71 static emlrtRSInfo qc_emlrtRSI = { 15, "bmlms", 72 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 73 74 static emlrtRSInfo rc_emlrtRSI = { 14, "bmlms", 75 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 76 77 static emlrtRSInfo sc_emlrtRSI = { 12, "bmlms", 78 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 79 80 static emlrtRSInfo tc_emlrtRSI = { 10, "bmlms", 81 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 82 83 static emlrtRSInfo uc_emlrtRSI = { 9, "bmlms", 84 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 85 86 static emlrtRTEInfo b_emlrtRTEI = { 4, 36, "bmlms", 87 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 88 89 static emlrtECInfo c_emlrtECI = { -1, 104, 1, "bmlms", 90 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m" }; 91 92 static emlrtDCInfo g_emlrtDCI = { 60, 13, "bmlms", 93 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m", 1 }; 94 95 static emlrtDCInfo h_emlrtDCI = { 60, 13, "bmlms", 96 "E:\\micro array project\\Microphone Array\\beamform test\\bmlms.m", 4 }; 97 98 /* Function Definitions */ 99 void bmlms(const emlrtStack *sp, const real_T x[14112], const real_T b[882], 100 real_T mu, real_T order, real_T beta, const real_T phi[320], const 101 real_T psi[320], const real_T bp_data[], const int32_T bp_size[1], 102 const real_T bw1[320], real_T snrThresh, real_T snrRate, const real_T 103 snr1[16], real_T z[14112], emxArray_real_T *bmw, real_T mcAdapt[14112], 104 real_T snrAll[14112]) 105 { 106 boolean_T b2; 107 boolean_T bv11[14112]; 108 int32_T i31; 109 boolean_T amcInds[16]; 110 boolean_T y; 111 int32_T k; 112 boolean_T exitg1; 113 boolean_T bv12[882]; 114 const mxArray *b_y; 115 char_T u[23]; 116 static const char_T varargin_1[23] = { 'x', ' ', 'm', 'u', 's', 't', ' ', 'b', 117 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 'r', 'i', 'x' }; 118 119 const mxArray *m22; 120 static const int32_T iv25[2] = { 1, 23 }; 121 122 const mxArray *c_y; 123 char_T b_u[23]; 124 static const char_T b_varargin_1[23] = { 'b', ' ', 'm', 'u', 's', 't', ' ', 125 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'v', 'e', 'c', 't', 'o', 126 'r' }; 127 128 boolean_T tmp_data[1764]; 129 static const int32_T iv26[2] = { 1, 23 }; 130 131 boolean_T b_tmp_data[1764]; 132 boolean_T c_tmp_data[1764]; 133 int32_T tmp_size[1]; 134 real_T d1; 135 const mxArray *d_y; 136 char_T c_u[24]; 137 static const char_T c_varargin_1[24] = { 'b', 'p', ' ', 'm', 'u', 's', 't', 138 ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'v', 'e', 'c', 't', 139 'o', 'r' }; 140 141 static const int32_T iv27[2] = { 1, 24 }; 142 143 boolean_T guard1 = false; 144 boolean_T guard2 = false; 145 const mxArray *e_y; 146 char_T d_u[24]; 147 static const char_T d_varargin_1[24] = { 'm', 'u', ' ', 'm', 'u', 's', 't', 148 ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 's', 'c', 'a', 'l', 149 'a', 'r' }; 150 151 static const int32_T iv28[2] = { 1, 24 }; 152 153 real_T w[320]; 154 const mxArray *f_y; 155 char_T e_u[32]; 156 static const char_T e_varargin_1[32] = { 'o', 'r', 'd', 'e', 'r', ' ', 'm', 157 'u', 's', 't', ' ', 'b', 'e', ' ', 'a', ' ', 'p', 'o', 's', 'i', 't', 'i', 158 'v', 'e', ' ', 'i', 'n', 't', 'e', 'g', 'e', 'r' }; 159 160 const mxArray *g_y; 161 char_T f_u[34]; 162 static const char_T f_varargin_1[34] = { 's', 'n', 'r', 'R', 'a', 't', 'e', 163 ' ', 'm', 'u', 's', 't', ' ', 'b', 'e', ' ', 'a', ' ', 'p', 'o', 's', 'i', 164 't', 'i', 'v', 'e', ' ', 'i', 'n', 't', 'e', 'g', 'e', 'r' }; 165 166 static const int32_T iv29[2] = { 1, 32 }; 167 168 static const int32_T iv30[2] = { 1, 34 }; 169 170 const mxArray *h_y; 171 char_T g_u[35]; 172 static const char_T g_varargin_1[35] = { 'b', 'e', 't', 'a', ' ', 'm', 'u', 173 's', 't', ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 's', 'c', 174 'a', 'l', 'a', 'r', ' ', 'i', 'n', ' ', '[', '0', ',', '1', ']' }; 175 176 boolean_T bv13[320]; 177 static const int32_T iv31[2] = { 1, 35 }; 178 179 real_T snr[16]; 180 const mxArray *i_y; 181 char_T h_u[25]; 182 static const char_T h_varargin_1[25] = { 'b', 'w', '1', ' ', 'm', 'u', 's', 183 't', ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 184 'r', 'i', 'x' }; 185 186 static const int32_T iv32[2] = { 1, 25 }; 187 188 int32_T n; 189 emxArray_int32_T *r0; 190 const mxArray *j_y; 191 char_T i_u[31]; 192 static const char_T i_varargin_1[31] = { 's', 'n', 'r', 'T', 'h', 'r', 'e', 193 's', 'h', ' ', 'm', 'u', 's', 't', ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 194 'a', 'l', ' ', 's', 'c', 'a', 'l', 'a', 'r' }; 195 196 static const int32_T iv33[2] = { 1, 31 }; 197 198 real_T bWin_data[1764]; 199 boolean_T bv14[320]; 200 boolean_T bv15[320]; 201 const mxArray *k_y; 202 char_T j_u[25]; 203 static const char_T j_varargin_1[25] = { 'p', 'h', 'i', ' ', 'm', 'u', 's', 204 't', ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 205 'r', 'i', 'x' }; 206 207 static const int32_T iv34[2] = { 1, 25 }; 208 209 int32_T iv35[2]; 210 int32_T iv36[2]; 211 const mxArray *l_y; 212 char_T k_u[25]; 213 static const char_T k_varargin_1[25] = { 'p', 's', 'i', ' ', 'm', 'u', 's', 214 't', ' ', 'b', 'e', ' ', 'a', ' ', 'r', 'e', 'a', 'l', ' ', 'm', 'a', 't', 215 'r', 'i', 'x' }; 216 217 static const int32_T iv37[2] = { 1, 25 }; 218 219 int32_T i32; 220 emlrtStack st; 221 emlrtStack b_st; 222 st.prev = sp; 223 st.tls = sp->tls; 224 b_st.prev = &st; 225 b_st.tls = st.tls; 226 emlrtHeapReferenceStackEnterFcnR2012b(sp); 227 b2 = false; 228 covrtLogFcn(&emlrtCoverageInstance, 3U, 0); 229 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 0); 230 231 /* % Blocking Matrix LMS Filter */ 232 /* % Function Declaration */ 233 /* % Argument Error Checking */ 234 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 0, true); 235 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 1, false); 236 for (i31 = 0; i31 < 14112; i31++) { 237 bv11[i31] = ((!muDoubleScalarIsInf(x[i31])) && (!muDoubleScalarIsNaN(x[i31]))); 238 } 239 240 st.site = &uc_emlrtRSI; 241 all(&st, bv11, amcInds); 242 y = true; 243 k = 0; 244 exitg1 = false; 245 while ((!exitg1) && (k < 16)) { 246 if (!amcInds[k]) { 247 y = false; 248 exitg1 = true; 249 } else { 250 k++; 251 } 252 } 253 254 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 2, y)) { 255 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 0, true); 256 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 0, true); 257 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 1); 258 st.site = &tc_emlrtRSI; 259 for (i31 = 0; i31 < 23; i31++) { 260 u[i31] = varargin_1[i31]; 261 } 262 263 b_y = NULL; 264 m22 = emlrtCreateCharArray(2, iv25); 265 emlrtInitCharArrayR2013a(&st, 23, m22, &u[0]); 266 emlrtAssign(&b_y, m22); 267 b_st.site = &af_emlrtRSI; 268 ab_error(&b_st, b_y, &emlrtMCI); 269 } else { 270 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 0, false); 271 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 0, false); 272 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 3, true); 273 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 4, true); 274 for (k = 0; k < 882; k++) { 275 bv12[k] = ((!muDoubleScalarIsInf(b[k])) && (!muDoubleScalarIsNaN(b[k]))); 276 } 277 278 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 5, h_all(bv12))) { 279 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 1, true); 280 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 1, true); 281 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 2); 282 st.site = &sc_emlrtRSI; 283 for (i31 = 0; i31 < 23; i31++) { 284 b_u[i31] = b_varargin_1[i31]; 285 } 286 287 c_y = NULL; 288 m22 = emlrtCreateCharArray(2, iv26); 289 emlrtInitCharArrayR2013a(&st, 23, m22, &b_u[0]); 290 emlrtAssign(&c_y, m22); 291 b_st.site = &af_emlrtRSI; 292 ab_error(&b_st, c_y, &emlrtMCI); 293 } else { 294 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 1, false); 295 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 1, false); 296 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 6, true); 297 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 7, true); 298 k = bp_size[0]; 299 for (i31 = 0; i31 < k; i31++) { 300 tmp_data[i31] = muDoubleScalarIsInf(bp_data[i31]); 301 } 302 303 k = bp_size[0]; 304 for (i31 = 0; i31 < k; i31++) { 305 c_tmp_data[i31] = muDoubleScalarIsNaN(bp_data[i31]); 306 } 307 308 tmp_size[0] = bp_size[0]; 309 k = bp_size[0]; 310 for (i31 = 0; i31 < k; i31++) { 311 b_tmp_data[i31] = ((!tmp_data[i31]) && (!c_tmp_data[i31])); 312 } 313 314 st.site = &rc_emlrtRSI; 315 y = g_all(&st, b_tmp_data, tmp_size); 316 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 8, y)) { 317 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 2, true); 318 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 2, true); 319 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 3); 320 st.site = &qc_emlrtRSI; 321 for (i31 = 0; i31 < 24; i31++) { 322 c_u[i31] = c_varargin_1[i31]; 323 } 324 325 d_y = NULL; 326 m22 = emlrtCreateCharArray(2, iv27); 327 emlrtInitCharArrayR2013a(&st, 24, m22, &c_u[0]); 328 emlrtAssign(&d_y, m22); 329 b_st.site = &af_emlrtRSI; 330 ab_error(&b_st, d_y, &emlrtMCI); 331 } else { 332 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 2, false); 333 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 2, false); 334 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 9, false); 335 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 10, true); 336 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 11, true); 337 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 12, c_isfinite(mu))) { 338 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 3, true); 339 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 3, true); 340 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 4); 341 st.site = &pc_emlrtRSI; 342 for (i31 = 0; i31 < 24; i31++) { 343 d_u[i31] = d_varargin_1[i31]; 344 } 345 346 e_y = NULL; 347 m22 = emlrtCreateCharArray(2, iv28); 348 emlrtInitCharArrayR2013a(&st, 24, m22, &d_u[0]); 349 emlrtAssign(&e_y, m22); 350 b_st.site = &af_emlrtRSI; 351 ab_error(&b_st, e_y, &emlrtMCI); 352 } else { 353 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 3, false); 354 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 3, false); 355 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 13, false); 356 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 14, true); 357 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 15, true); 358 guard1 = false; 359 guard2 = false; 360 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 16, c_isfinite(order))) 361 { 362 guard2 = true; 363 } else { 364 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 17, order < 0.0); 365 if (covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 18, 366 muDoubleScalarAbs(b_mod(order, muDoubleScalarFloor 367 (order))) > 0.0)) { 368 guard2 = true; 369 } else { 370 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 4, false); 371 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 4, false); 372 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 19, false); 373 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 20, true); 374 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 21, true); 375 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 22, c_isfinite 376 (beta))) { 377 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 5, true); 378 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 5, true); 379 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 6); 380 st.site = &nc_emlrtRSI; 381 for (i31 = 0; i31 < 35; i31++) { 382 g_u[i31] = g_varargin_1[i31]; 383 } 384 385 h_y = NULL; 386 m22 = emlrtCreateCharArray(2, iv31); 387 emlrtInitCharArrayR2013a(&st, 35, m22, &g_u[0]); 388 emlrtAssign(&h_y, m22); 389 b_st.site = &af_emlrtRSI; 390 ab_error(&b_st, h_y, &emlrtMCI); 391 } else { 392 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 23, beta < 0.0); 393 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 24, beta > 1.0); 394 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 5, false); 395 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 5, false); 396 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 25, false); 397 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 26, false); 398 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 27, true); 399 f_isfinite(bw1, bv13); 400 st.site = &mc_emlrtRSI; 401 e_all(&st, bv13, amcInds); 402 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 28, b_all 403 (amcInds))) { 404 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 6, true); 405 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 6, true); 406 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 7); 407 st.site = &lc_emlrtRSI; 408 for (i31 = 0; i31 < 25; i31++) { 409 h_u[i31] = h_varargin_1[i31]; 410 } 411 412 i_y = NULL; 413 m22 = emlrtCreateCharArray(2, iv32); 414 emlrtInitCharArrayR2013a(&st, 25, m22, &h_u[0]); 415 emlrtAssign(&i_y, m22); 416 b_st.site = &af_emlrtRSI; 417 ab_error(&b_st, i_y, &emlrtMCI); 418 } else { 419 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 6, false); 420 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 6, false); 421 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 29, true); 422 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 7, false); 423 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 7, false); 424 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 35, false); 425 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 36, true); 426 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 37, true); 427 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 38, 428 c_isfinite(snrThresh))) { 429 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 8, true); 430 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 8, true); 431 st.site = &kc_emlrtRSI; 432 for (i31 = 0; i31 < 31; i31++) { 433 i_u[i31] = i_varargin_1[i31]; 434 } 435 436 j_y = NULL; 437 m22 = emlrtCreateCharArray(2, iv33); 438 emlrtInitCharArrayR2013a(&st, 31, m22, &i_u[0]); 439 emlrtAssign(&j_y, m22); 440 b_st.site = &af_emlrtRSI; 441 ab_error(&b_st, j_y, &emlrtMCI); 442 } else { 443 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 8, false); 444 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 8, false); 445 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 39, false); 446 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 40, true); 447 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 41, true); 448 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 42, 449 c_isfinite(snrRate))) { 450 guard1 = true; 451 } else { 452 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 43, snrRate < 453 0.0); 454 if (covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 44, 455 muDoubleScalarAbs(b_mod(snrRate, 456 muDoubleScalarFloor(snrRate))) > 0.0)) { 457 guard1 = true; 458 } else { 459 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 9, false); 460 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 9, false); 461 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 10, false); 462 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 45, false); 463 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 46, true); 464 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 47, true); 465 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 10, false); 466 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 11, false); 467 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 48, false); 468 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 49, false); 469 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 50, true); 470 f_isfinite(phi, bv14); 471 st.site = &ic_emlrtRSI; 472 e_all(&st, bv14, amcInds); 473 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 51, 474 b_all(amcInds))) { 475 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 11, true); 476 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 12, true); 477 st.site = &hc_emlrtRSI; 478 for (i31 = 0; i31 < 25; i31++) { 479 j_u[i31] = j_varargin_1[i31]; 480 } 481 482 k_y = NULL; 483 m22 = emlrtCreateCharArray(2, iv34); 484 emlrtInitCharArrayR2013a(&st, 25, m22, &j_u[0]); 485 emlrtAssign(&k_y, m22); 486 b_st.site = &af_emlrtRSI; 487 ab_error(&b_st, k_y, &emlrtMCI); 488 } else { 489 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 11, false); 490 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 12, false); 491 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 52, false); 492 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 53, false); 493 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 54, true); 494 f_isfinite(psi, bv15); 495 st.site = &gc_emlrtRSI; 496 e_all(&st, bv15, amcInds); 497 if (!covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 55, 498 b_all(amcInds))) { 499 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 12, 500 true); 501 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 13, true); 502 st.site = &fc_emlrtRSI; 503 for (i31 = 0; i31 < 25; i31++) { 504 k_u[i31] = k_varargin_1[i31]; 505 } 506 507 l_y = NULL; 508 m22 = emlrtCreateCharArray(2, iv37); 509 emlrtInitCharArrayR2013a(&st, 25, m22, &k_u[0]); 510 emlrtAssign(&l_y, m22); 511 b_st.site = &af_emlrtRSI; 512 ab_error(&b_st, l_y, &emlrtMCI); 513 } else { 514 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 12, 515 false); 516 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 13, false); 517 } 518 } 519 } 520 } 521 } 522 } 523 } 524 } 525 } 526 527 if (guard2) { 528 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 4, true); 529 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 4, true); 530 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 5); 531 st.site = &oc_emlrtRSI; 532 for (i31 = 0; i31 < 32; i31++) { 533 e_u[i31] = e_varargin_1[i31]; 534 } 535 536 f_y = NULL; 537 m22 = emlrtCreateCharArray(2, iv29); 538 emlrtInitCharArrayR2013a(&st, 32, m22, &e_u[0]); 539 emlrtAssign(&f_y, m22); 540 b_st.site = &af_emlrtRSI; 541 ab_error(&b_st, f_y, &emlrtMCI); 542 } 543 544 if (guard1) { 545 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 9, true); 546 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 9, true); 547 st.site = &jc_emlrtRSI; 548 for (i31 = 0; i31 < 34; i31++) { 549 f_u[i31] = f_varargin_1[i31]; 550 } 551 552 g_y = NULL; 553 m22 = emlrtCreateCharArray(2, iv30); 554 emlrtInitCharArrayR2013a(&st, 34, m22, &f_u[0]); 555 emlrtAssign(&g_y, m22); 556 b_st.site = &af_emlrtRSI; 557 ab_error(&b_st, g_y, &emlrtMCI); 558 } 559 } 560 } 561 } 562 } 563 564 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 10); 565 566 /* % Adaptive Filtering */ 567 /* % inital values of BMLMS */ 568 /* length of tracks, number of mics */ 569 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 14, false); 570 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 12); 571 572 /* initial targbm */ 573 i31 = bmw->size[0] * bmw->size[1] * bmw->size[2]; 574 if (!(order >= 0.0)) { 575 emlrtNonNegativeCheckR2012b(order, &h_emlrtDCI, sp); 576 } 577 578 d1 = order; 579 if (d1 != (int32_T)muDoubleScalarFloor(d1)) { 580 emlrtIntegerCheckR2012b(d1, &g_emlrtDCI, sp); 581 } 582 583 bmw->size[0] = (int32_T)d1; 584 bmw->size[1] = 16; 585 bmw->size[2] = 882; 586 emxEnsureCapacity(sp, (emxArray__common *)bmw, i31, (int32_T)sizeof(real_T), 587 &b_emlrtRTEI); 588 if (!(order >= 0.0)) { 589 emlrtNonNegativeCheckR2012b(order, &h_emlrtDCI, sp); 590 } 591 592 if (d1 != (int32_T)muDoubleScalarFloor(d1)) { 593 emlrtIntegerCheckR2012b(d1, &g_emlrtDCI, sp); 594 } 595 596 k = ((int32_T)d1 << 4) * 882; 597 for (i31 = 0; i31 < k; i31++) { 598 bmw->data[i31] = 0.0; 599 } 600 601 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 56, false); 602 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 13, true); 603 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 15, true); 604 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 13); 605 memcpy(&w[0], &bw1[0], 320U * sizeof(real_T)); 606 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 15); 607 for (i31 = 0; i31 < 14112; i31++) { 608 z[i31] = 0.0; 609 } 610 611 /* initial AMC */ 612 for (i31 = 0; i31 < 14112; i31++) { 613 mcAdapt[i31] = 0.0; 614 } 615 616 /* Matrix of columns to adapt in MC */ 617 /* amcInds=gt(snr,snrThresh); */ 618 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 57, false); 619 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 14, true); 620 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 16, true); 621 622 /* Use snrInit if supplied; otherwise set to infinity so that we */ 623 /* always adapt over the first power window. */ 624 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 17, false); 625 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 17); 626 memcpy(&snr[0], &snr1[0], sizeof(real_T) << 4); 627 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 18); 628 629 /* Initial value of amcInds */ 630 for (i31 = 0; i31 < 16; i31++) { 631 amcInds[i31] = (snr1[i31] > snrThresh); 632 } 633 634 /* ord--one for each track of input x */ 635 n = 0; 636 emxInit_int32_T(sp, &r0, 1, &b_emlrtRTEI, true); 637 while (n < 882) { 638 covrtLogFor(&emlrtCoverageInstance, 3U, 0U, 0, 1); 639 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 19); 640 641 /* calculate targbm output and ready to opt */ 642 st.site = &ec_emlrtRSI; 643 targbm(&st, bp_data, bp_size, b, x, 1.0 + (real_T)n, order, w, z, bWin_data, 644 tmp_size); 645 646 /* check bmWF */ 647 covrtLogCond(&emlrtCoverageInstance, 3U, 0U, 58, true); 648 covrtLogMcdc(&emlrtCoverageInstance, 3U, 0U, 15, false); 649 covrtLogIf(&emlrtCoverageInstance, 3U, 0U, 18, false); 650 covrtLogBasicBlock(&emlrtCoverageInstance, 3U, 21); 651 652 /* If enough samples have passed and we're doing AMC */ 653 /* thresholding, find the SNR for each track. */ 654 st.site = &dc_emlrtRSI; 655 AMC(&st, b, z, 1.0 + (real_T)n, snrThresh, snrRate, snr, amcInds, mcAdapt); 656 657 /* save SNR values for debug output */ 658 for (i31 = 0; i31 < 16; i31++) { 659 snrAll[n + 882 * i31] = snr[i31]; 660 } 661 662 /* Perform LMS tap update under threshold */ 663 /* figure out if bmWForce supplied */ 664 st.site = &cc_emlrtRSI; 665 optwbm(&st, bWin_data, tmp_size, 1.0 + (real_T)n, w, z, beta, mu, amcInds); 666 667 /* CCAF (Coefficient Constrained) Tap Constraints */ 668 st.site = &bc_emlrtRSI; 669 CCAF(&st, phi, psi, order, w, amcInds); 670 671 /* Save the taps used on this iteration */ 672 k = bmw->size[0]; 673 i31 = r0->size[0]; 674 r0->size[0] = k; 675 emxEnsureCapacity(sp, (emxArray__common *)r0, i31, (int32_T)sizeof(int32_T), 676 &b_emlrtRTEI); 677 for (i31 = 0; i31 < k; i31++) { 678 r0->data[i31] = i31; 679 } 680 681 iv35[0] = r0->size[0]; 682 iv35[1] = 16; 683 if (!b2) { 684 for (i31 = 0; i31 < 2; i31++) { 685 iv36[i31] = 20 + -4 * i31; 686 } 687 688 b2 = true; 689 } 690 691 emlrtSubAssignSizeCheckR2012b(iv35, 2, iv36, 2, &c_emlrtECI, sp); 692 k = r0->size[0]; 693 for (i31 = 0; i31 < 16; i31++) { 694 for (i32 = 0; i32 < k; i32++) { 695 bmw->data[(r0->data[i32] + bmw->size[0] * i31) + bmw->size[0] * 696 bmw->size[1] * n] = w[i32 + k * i31]; 697 } 698 } 699 700 n++; 701 if (*emlrtBreakCheckR2012bFlagVar != 0) { 702 emlrtBreakCheckR2012b(sp); 703 } 704 } 705 706 emxFree_int32_T(&r0); 707 covrtLogFor(&emlrtCoverageInstance, 3U, 0U, 0, 0); 708 709 /* for n = 1:length(b) */ 710 /* bmw=w; */ 711 /* function bmlms */ 712 emlrtHeapReferenceStackLeaveFcnR2012b(sp); 713 } 714 715 /* End of code generation (bmlms.c) */ 716 |