Search  

---

C:/temp/src/j2k/Beta/Math/Complex/CplxMult.cpp

Go to the documentation of this file.

#ifndef __J2K__JComplex_Multiplication_Division_CPP__
#define __J2K__JComplex_Multiplication_Division_CPP__

/////// TO BE FINISH !

/////////////////////////////////////////////////////////////////////////////
/// Scaling operations                                                    ///
/////////////////////////////////////////////////////////////////////////////
inline JComplex& JComplex::operator*=( const CplxDouble r ) {
  Real = Real * r;
  Imag = Imag * r;
  return (*this);
}

inline JComplex& JComplex::operator/=( const CplxDouble r ) {
  Real = Real / r;
  Imag = Imag / r;
  return (*this);
}

/////////////////////////////////////////////////////////////////////////////
/// Multiplication and Division operations                                ///
/////////////////////////////////////////////////////////////////////////////
JComplex JComplex::Multiply( JComplex& x, const JComplex& y ) {
   // Reminder: (a+bj)(c+dj) = (ac + bcj + adj + bdjj)
   // Result:   (ac - bd) + ( bc + ad )j
   // jj = -1, by definition.

   CplxDouble Temp_Re = (x.Real * y.Real) - (x.Imag * y.Imag);
   CplxDouble Temp_Im = (x.Imag * y.Real) + (x.Real * y.Imag);

   return JComplex( Temp_Re, Temp_Im );
}

JComplex JComplex::Divide( JComplex& x, const JComplex& y ) {
   // Reminder: (a+bj)/(c+dj) = (a+bj)(c-dj) / [ (c+dj)(c-dj) ]
   // = (ac + bcj - adj - bdjj) / (cc - ddjj)
   // = [ (ac + bd) + ( bc - ad )j ] / [ cc + dd ]
   // jj = -1, by definition.

   // Doesn't handle Divide by Zero, but STL does it.

   CplxDouble Temp_delta = (y.Real * y.Real) + (y.Imag * y.Imag);
   CplxDouble Temp_Re    = (x.Real * y.Real) + (x.Imag * y.Imag);
   CplxDouble Temp_Im    = (x.Imag * y.Real) - (x.Real * y.Imag);

   return JComplex( Temp_Re / Temp_delta, Temp_Im / Temp_delta );
}

inline void JComplex::operator*=( const JComplex& c ) {
  this = Multiply( this, c );
}

inline void JComplex::operator/=( const JComplex& c ) {
  this = Divide( this, c );
}

inline JComplex JComplex::operator*( const JComplex& l, const JComplex& r) {
  return Multiply( l, r );
}

inline JComplex JComplex::operator/( const JComplex& l, const JComplex& r) {
  return Divide( l, r );
}

/* STL content
// It use Complex double as temp to verify for NaN, Inf
// Might use Double for that.
{
   if ( _Isnan( Temp_re ) || _Isnan( Temp_im ) ) {
     x.Real( _Nanv( Temp_re )), x.Imag( x.Real );
   } else if (
   (Temp_im < 0 ? -Temp_im : +Temp_im) < (Temp_re < 0 ? -Temp_re : +Temp_re)
   ) {
     CplxDouble _Wr = Temp_im / Temp_re;
     CplxDouble _Wd = Temp_re + _Wr * Temp_im;

     if (_Isnan(_Wd) || _Wd == 0) {
       x.Real(_Nanv(Temp_re)), x.Imag(x.Real());
     } else {
       CplxDouble temp = (x.Real() + x.Imag() * _Wr) / _Wd;
       x.Imag((x.Imag() - x.Real() * _Wr) / _Wd);
       x.Real(temp);
     }

   } else if (Temp_im == 0) {
      x.Real(_Nanv(Temp_re)), x.Imag(x.Real());
   } else {
      CplxDouble _Wr = Temp_re / Temp_im;
      CplxDouble _Wd = Temp_im + _Wr * Temp_re;

      if (_Isnan(_Wd) || _Wd == 0) {
         x.Real(_Nanv(Temp_re)), x.Imag(x.Real());
      } else {
         CplxDouble temp = (x.Real() * _Wr + x.Imag()) / _Wd;
         x.Imag((x.Imag() * _Wr - x.Real()) / _Wd);
         x.Real(temp);
      }
   }
   return (x);
}
*/

/*

// TEMPLATE FUNCTION operator>>
template<class Exponent, class _Tr, class _U> inline
   basic_istream<Exponent, _Tr>&  operator>>(
      basic_istream<Exponent, _Tr>& Im, JComplex& x)
{
   Exponent _Ch;
   long double Real, Imag;
   if (Im >> _Ch && _Ch != '(')
      Im.putback(_Ch), Im >> Real, Imag = 0;
   else if (Im >> Real >> _Ch && _Ch != ',')
      if (_Ch == ')')
         Imag = 0;
      else
         Im.putback(_Ch), Im.setstate(ios_base::failbit);
   else if (Im >> Imag >> _Ch && _Ch != ')')
         Im.putback(_Ch), Im.setstate(ios_base::failbit);
   if (!Im.fail())
      x = JComplex((_U)Real, (_U)Imag);
   return (Im);
}

// TEMPLATE FUNCTION operator<<
template<class Exponent, class _Tr, class _U> inline
   basic_ostream<Exponent, _Tr>&  operator<<(
      basic_ostream<Exponent, _Tr>& _O, const JComplex& x)
   {basic_ostringstream<Exponent, _Tr, allocator<Exponent> > _S;
   _S.flags(_O.flags());
   _S.imbue(_O.getloc());
   _S.precision(_O.precision());
   _S << '(' << Real(x) << ',' << Imag(x) << ')';
   return (_O << _S.str().c_str()); }
 #include <xcomplex>
*/

#endif

---