File: AMC.c

    1   /*
    2    * AMC.c
    3    *
    4    * Code generation for function 'AMC'
    5    *
    6    */
    7   
    8   /* Include files */
    9   #include "rt_nonfinite.h"
   10   #include "gjbf.h"
   11   #include "AMC.h"
   12   #include "gjbf_emxutil.h"
   13   #include "log10.h"
   14   #include "sum.h"
   15   #include "power.h"
   16   #include "mod.h"
   17   #include "gjbf_data.h"
   18   #include "blas.h"
   19   
   20   /* Variable Definitions */
   21   static emlrtRSInfo dd_emlrtRSI = { 8, "AMC",
   22     "E:\\micro array project\\Microphone Array\\beamform test\\AMC.m" };
   23   
   24   static emlrtRSInfo ed_emlrtRSI = { 9, "AMC",
   25     "E:\\micro array project\\Microphone Array\\beamform test\\AMC.m" };
   26   
   27   static emlrtRTEInfo g_emlrtRTEI = { 1, 34, "AMC",
   28     "E:\\micro array project\\Microphone Array\\beamform test\\AMC.m" };
   29   
   30   static emlrtDCInfo m_emlrtDCI = { 8, 21, "AMC",
   31     "E:\\micro array project\\Microphone Array\\beamform test\\AMC.m", 1 };
   32   
   33   static emlrtBCInfo j_emlrtBCI = { 1, 882, 8, 21, "b", "AMC",
   34     "E:\\micro array project\\Microphone Array\\beamform test\\AMC.m", 0 };
   35   
   36   static emlrtDCInfo n_emlrtDCI = { 9, 19, "AMC",
   37     "E:\\micro array project\\Microphone Array\\beamform test\\AMC.m", 1 };
   38   
   39   static emlrtBCInfo k_emlrtBCI = { 1, 882, 9, 19, "y", "AMC",
   40     "E:\\micro array project\\Microphone Array\\beamform test\\AMC.m", 0 };
   41   
   42   /* Function Definitions */
   43   void AMC(const emlrtStack *sp, const real_T b[882], const real_T y[14112],
   44            real_T n, real_T snrThresh, real_T snrRate, real_T snr[16], boolean_T
   45            amcInds[16], real_T mcAdapt[14112])
   46   {
   47     int32_T i37;
   48     real_T x;
   49     int32_T i38;
   50     int32_T i39;
   51     int32_T i40;
   52     real_T b_data[882];
   53     int32_T b_size[1];
   54     int32_T loop_ub;
   55     emxArray_real_T *b_y;
   56     real_T tmp_data[882];
   57     int32_T tmp_size[1];
   58     emxArray_real_T *r2;
   59     emlrtStack st;
   60     st.prev = sp;
   61     st.tls = sp->tls;
   62     emlrtHeapReferenceStackEnterFcnR2012b(sp);
   63     covrtLogFcn(&emlrtCoverageInstance, 5U, 0);
   64   
   65     /*  update amcInd at snrRate time */
   66     covrtLogCond(&emlrtCoverageInstance, 5U, 0U, 0, false);
   67     if (covrtLogCond(&emlrtCoverageInstance, 5U, 0U, 1, b_mod(n, snrRate) == 0.0))
   68     {
   69       covrtLogMcdc(&emlrtCoverageInstance, 5U, 0U, 0, true);
   70       covrtLogIf(&emlrtCoverageInstance, 5U, 0U, 0, true);
   71       covrtLogBasicBlock(&emlrtCoverageInstance, 5U, 0);
   72   
   73       /* snr condition to adapt */
   74       x = (n - snrRate) + 1.0;
   75       if (x > n) {
   76         i37 = 0;
   77         i38 = 0;
   78       } else {
   79         if (x != (int32_T)muDoubleScalarFloor(x)) {
   80           emlrtIntegerCheckR2012b(x, &m_emlrtDCI, sp);
   81         }
   82   
   83         i37 = (int32_T)x;
   84         if (!((i37 >= 1) && (i37 <= 882))) {
   85           emlrtDynamicBoundsCheckR2012b(i37, 1, 882, &j_emlrtBCI, sp);
   86         }
   87   
   88         i37--;
   89         i38 = (int32_T)n;
   90       }
   91   
   92       x = (n - snrRate) + 1.0;
   93       if (x > n) {
   94         i39 = 0;
   95         i40 = 0;
   96       } else {
   97         if (x != (int32_T)muDoubleScalarFloor(x)) {
   98           emlrtIntegerCheckR2012b(x, &n_emlrtDCI, sp);
   99         }
  100   
  101         i39 = (int32_T)x;
  102         if (!((i39 >= 1) && (i39 <= 882))) {
  103           emlrtDynamicBoundsCheckR2012b(i39, 1, 882, &k_emlrtBCI, sp);
  104         }
  105   
  106         i39--;
  107         i40 = (int32_T)n;
  108       }
  109   
  110       b_size[0] = i38 - i37;
  111       loop_ub = i38 - i37;
  112       for (i38 = 0; i38 < loop_ub; i38++) {
  113         b_data[i38] = b[i37 + i38];
  114       }
  115   
  116       emxInit_real_T(sp, &b_y, 2, &g_emlrtRTEI, true);
  117       st.site = &dd_emlrtRSI;
  118       b_power(&st, b_data, b_size, tmp_data, tmp_size);
  119       i37 = b_y->size[0] * b_y->size[1];
  120       b_y->size[0] = i40 - i39;
  121       b_y->size[1] = 16;
  122       emxEnsureCapacity(sp, (emxArray__common *)b_y, i37, (int32_T)sizeof(real_T),
  123                         &g_emlrtRTEI);
  124       for (i37 = 0; i37 < 16; i37++) {
  125         loop_ub = i40 - i39;
  126         for (i38 = 0; i38 < loop_ub; i38++) {
  127           b_y->data[i38 + b_y->size[0] * i37] = y[(i39 + i38) + 882 * i37];
  128         }
  129       }
  130   
  131       emxInit_real_T(sp, &r2, 2, &g_emlrtRTEI, true);
  132       st.site = &ed_emlrtRSI;
  133       c_power(&st, b_y, r2);
  134       st.site = &dd_emlrtRSI;
  135       x = c_sum(&st, tmp_data, tmp_size);
  136       st.site = &ed_emlrtRSI;
  137       d_sum(&st, r2, snr);
  138       emxFree_real_T(&b_y);
  139       emxFree_real_T(&r2);
  140       for (i37 = 0; i37 < 16; i37++) {
  141         snr[i37] = x / snr[i37];
  142       }
  143   
  144       st.site = &dd_emlrtRSI;
  145       b_log10(&st, snr);
  146   
  147       /*  find which tracks adapt */
  148       for (i37 = 0; i37 < 16; i37++) {
  149         snr[i37] *= 10.0;
  150         amcInds[i37] = (snr[i37] > snrThresh);
  151       }
  152     } else {
  153       covrtLogMcdc(&emlrtCoverageInstance, 5U, 0U, 0, false);
  154       covrtLogIf(&emlrtCoverageInstance, 5U, 0U, 0, false);
  155     }
  156   
  157     covrtLogBasicBlock(&emlrtCoverageInstance, 5U, 1);
  158     for (i37 = 0; i37 < 16; i37++) {
  159       mcAdapt[((int32_T)n + 882 * i37) - 1] = !amcInds[i37];
  160     }
  161   
  162     emlrtHeapReferenceStackLeaveFcnR2012b(sp);
  163   }
  164   
  165   /* End of code generation (AMC.c) */
  166