File: optwbm.c

    1   /*
    2    * optwbm.c
    3    *
    4    * Code generation for function 'optwbm'
    5    *
    6    */
    7   
    8   /* Include files */
    9   #include "rt_nonfinite.h"
   10   #include "gjbf.h"
   11   #include "optwbm.h"
   12   #include "diag.h"
   13   #include "norm.h"
   14   #include "mpower.h"
   15   #include "gjbf_emxutil.h"
   16   #include "gjbf_data.h"
   17   #include "blas.h"
   18   
   19   /* Variable Definitions */
   20   static emlrtRSInfo nd_emlrtRSI = { 11, "optwbm",
   21     "E:\\micro array project\\Microphone Array\\beamform test\\optwbm.m" };
   22   
   23   static emlrtRSInfo od_emlrtRSI = { 10, "optwbm",
   24     "E:\\micro array project\\Microphone Array\\beamform test\\optwbm.m" };
   25   
   26   static emlrtRSInfo pd_emlrtRSI = { 12, "optwbm",
   27     "E:\\micro array project\\Microphone Array\\beamform test\\optwbm.m" };
   28   
   29   static emlrtRTEInfo h_emlrtRTEI = { 1, 15, "optwbm",
   30     "E:\\micro array project\\Microphone Array\\beamform test\\optwbm.m" };
   31   
   32   static emlrtECInfo e_emlrtECI = { -1, 10, 5, "optwbm",
   33     "E:\\micro array project\\Microphone Array\\beamform test\\optwbm.m" };
   34   
   35   static emlrtECInfo f_emlrtECI = { 2, 10, 20, "optwbm",
   36     "E:\\micro array project\\Microphone Array\\beamform test\\optwbm.m" };
   37   
   38   /* Function Definitions */
   39   void optwbm(const emlrtStack *sp, const real_T bWin_data[], const int32_T
   40               bWin_size[1], real_T n, real_T w[320], const real_T z[14112], real_T
   41               beta, real_T mu, const boolean_T amcInds[16])
   42   {
   43     int32_T idx;
   44     int32_T ii;
   45     boolean_T exitg1;
   46     boolean_T guard1 = false;
   47     int32_T loop_ub;
   48     int32_T ii_size_idx_1;
   49     int8_T tmp_data[16];
   50     int32_T trueCount;
   51     int32_T tmp_size[2];
   52     int32_T i41;
   53     int32_T i42;
   54     int32_T b_trueCount;
   55     real_T b_tmp_data[320];
   56     real_T z_data[16];
   57     int32_T z_size[2];
   58     emxArray_real_T *y;
   59     real_T b_data[256];
   60     int32_T b_size[2];
   61     real_T b_y;
   62     emxArray_real_T *a;
   63     emxArray_real_T *c_y;
   64     int16_T unnamed_idx_0;
   65     real_T alpha1;
   66     real_T beta1;
   67     char_T TRANSB;
   68     char_T TRANSA;
   69     ptrdiff_t m_t;
   70     ptrdiff_t n_t;
   71     ptrdiff_t k_t;
   72     ptrdiff_t lda_t;
   73     ptrdiff_t ldb_t;
   74     int32_T iv58[2];
   75     ptrdiff_t ldc_t;
   76     int32_T d_y[2];
   77     int32_T iv59[2];
   78     emlrtStack st;
   79     emlrtStack b_st;
   80     st.prev = sp;
   81     st.tls = sp->tls;
   82     b_st.prev = &st;
   83     b_st.tls = st.tls;
   84     emlrtHeapReferenceStackEnterFcnR2012b(sp);
   85     covrtLogFcn(&emlrtCoverageInstance, 6U, 0);
   86   
   87     /*  adapt everyone under no threshold */
   88     covrtLogIf(&emlrtCoverageInstance, 6U, 0U, 0, false);
   89     covrtLogBasicBlock(&emlrtCoverageInstance, 6U, 1);
   90     idx = 0;
   91     ii = 1;
   92     exitg1 = false;
   93     while ((!exitg1) && (ii < 17)) {
   94       guard1 = false;
   95       if (amcInds[ii - 1]) {
   96         idx++;
   97         if (idx >= 16) {
   98           exitg1 = true;
   99         } else {
  100           guard1 = true;
  101         }
  102       } else {
  103         guard1 = true;
  104       }
  105   
  106       if (guard1) {
  107         ii++;
  108       }
  109     }
  110   
  111     if (1 > idx) {
  112       loop_ub = 0;
  113     } else {
  114       loop_ub = idx;
  115     }
  116   
  117     if (1 > idx) {
  118       ii_size_idx_1 = 0;
  119     } else {
  120       ii_size_idx_1 = idx;
  121     }
  122   
  123     trueCount = 0;
  124     for (ii = 0; ii < 16; ii++) {
  125       if (amcInds[ii]) {
  126         trueCount++;
  127       }
  128     }
  129   
  130     idx = 0;
  131     for (ii = 0; ii < 16; ii++) {
  132       if (amcInds[ii]) {
  133         tmp_data[idx] = (int8_T)(ii + 1);
  134         idx++;
  135       }
  136     }
  137   
  138     tmp_size[0] = 20;
  139     tmp_size[1] = trueCount;
  140     for (i41 = 0; i41 < trueCount; i41++) {
  141       for (i42 = 0; i42 < 20; i42++) {
  142         b_tmp_data[i42 + 20 * i41] = beta * w[i42 + 20 * (tmp_data[i41] - 1)];
  143       }
  144     }
  145   
  146     b_trueCount = 0;
  147     for (ii = 0; ii < 16; ii++) {
  148       if (amcInds[ii]) {
  149         b_trueCount++;
  150       }
  151     }
  152   
  153     idx = 0;
  154     for (ii = 0; ii < 16; ii++) {
  155       if (amcInds[ii]) {
  156         tmp_data[idx] = (int8_T)(ii + 1);
  157         idx++;
  158       }
  159     }
  160   
  161     z_size[0] = 1;
  162     z_size[1] = b_trueCount;
  163     for (i41 = 0; i41 < b_trueCount; i41++) {
  164       z_data[i41] = z[((int32_T)n + 882 * (tmp_data[i41] - 1)) - 1];
  165     }
  166   
  167     emxInit_real_T(sp, &y, 2, &h_emlrtRTEI, true);
  168     st.site = &nd_emlrtRSI;
  169     diag(z_data, z_size, b_data, b_size);
  170     st.site = &pd_emlrtRSI;
  171     b_y = norm(bWin_data, bWin_size);
  172     i41 = y->size[0] * y->size[1];
  173     y->size[0] = bWin_size[0];
  174     y->size[1] = loop_ub;
  175     emxEnsureCapacity(sp, (emxArray__common *)y, i41, (int32_T)sizeof(real_T),
  176                       &h_emlrtRTEI);
  177     b_trueCount = bWin_size[0];
  178     for (i41 = 0; i41 < b_trueCount; i41++) {
  179       for (i42 = 0; i42 < ii_size_idx_1; i42++) {
  180         y->data[i41 + y->size[0] * i42] = mu * bWin_data[i41];
  181       }
  182     }
  183   
  184     emxInit_real_T(sp, &a, 2, &h_emlrtRTEI, true);
  185     st.site = &od_emlrtRSI;
  186     i41 = a->size[0] * a->size[1];
  187     a->size[0] = bWin_size[0];
  188     a->size[1] = loop_ub;
  189     emxEnsureCapacity(&st, (emxArray__common *)a, i41, (int32_T)sizeof(real_T),
  190                       &h_emlrtRTEI);
  191     b_trueCount = bWin_size[0];
  192     for (i41 = 0; i41 < b_trueCount; i41++) {
  193       for (i42 = 0; i42 < loop_ub; i42++) {
  194         a->data[i41 + a->size[0] * i42] = mu * bWin_data[i41];
  195       }
  196     }
  197   
  198     b_st.site = &bd_emlrtRSI;
  199     if (!(a->size[1] == b_size[0])) {
  200       if (((a->size[0] == 1) && (a->size[1] == 1)) || ((b_size[0] == 1) &&
  201            (b_size[1] == 1))) {
  202         emlrtErrorWithMessageIdR2012b(&b_st, &x_emlrtRTEI,
  203           "Coder:toolbox:mtimes_noDynamicScalarExpansion", 0);
  204       } else {
  205         emlrtErrorWithMessageIdR2012b(&b_st, &y_emlrtRTEI, "Coder:MATLAB:innerdim",
  206           0);
  207       }
  208     }
  209   
  210     emxInit_real_T(&st, &c_y, 2, &h_emlrtRTEI, true);
  211     if ((y->size[1] == 1) || (b_size[0] == 1)) {
  212       i41 = c_y->size[0] * c_y->size[1];
  213       c_y->size[0] = y->size[0];
  214       c_y->size[1] = b_size[1];
  215       emxEnsureCapacity(&st, (emxArray__common *)c_y, i41, (int32_T)sizeof(real_T),
  216                         &h_emlrtRTEI);
  217       loop_ub = y->size[0];
  218       for (i41 = 0; i41 < loop_ub; i41++) {
  219         b_trueCount = b_size[1];
  220         for (i42 = 0; i42 < b_trueCount; i42++) {
  221           c_y->data[i41 + c_y->size[0] * i42] = 0.0;
  222           ii = y->size[1];
  223           for (idx = 0; idx < ii; idx++) {
  224             c_y->data[i41 + c_y->size[0] * i42] += y->data[i41 + y->size[0] * idx]
  225               * b_data[idx + b_size[0] * i42];
  226           }
  227         }
  228       }
  229     } else {
  230       unnamed_idx_0 = (int16_T)y->size[0];
  231       i41 = c_y->size[0] * c_y->size[1];
  232       c_y->size[0] = unnamed_idx_0;
  233       c_y->size[1] = (int16_T)b_size[1];
  234       emxEnsureCapacity(&st, (emxArray__common *)c_y, i41, (int32_T)sizeof(real_T),
  235                         &h_emlrtRTEI);
  236       loop_ub = c_y->size[1];
  237       for (i41 = 0; i41 < loop_ub; i41++) {
  238         b_trueCount = c_y->size[0];
  239         for (i42 = 0; i42 < b_trueCount; i42++) {
  240           c_y->data[i42 + c_y->size[0] * i41] = 0.0;
  241         }
  242       }
  243   
  244       b_st.site = &ad_emlrtRSI;
  245       if ((a->size[0] < 1) || (b_size[1] < 1) || (a->size[1] < 1)) {
  246       } else {
  247         alpha1 = 1.0;
  248         beta1 = 0.0;
  249         TRANSB = 'N';
  250         TRANSA = 'N';
  251         m_t = (ptrdiff_t)a->size[0];
  252         n_t = (ptrdiff_t)b_size[1];
  253         k_t = (ptrdiff_t)a->size[1];
  254         lda_t = (ptrdiff_t)a->size[0];
  255         ldb_t = (ptrdiff_t)a->size[1];
  256         ldc_t = (ptrdiff_t)a->size[0];
  257         dgemm(&TRANSA, &TRANSB, &m_t, &n_t, &k_t, &alpha1, &a->data[0], &lda_t,
  258               &b_data[0], &ldb_t, &beta1, &c_y->data[0], &ldc_t);
  259       }
  260     }
  261   
  262     emxFree_real_T(&a);
  263     emxFree_real_T(&y);
  264     st.site = &pd_emlrtRSI;
  265     b_y = mpower(b_y);
  266     i41 = c_y->size[0] * c_y->size[1];
  267     emxEnsureCapacity(sp, (emxArray__common *)c_y, i41, (int32_T)sizeof(real_T),
  268                       &h_emlrtRTEI);
  269     ii = c_y->size[0];
  270     idx = c_y->size[1];
  271     loop_ub = ii * idx;
  272     for (i41 = 0; i41 < loop_ub; i41++) {
  273       c_y->data[i41] /= b_y;
  274     }
  275   
  276     for (i41 = 0; i41 < 2; i41++) {
  277       iv58[i41] = tmp_size[i41];
  278     }
  279   
  280     for (i41 = 0; i41 < 2; i41++) {
  281       d_y[i41] = c_y->size[i41];
  282     }
  283   
  284     if ((iv58[0] != d_y[0]) || (iv58[1] != d_y[1])) {
  285       emlrtSizeEqCheckNDR2012b(&iv58[0], &d_y[0], &f_emlrtECI, sp);
  286     }
  287   
  288     b_trueCount = 0;
  289     for (ii = 0; ii < 16; ii++) {
  290       if (amcInds[ii]) {
  291         b_trueCount++;
  292       }
  293     }
  294   
  295     iv59[0] = 20;
  296     iv59[1] = b_trueCount;
  297     emlrtSubAssignSizeCheckR2012b(iv59, 2, tmp_size, 2, &e_emlrtECI, sp);
  298     idx = 0;
  299     for (ii = 0; ii < 16; ii++) {
  300       if (amcInds[ii]) {
  301         tmp_data[idx] = (int8_T)(ii + 1);
  302         idx++;
  303       }
  304     }
  305   
  306     for (i41 = 0; i41 < trueCount; i41++) {
  307       for (i42 = 0; i42 < 20; i42++) {
  308         w[i42 + 20 * (tmp_data[i41] - 1)] = b_tmp_data[i42 + 20 * i41] + c_y->
  309           data[i42 + c_y->size[0] * i41];
  310       }
  311     }
  312   
  313     emxFree_real_T(&c_y);
  314     covrtLogBasicBlock(&emlrtCoverageInstance, 6U, 2);
  315     emlrtHeapReferenceStackLeaveFcnR2012b(sp);
  316   }
  317   
  318   /* End of code generation (optwbm.c) */
  319