File: sum.c

    1   /*
    2    * sum.c
    3    *
    4    * Code generation for function 'sum'
    5    *
    6    */
    7   
    8   /* Include files */
    9   #include "rt_nonfinite.h"
   10   #include "gjbf.h"
   11   #include "sum.h"
   12   #include "gjbf_data.h"
   13   #include "blas.h"
   14   
   15   /* Function Definitions */
   16   void b_sum(const real_T x[14112], real_T y[882])
   17   {
   18     int32_T j;
   19     real_T s;
   20     int32_T k;
   21     for (j = 0; j < 882; j++) {
   22       s = x[j];
   23       for (k = 0; k < 15; k++) {
   24         s += x[j + (k + 1) * 882];
   25       }
   26   
   27       y[j] = s;
   28     }
   29   }
   30   
   31   real_T c_sum(const emlrtStack *sp, const real_T x_data[], const int32_T x_size[1])
   32   {
   33     real_T y;
   34     boolean_T p;
   35     boolean_T b_p;
   36     int32_T k;
   37     int32_T exitg1;
   38     int32_T b_k;
   39     emlrtStack st;
   40     st.prev = sp;
   41     st.tls = sp->tls;
   42     st.site = &id_emlrtRSI;
   43     if ((x_size[0] == 1) || (x_size[0] != 1)) {
   44       p = true;
   45     } else {
   46       p = false;
   47     }
   48   
   49     if (p) {
   50     } else {
   51       emlrtErrorWithMessageIdR2012b(&st, &w_emlrtRTEI,
   52         "Coder:toolbox:autoDimIncompatibility", 0);
   53     }
   54   
   55     p = false;
   56     b_p = false;
   57     k = 0;
   58     do {
   59       exitg1 = 0;
   60       if (k < 2) {
   61         if (k + 1 <= 1) {
   62           b_k = x_size[0];
   63         } else {
   64           b_k = 1;
   65         }
   66   
   67         if (b_k != 0) {
   68           exitg1 = 1;
   69         } else {
   70           k++;
   71         }
   72       } else {
   73         b_p = true;
   74         exitg1 = 1;
   75       }
   76     } while (exitg1 == 0);
   77   
   78     if (!b_p) {
   79     } else {
   80       p = true;
   81     }
   82   
   83     if (!p) {
   84     } else {
   85       emlrtErrorWithMessageIdR2012b(&st, &v_emlrtRTEI,
   86         "Coder:toolbox:UnsupportedSpecialEmpty", 0);
   87     }
   88   
   89     if (x_size[0] == 0) {
   90       y = 0.0;
   91     } else {
   92       y = x_data[0];
   93       for (k = 2; k <= x_size[0]; k++) {
   94         y += x_data[k - 1];
   95       }
   96     }
   97   
   98     return y;
   99   }
  100   
  101   void d_sum(const emlrtStack *sp, const emxArray_real_T *x, real_T y[16])
  102   {
  103     boolean_T p;
  104     boolean_T b_p;
  105     int32_T k;
  106     int32_T exitg1;
  107     int32_T vlen;
  108     int32_T i;
  109     int32_T xoffset;
  110     real_T s;
  111     emlrtStack st;
  112     st.prev = sp;
  113     st.tls = sp->tls;
  114     st.site = &id_emlrtRSI;
  115     p = (x->size[0] != 1);
  116     if (p) {
  117     } else {
  118       emlrtErrorWithMessageIdR2012b(&st, &w_emlrtRTEI,
  119         "Coder:toolbox:autoDimIncompatibility", 0);
  120     }
  121   
  122     p = false;
  123     b_p = false;
  124     k = 0;
  125     do {
  126       exitg1 = 0;
  127       if (k < 2) {
  128         if (x->size[k] != 0) {
  129           exitg1 = 1;
  130         } else {
  131           k++;
  132         }
  133       } else {
  134         b_p = true;
  135         exitg1 = 1;
  136       }
  137     } while (exitg1 == 0);
  138   
  139     if (!b_p) {
  140     } else {
  141       p = true;
  142     }
  143   
  144     if (!p) {
  145     } else {
  146       emlrtErrorWithMessageIdR2012b(&st, &v_emlrtRTEI,
  147         "Coder:toolbox:UnsupportedSpecialEmpty", 0);
  148     }
  149   
  150     if (x->size[0] == 0) {
  151       memset(&y[0], 0, sizeof(real_T) << 4);
  152     } else {
  153       vlen = x->size[0];
  154       for (i = 0; i < 16; i++) {
  155         xoffset = i * vlen;
  156         s = x->data[xoffset];
  157         for (k = 2; k <= vlen; k++) {
  158           s += x->data[(xoffset + k) - 1];
  159         }
  160   
  161         y[i] = s;
  162       }
  163     }
  164   }
  165   
  166   void sum(const real_T x[48], real_T y[16])
  167   {
  168     int32_T i;
  169     int32_T xoffset;
  170     real_T s;
  171     int32_T k;
  172     for (i = 0; i < 16; i++) {
  173       xoffset = i * 3;
  174       s = x[xoffset];
  175       for (k = 0; k < 2; k++) {
  176         s += x[(xoffset + k) + 1];
  177       }
  178   
  179       y[i] = s;
  180     }
  181   }
  182   
  183   /* End of code generation (sum.c) */
  184