resampling.cpp

Go to the documentation of this file.

/*
 * resampling.cpp
 *
 * Code generation for function 'resampling'
 *
 * C source code generated on: Wed Jul 24 16:11:35 2013
 *
 */

/* Include files */
#include "rt_nonfinite.h"
#include "Optimal_affine_tracking_3d16_fast_realtime.h"
#include "resampling.h"
#include "meshgrid.h"
#include "cumulative_sum.h"
#include "rand.h"

/* Type Definitions */

/* Named Constants */

/* Variable Declarations */

/* Variable Definitions */

/* Function Declarations */

/* Function Definitions */
void resampling(const real_T w[25], real_T outindex[25])
{
  real_T ndbl;
  real_T y;
  int32_T xtmp;
  real_T apnd;
  real_T absa;
  real_T U_data[26];
  int32_T nm1d2;
  int32_T k;
  real_T dv10[25];
  real_T cum[26];
  real_T dv11[25];
  real_T dv12[25];
  int32_T i;
  real_T jj[625];
  real_T ii[625];
  int32_T i19;
  boolean_T cond[625];
  int32_T ind;
  int32_T idx;
  int16_T ii_data[1];
  boolean_T exitg1;
  int16_T tmp_data[625];
  int32_T tmp_size_idx_0;
  int32_T loop_ub;
  int32_T i20;
  int16_T b_tmp_data[625];
  int16_T b_ii_data[1];
  int16_T j_data[1];
  ndbl = c_rand();
  y = ndbl / 25.0;
  if (rtIsNaN(y)) {
    xtmp = 1;
    y = rtNaN;
    apnd = 1.0;
  } else if (rtIsInf(y)) {
    xtmp = 1;
    y = rtNaN;
    apnd = 1.0;
  } else {
    ndbl = floor((1.0 - y) / 0.04 + 0.5);
    apnd = y + ndbl * 0.04;
    absa = fabs(y);
    if (absa > 1.0) {
    } else {
      absa = 1.0;
    }

    if (fabs(apnd - 1.0) < 4.4408920985006262E-16 * absa) {
      ndbl++;
      apnd = 1.0;
    } else if (apnd - 1.0 > 0.0) {
      apnd = y + (ndbl - 1.0) * 0.04;
    } else {
      ndbl++;
    }

    xtmp = (int32_T)ndbl;
  }

  U_data[0] = y;
  if (xtmp > 1) {
    U_data[xtmp - 1] = apnd;
    nm1d2 = (xtmp - 1) / 2;
    for (k = 1; k <= nm1d2 - 1; k++) {
      ndbl = (real_T)k * 0.04;
      U_data[k] = y + ndbl;
      U_data[(xtmp - k) - 1] = apnd - ndbl;
    }

    if (nm1d2 << 1 == xtmp - 1) {
      U_data[nm1d2] = (y + apnd) / 2.0;
    } else {
      ndbl = (real_T)nm1d2 * 0.04;
      U_data[nm1d2] = y + ndbl;
      U_data[nm1d2 + 1] = apnd - ndbl;
    }
  }

  cumulative_sum(w, dv10);
  cum[0] = 0.0;
  for (i = 0; i < 25; i++) {
    cum[i + 1] = dv10[i];
    outindex[i] = 0.0;
    dv11[i] = 1.0 + (real_T)i;
    dv12[i] = 2.0 + (real_T)i;
  }

  meshgrid(dv11, dv12, ii, jj);
  for (i19 = 0; i19 < 625; i19++) {
    cond[i19] = ((U_data[(int32_T)ii[i19] - 1] > cum[(int32_T)(jj[i19] - 1.0) -
                  1]) && (U_data[(int32_T)ii[i19] - 1] <= cum[(int32_T)jj[i19] -
                          1]));
  }

  i = 0;
  for (ind = 0; ind < 25; ind++) {
    nm1d2 = 1 + ind * 25;
    if (nm1d2 > nm1d2 + 24) {
      nm1d2 = 1;
      i19 = 0;
    } else {
      i19 = nm1d2 + 24;
    }

    xtmp = (i19 - nm1d2) + 1;
    if (1 <= xtmp) {
      k = 1;
    } else {
      k = xtmp;
    }

    idx = 0;
    exitg1 = FALSE;
    while ((exitg1 == 0U) && (xtmp > 0)) {
      tmp_size_idx_0 = (i19 - nm1d2) + 1;
      loop_ub = i19 - nm1d2;
      for (i20 = 0; i20 <= loop_ub; i20++) {
        tmp_data[i20] = (int16_T)(nm1d2 + i20);
      }

      loop_ub = tmp_size_idx_0 - 1;
      for (i20 = 0; i20 <= loop_ub; i20++) {
        b_tmp_data[i20] = tmp_data[i20];
      }

      if (cond[b_tmp_data[xtmp - 1] - 1]) {
        idx = 1;
        ii_data[0] = (int16_T)xtmp;
        exitg1 = TRUE;
      } else {
        xtmp--;
      }
    }

    if (k == 1) {
      if (idx == 0) {
        k = 0;
      }
    } else {
      if (1 > idx) {
        i19 = -1;
      } else {
        i19 = 0;
      }

      loop_ub = i19;
      i20 = 0;
      while (i20 <= loop_ub) {
        i20 = 0;
        while (i20 <= 0) {
          b_ii_data[0] = ii_data[0];
          i20 = 1;
        }

        i20 = 1;
      }

      k = i19 + 1;
      loop_ub = i19;
      i20 = 0;
      while (i20 <= loop_ub) {
        ii_data[0] = b_ii_data[0];
        i20 = 1;
      }

      nm1d2 = (i19 + 1) / 2;
      xtmp = 1;
      while (xtmp <= nm1d2) {
        xtmp = ii_data[0];
        ii_data[0] = ii_data[i19];
        ii_data[i19] = (int16_T)xtmp;
        xtmp = 2;
      }
    }

    loop_ub = k - 1;
    i19 = 0;
    while (i19 <= loop_ub) {
      j_data[0] = ii_data[0];
      i19 = 1;
    }

    outindex[i] = (real_T)j_data[0];
    i++;
  }
}

/* End of code generation (resampling.cpp) */