File: bmlms.c

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