File: optwmc.c1 /* 2 * optwmc.c 3 * 4 * Code generation for function 'optwmc' 5 * 6 */ 7 8 /* Include files */ 9 #include "rt_nonfinite.h" 10 #include "gjbf.h" 11 #include "optwmc.h" 12 #include "gjbf_emxutil.h" 13 #include "eml_int_forloop_overflow_check.h" 14 #include "scalexpAlloc.h" 15 #include "gjbf_data.h" 16 #include "blas.h" 17 18 /* Variable Definitions */ 19 static emlrtRSInfo jd_emlrtRSI = { 58, "sumprod", 20 "C:\\Program Files\\MATLAB\\R2016a\\toolbox\\eml\\lib\\matlab\\datafun\\private\\sumprod.m" 21 }; 22 23 static emlrtRSInfo ld_emlrtRSI = { 113, "combine_vector_elements", 24 "C:\\Program Files\\MATLAB\\R2016a\\toolbox\\eml\\lib\\matlab\\datafun\\private\\combine_vector_elements.m" 25 }; 26 27 static emlrtRSInfo pe_emlrtRSI = { 11, "optwmc", 28 "E:\\micro array project\\Microphone Array\\beamform test\\optwmc.m" }; 29 30 static emlrtRSInfo qe_emlrtRSI = { 15, "optwmc", 31 "E:\\micro array project\\Microphone Array\\beamform test\\optwmc.m" }; 32 33 static emlrtRSInfo re_emlrtRSI = { 99, "combine_vector_elements", 34 "C:\\Program Files\\MATLAB\\R2016a\\toolbox\\eml\\lib\\matlab\\datafun\\private\\combine_vector_elements.m" 35 }; 36 37 static emlrtRTEInfo k_emlrtRTEI = { 1, 15, "optwmc", 38 "E:\\micro array project\\Microphone Array\\beamform test\\optwmc.m" }; 39 40 static emlrtRTEInfo l_emlrtRTEI = { 7, 9, "optwmc", 41 "E:\\micro array project\\Microphone Array\\beamform test\\optwmc.m" }; 42 43 static emlrtRTEInfo ab_emlrtRTEI = { 13, 15, "rdivide", 44 "C:\\Program Files\\MATLAB\\R2016a\\toolbox\\eml\\lib\\matlab\\ops\\rdivide.m" 45 }; 46 47 static emlrtECInfo i_emlrtECI = { -1, 14, 9, "optwmc", 48 "E:\\micro array project\\Microphone Array\\beamform test\\optwmc.m" }; 49 50 static emlrtECInfo j_emlrtECI = { 2, 14, 24, "optwmc", 51 "E:\\micro array project\\Microphone Array\\beamform test\\optwmc.m" }; 52 53 static emlrtBCInfo r_emlrtBCI = { 1, 882, 10, 32, "mcAdapt", "optwmc", 54 "E:\\micro array project\\Microphone Array\\beamform test\\optwmc.m", 0 }; 55 56 static emlrtBCInfo s_emlrtBCI = { -1, -1, 12, 9, "normvec", "optwmc", 57 "E:\\micro array project\\Microphone Array\\beamform test\\optwmc.m", 0 }; 58 59 /* Function Definitions */ 60 void optwmc(const emlrtStack *sp, const emxArray_real_T *zWin, real_T n, real_T 61 w[320], const real_T mcAdapt[14112], real_T mu, real_T order, real_T 62 beta, const real_T y[14112]) 63 { 64 int32_T i47; 65 int32_T idx; 66 int8_T ii_data[16]; 67 int32_T ii_size[2]; 68 int32_T b_n; 69 static const int8_T iv63[2] = { 1, 16 }; 70 71 boolean_T exitg3; 72 boolean_T guard1 = false; 73 int32_T loop_ub; 74 int32_T xoffset; 75 emxArray_real_T *normmat; 76 int8_T amcInds_data[16]; 77 emxArray_real_T *b_zWin; 78 int32_T k; 79 uint32_T varargin_1[2]; 80 emxArray_real_T *x; 81 boolean_T p; 82 boolean_T b_p; 83 int32_T exitg2; 84 real_T normvec_data[16]; 85 int32_T normvec_size_idx_1; 86 real_T s; 87 int32_T tmp_size[2]; 88 real_T tmp_data[320]; 89 uint32_T varargin_2[2]; 90 boolean_T exitg1; 91 int32_T iv64[2]; 92 int32_T b_x[2]; 93 int32_T iv65[2]; 94 int8_T b_tmp_data[16]; 95 emlrtStack st; 96 emlrtStack b_st; 97 emlrtStack c_st; 98 emlrtStack d_st; 99 emlrtStack e_st; 100 st.prev = sp; 101 st.tls = sp->tls; 102 b_st.prev = &st; 103 b_st.tls = st.tls; 104 c_st.prev = &b_st; 105 c_st.tls = b_st.tls; 106 d_st.prev = &c_st; 107 d_st.tls = c_st.tls; 108 e_st.prev = &d_st; 109 e_st.tls = d_st.tls; 110 emlrtHeapReferenceStackEnterFcnR2012b(sp); 111 covrtLogFcn(&emlrtCoverageInstance, 10U, 0); 112 113 /* If mcAdapt specified columns requested only adapt */ 114 covrtLogIf(&emlrtCoverageInstance, 10U, 0U, 0, false); 115 covrtLogBasicBlock(&emlrtCoverageInstance, 10U, 1); 116 i47 = (int32_T)n; 117 if (!((i47 >= 1) && (i47 <= 882))) { 118 emlrtDynamicBoundsCheckR2012b(i47, 1, 882, &r_emlrtBCI, sp); 119 } 120 121 idx = 0; 122 for (i47 = 0; i47 < 2; i47++) { 123 ii_size[i47] = iv63[i47]; 124 } 125 126 b_n = 1; 127 exitg3 = false; 128 while ((!exitg3) && (b_n < 17)) { 129 guard1 = false; 130 if (mcAdapt[((int32_T)n + 882 * (b_n - 1)) - 1] != 0.0) { 131 idx++; 132 ii_data[idx - 1] = (int8_T)b_n; 133 if (idx >= 16) { 134 exitg3 = true; 135 } else { 136 guard1 = true; 137 } 138 } else { 139 guard1 = true; 140 } 141 142 if (guard1) { 143 b_n++; 144 } 145 } 146 147 if (1 > idx) { 148 loop_ub = 0; 149 } else { 150 loop_ub = idx; 151 } 152 153 if (1 > idx) { 154 ii_size[1] = 0; 155 } else { 156 ii_size[1] = idx; 157 } 158 159 xoffset = ii_size[0] * loop_ub; 160 for (i47 = 0; i47 < xoffset; i47++) { 161 amcInds_data[i47] = ii_data[i47]; 162 } 163 164 emxInit_real_T(sp, &normmat, 2, &l_emlrtRTEI, true); 165 st.site = &pe_emlrtRSI; 166 xoffset = zWin->size[0]; 167 i47 = normmat->size[0] * normmat->size[1]; 168 normmat->size[0] = xoffset; 169 normmat->size[1] = ii_size[1]; 170 emxEnsureCapacity(&st, (emxArray__common *)normmat, i47, (int32_T)sizeof 171 (real_T), &k_emlrtRTEI); 172 b_n = ii_size[1]; 173 for (i47 = 0; i47 < b_n; i47++) { 174 for (k = 0; k < xoffset; k++) { 175 idx = amcInds_data[i47]; 176 normmat->data[k + normmat->size[0] * i47] = zWin->data[k + zWin->size[0] * 177 (idx - 1)]; 178 } 179 } 180 181 emxInit_real_T(&st, &b_zWin, 2, &k_emlrtRTEI, true); 182 b_st.site = &xb_emlrtRSI; 183 c_st.site = &fd_emlrtRSI; 184 d_st.site = &gd_emlrtRSI; 185 xoffset = zWin->size[0]; 186 i47 = b_zWin->size[0] * b_zWin->size[1]; 187 b_zWin->size[0] = xoffset; 188 b_zWin->size[1] = ii_size[1]; 189 emxEnsureCapacity(&d_st, (emxArray__common *)b_zWin, i47, (int32_T)sizeof 190 (real_T), &k_emlrtRTEI); 191 b_n = ii_size[1]; 192 for (i47 = 0; i47 < b_n; i47++) { 193 for (k = 0; k < xoffset; k++) { 194 b_zWin->data[k + b_zWin->size[0] * i47] = zWin->data[k + zWin->size[0] * 195 (amcInds_data[i47] - 1)]; 196 } 197 } 198 199 for (i47 = 0; i47 < 2; i47++) { 200 varargin_1[i47] = (uint32_T)b_zWin->size[i47]; 201 } 202 203 emxFree_real_T(&b_zWin); 204 emxInit_real_T(&d_st, &x, 2, &k_emlrtRTEI, true); 205 i47 = x->size[0] * x->size[1]; 206 x->size[0] = (int32_T)varargin_1[0]; 207 x->size[1] = (int32_T)varargin_1[1]; 208 emxEnsureCapacity(&d_st, (emxArray__common *)x, i47, (int32_T)sizeof(real_T), 209 &c_emlrtRTEI); 210 if (c_dimagree(x, normmat)) { 211 } else { 212 emlrtErrorWithMessageIdR2012b(&d_st, &u_emlrtRTEI, "MATLAB:dimagree", 0); 213 } 214 215 i47 = zWin->size[0]; 216 b_n = i47 * loop_ub; 217 d_st.site = &hd_emlrtRSI; 218 if ((!(1 > b_n)) && (b_n > 2147483646)) { 219 e_st.site = &kb_emlrtRSI; 220 check_forloop_overflow_error(&e_st); 221 } 222 223 for (k = 0; k + 1 <= b_n; k++) { 224 x->data[k] = normmat->data[k] * normmat->data[k]; 225 } 226 227 st.site = &pe_emlrtRSI; 228 b_st.site = &id_emlrtRSI; 229 if (((x->size[0] == 1) && (x->size[1] == 1)) || (x->size[0] != 1)) { 230 p = true; 231 } else { 232 p = false; 233 } 234 235 if (p) { 236 } else { 237 emlrtErrorWithMessageIdR2012b(&b_st, &w_emlrtRTEI, 238 "Coder:toolbox:autoDimIncompatibility", 0); 239 } 240 241 p = false; 242 b_p = false; 243 k = 0; 244 do { 245 exitg2 = 0; 246 if (k < 2) { 247 if (x->size[k] != 0) { 248 exitg2 = 1; 249 } else { 250 k++; 251 } 252 } else { 253 b_p = true; 254 exitg2 = 1; 255 } 256 } while (exitg2 == 0); 257 258 if (!b_p) { 259 } else { 260 p = true; 261 } 262 263 if (!p) { 264 } else { 265 emlrtErrorWithMessageIdR2012b(&b_st, &v_emlrtRTEI, 266 "Coder:toolbox:UnsupportedSpecialEmpty", 0); 267 } 268 269 c_st.site = &jd_emlrtRSI; 270 normvec_size_idx_1 = x->size[1]; 271 if ((x->size[0] == 0) || (x->size[1] == 0)) { 272 for (i47 = 0; i47 < normvec_size_idx_1; i47++) { 273 normvec_data[i47] = 0.0; 274 } 275 } else { 276 b_n = x->size[0]; 277 d_st.site = &re_emlrtRSI; 278 for (idx = 0; idx + 1 <= x->size[1]; idx++) { 279 xoffset = idx * b_n; 280 s = x->data[xoffset]; 281 d_st.site = &ld_emlrtRSI; 282 if ((!(2 > b_n)) && (b_n > 2147483646)) { 283 e_st.site = &kb_emlrtRSI; 284 check_forloop_overflow_error(&e_st); 285 } 286 287 for (k = 2; k <= b_n; k++) { 288 s += x->data[(xoffset + k) - 1]; 289 } 290 291 normvec_data[idx] = s; 292 } 293 } 294 295 /* Norm of each column */ 296 for (idx = 0; idx < normvec_size_idx_1; idx++) { 297 if (normvec_data[idx] < 1.0E-10) { 298 if (!((idx + 1 >= 1) && (idx + 1 <= normvec_size_idx_1))) { 299 emlrtDynamicBoundsCheckR2012b(idx + 1, 1, normvec_size_idx_1, 300 &s_emlrtBCI, sp); 301 } 302 303 normvec_data[idx] = 1.0E-10; 304 } 305 } 306 307 /* Ensure norm is nonzero */ 308 i47 = normmat->size[0] * normmat->size[1]; 309 normmat->size[0] = (int32_T)order; 310 normmat->size[1] = normvec_size_idx_1; 311 emxEnsureCapacity(sp, (emxArray__common *)normmat, i47, (int32_T)sizeof(real_T), 312 &k_emlrtRTEI); 313 xoffset = (int32_T)order; 314 for (i47 = 0; i47 < xoffset; i47++) { 315 for (k = 0; k < normvec_size_idx_1; k++) { 316 normmat->data[i47 + normmat->size[0] * k] = normvec_data[k]; 317 } 318 } 319 320 tmp_size[0] = 20; 321 tmp_size[1] = ii_size[1]; 322 xoffset = ii_size[1]; 323 for (i47 = 0; i47 < xoffset; i47++) { 324 for (k = 0; k < 20; k++) { 325 tmp_data[k + 20 * i47] = beta * w[k + 20 * (amcInds_data[i47] - 1)]; 326 } 327 } 328 329 s = mu * y[(int32_T)n - 1]; 330 xoffset = zWin->size[0]; 331 i47 = x->size[0] * x->size[1]; 332 x->size[0] = xoffset; 333 x->size[1] = ii_size[1]; 334 emxEnsureCapacity(sp, (emxArray__common *)x, i47, (int32_T)sizeof(real_T), 335 &k_emlrtRTEI); 336 b_n = ii_size[1]; 337 for (i47 = 0; i47 < b_n; i47++) { 338 for (k = 0; k < xoffset; k++) { 339 x->data[k + x->size[0] * i47] = s * zWin->data[k + zWin->size[0] * 340 (amcInds_data[i47] - 1)]; 341 } 342 } 343 344 st.site = &qe_emlrtRSI; 345 for (i47 = 0; i47 < 2; i47++) { 346 varargin_1[i47] = (uint32_T)x->size[i47]; 347 } 348 349 for (i47 = 0; i47 < 2; i47++) { 350 varargin_2[i47] = (uint32_T)normmat->size[i47]; 351 } 352 353 p = false; 354 b_p = true; 355 k = 0; 356 exitg1 = false; 357 while ((!exitg1) && (k < 2)) { 358 if (!((int32_T)varargin_1[k] == (int32_T)varargin_2[k])) { 359 b_p = false; 360 exitg1 = true; 361 } else { 362 k++; 363 } 364 } 365 366 if (!b_p) { 367 } else { 368 p = true; 369 } 370 371 if (p) { 372 } else { 373 emlrtErrorWithMessageIdR2012b(&st, &ab_emlrtRTEI, "MATLAB:dimagree", 0); 374 } 375 376 i47 = x->size[0] * x->size[1]; 377 emxEnsureCapacity(&st, (emxArray__common *)x, i47, (int32_T)sizeof(real_T), 378 &k_emlrtRTEI); 379 b_n = x->size[0]; 380 idx = x->size[1]; 381 xoffset = b_n * idx; 382 for (i47 = 0; i47 < xoffset; i47++) { 383 x->data[i47] /= normmat->data[i47]; 384 } 385 386 emxFree_real_T(&normmat); 387 for (i47 = 0; i47 < 2; i47++) { 388 iv64[i47] = tmp_size[i47]; 389 } 390 391 for (i47 = 0; i47 < 2; i47++) { 392 b_x[i47] = x->size[i47]; 393 } 394 395 if ((iv64[0] != b_x[0]) || (iv64[1] != b_x[1])) { 396 emlrtSizeEqCheckNDR2012b(&iv64[0], &b_x[0], &j_emlrtECI, sp); 397 } 398 399 xoffset = ii_size[1]; 400 for (i47 = 0; i47 < xoffset; i47++) { 401 b_tmp_data[i47] = (int8_T)(amcInds_data[i47] - 1); 402 } 403 404 iv65[0] = 20; 405 iv65[1] = loop_ub; 406 emlrtSubAssignSizeCheckR2012b(iv65, 2, tmp_size, 2, &i_emlrtECI, sp); 407 for (i47 = 0; i47 < loop_ub; i47++) { 408 for (k = 0; k < 20; k++) { 409 w[k + 20 * b_tmp_data[i47]] = tmp_data[k + 20 * i47] + x->data[k + x-> 410 size[0] * i47]; 411 } 412 } 413 414 emxFree_real_T(&x); 415 416 /* Tap update */ 417 covrtLogBasicBlock(&emlrtCoverageInstance, 10U, 2); 418 emlrtHeapReferenceStackLeaveFcnR2012b(sp); 419 } 420 421 /* End of code generation (optwmc.c) */ 422 |