C++ (Cpp) rt_ComplexRDivide_Dbl Exemples

Exemple #1

Fichier : rt_forwardsubcr_dbl.c Projet : Tri-o-copter/Brainware

void rt_ForwardSubstitutionCR_Dbl(creal_T       *pL,
                                  const real_T  *pb,
                                  creal_T       *x,
                                  int_T          N,
                                  int_T          P,
                                  const int32_T *piv,
                                  boolean_T      unit_lower)
{
  int_T i, k;
  for(k=0; k<P; k++) {
    creal_T *pLcol = pL;
    for(i=0; i<N; i++) {
      creal_T *xj = x + k*N;
      creal_T s = {0.0, 0.0};
      creal_T *pLrow = pLcol++;
      real_T cb;

      {
        int_T j = i;
        while(j-- > 0) {
          /* Compute: s += L * xj, in complex */
          creal_T cL = *pLrow;
          creal_T c;
          rt_ComplexTimes_Dbl(&c, cL, *xj);

          s.re += c.re;
          s.im += c.im;
          xj++;
          pLrow += N;
        }
      }

      cb = pb[piv[i]];
      if (unit_lower) {
        xj->re = cb - s.re;
        xj->im = -s.im;
      } else {
        /* Complex divide: *xj = cdiff / *cL */
        creal_T cL = *pLrow;
        creal_T cdiff;
        cdiff.re = cb - s.re;
        cdiff.im = -s.im;

        rt_ComplexRDivide_Dbl(xj, cdiff, cL);
      }
    }
    pb += N;
  }
}

Exemple #2

Fichier : rt_backsubrc_dbl.c Projet : Tri-o-copter/Brainware

void rt_BackwardSubstitutionRC_Dbl(real_T          *pU,
                                   const creal_T   *pb,
                                   creal_T         *x,
                                   int_T            N,
                                   int_T            P,
                                   boolean_T        unit_upper)
{
  int_T i,k;
  for(k=P; k>0; k--) {
    real_T *pUcol = pU;
    for(i=0; i<N; i++) {
      creal_T *xj = x + k*N-1;
      creal_T s = {0.0, 0.0};
      real_T *pUrow = pUcol--;          /* access current row of U */
      creal_T cb;

      {
        int_T j = i;
        while(j-- > 0) {
          creal_T c;
          creal_T cUp;
          cUp.re = *pUrow;
          cUp.im = 0.0;
          rt_ComplexTimes_Dbl(&c, cUp, *xj);

          s.re += c.re;
          s.im += c.im;
          xj--;
          pUrow -= N;
        }
      }

      cb = (*pb--);
      if (unit_upper) {
        xj->re = cb.re - s.re;
        xj->im = cb.im - s.im;
      } else {
        creal_T cU;
        creal_T cdiff;
        cU.re = *pUrow;
        cU.im = 0.0;
        cdiff.re = cb.re - s.re;
        cdiff.im = cb.im - s.im;

        rt_ComplexRDivide_Dbl(xj, cdiff, cU);
      }
    }
  }
}

Exemple #3

Fichier : rt_matrixlib_dbl.c Projet : ssernap/Tesis_Organizado

im ) / d ; } } } void rt_ComplexReciprocal_Dbl ( creal_T * Out , const
creal_T In1 ) { creal_T y ; y . re = 1.0 ; y . im = 0.0 ;
rt_ComplexRDivide_Dbl ( Out , y , In1 ) ; }