Exemplo n.º 1
0
//
// Arguments    : const double A[476]
//                double U[476]
//                double S[289]
//                double V[289]
// Return Type  : void
//
void svd(const double A[476], double U[476], double S[289], double V[289])
{
  double s[17];
  int k;
  eml_xgesvd(A, U, s, V);
  memset(&S[0], 0, 289U * sizeof(double));
  for (k = 0; k < 17; k++) {
    S[k + 17 * k] = s[k];
  }
}
Exemplo n.º 2
0
real_T cond(const emxArray_real_T *A)
{
  real_T c;
  int32_T U_size[1];
  real_T U_data[10];
  if (A->size[0] == 0) {
    c = 0.0;
  } else {
    eml_xgesvd(A, U_data, U_size);
    if (U_data[U_size[0] - 1] == 0.0) {
      c = rtInf;
    } else {
      c = U_data[0] / U_data[U_size[0] - 1];
    }
  }

  return c;
}
Exemplo n.º 3
0
/*
 * Arguments    : const double x[900]
 * Return Type  : double
 */
double d_norm(const double x[900])
{
  double U[30];
  eml_xgesvd(x, U);
  return U[0];
}
Exemplo n.º 4
0
/////////////////////////////////////////////////////////
// main testing function 
/////////////////////////////////////////////////////////
int main(int argc, const char * const argv[])
{
  (void)argc;
  (void)argv;

  int coreid, k;
  boolean_T pass;

  float V[25];
  float s[5];
  float U[25];
  
  int b_k;
  float y[25];
  float b_y;
  float c_y;
  float d_y;
  float tmp[3];
  
  init_fp_regs();

  /////////////////////////////////////////////////////////
  // main test loop 
  // each core loops over a kernel instance
  /////////////////////////////////////////////////////////
  
  coreid = get_core_id();

  printf("starting %d kernel iterations... (coreid = %d)\n",KERNEL_ITS,coreid);
  
  if (coreid>3)
    coreid=coreid-4;

  synch_barrier();
  
  perf_begin();

  for(k = 0; k < getKernelIts(); k++)
  {

    // call matlab kernel
    eml_xgesvd(*(float (*)[25])&fv0[25 * coreid], U, s, V);
    
  }

  synch_barrier();

  perf_end();

  /////////////////////////////////////////////////////////
  // check results
  /////////////////////////////////////////////////////////
  
  synch_barrier();

  for (b_k = 0; b_k < 25; b_k++) {
    y[b_k] = fAbs(U[b_k]);
  }

  b_y = y[0];
  c_y = s[0];
  
  for (b_k = 0; b_k < 4; b_k++) {
    c_y += s[b_k + 1];
  }

  for (b_k = 0; b_k < 24; b_k++) {
    b_y += y[b_k + 1];
  }

  for (b_k = 0; b_k < 25; b_k++) {
    y[b_k] = fAbs(V[b_k]);
  }

  d_y = y[0];
  for (b_k = 0; b_k < 24; b_k++) {
    d_y += y[b_k + 1];
  }

  tmp[0] = b_y;
  tmp[1] = c_y;
  tmp[2] = d_y;
  
  pass = true;
  for (b_k = 0; b_k < 3; b_k++) {
    pass = pass && (tmp[b_k] <= fv1[(0 + (b_k << 1)) + 6 * coreid]);
    pass = pass && (tmp[b_k] >= fv1[(1 + (b_k << 1)) + 6 * coreid]);
  }

  flagPassFail(pass, get_core_id());
  
  synch_barrier();

/////////////////////////////////////////////////////////
// synchronize and exit
/////////////////////////////////////////////////////////

  return !pass;
}
Exemplo n.º 5
0
void pinv(const real32_T A[9], real32_T X[9])
{
  int32_T k;
  real32_T V[9];
  real32_T s[3];
  real32_T U[9];
  real32_T S[9];
  int32_T r;
  int32_T vcol;
  int32_T br;
  real32_T z;
  int32_T ic;
  int32_T ar;
  int32_T ib;
  int32_T ia;
  for (k = 0; k < 9; k++) {
    X[k] = 0.0F;
  }

  eml_xgesvd(A, U, s, V);
  for (k = 0; k < 9; k++) {
    S[k] = 0.0F;
  }

  for (k = 0; k < 3; k++) {
    S[k + 3 * k] = s[k];
  }

  r = 0;
  k = 0;
  while ((k + 1 < 4) && (S[k + 3 * k] > 3.0F * S[0] * 1.1920929E-7F)) {
    r++;
    k++;
  }

  if (r > 0) {
    vcol = 0;
    for (br = 0; br + 1 <= r; br++) {
      z = 1.0F / S[br + 3 * br];
      for (k = vcol; k + 1 <= vcol + 3; k++) {
        V[k] *= z;
      }

      vcol += 3;
    }

    for (vcol = 0; vcol < 8; vcol += 3) {
      for (ic = vcol; ic + 1 <= vcol + 3; ic++) {
        X[ic] = 0.0F;
      }
    }

    br = -1;
    for (vcol = 0; vcol < 8; vcol += 3) {
      ar = 0;
      br++;
      k = (br + 3 * (r - 1)) + 1;
      for (ib = br; ib + 1 <= k; ib += 3) {
        if (U[ib] != 0.0F) {
          ia = ar;
          for (ic = vcol; ic + 1 <= vcol + 3; ic++) {
            ia++;
            X[ic] += U[ib] * V[ia - 1];
          }
        }

        ar += 3;
      }
    }
  }
}