File: optwmc.c

    1   /*
    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