Complex.cs

Go to the documentation of this file.

using System;

namespace FFT {

   ///
   /// Complex numbers.
   ///
   /// Planar representation of complex numbers is used. A complex number is 
   /// a pair of real numbers: its real and imaginary components. 
   /// Real numbers of double precision are used. 
   ///
   public struct Complex : IEquatable<Complex>
   {
      ///
      /// The real part
      ///
      public double Re {get; private set;}
      
      ///
      /// The imaginary part 
      ///
      public double Im {get; private set;}
      
      ///
      /// Complex number from the read and imaginary parts.
      ///
      /// \param re the real component.
      /// \param im the imaginary component.
      ///
      public Complex(double re, double im) : this()
      {
         this.Re = re;
         this.Im = im;
      }

      /// Complex number from polar coordinates.
      ///
      /// \param modulus the absolute value (the radius).
      /// \param argument the angle.
      /// \returns the corresponding complex value.
      ///
      public static Complex FromPolar(double modulus, double argument)
      {
         return new Complex(modulus*Math.Cos(argument),
                            modulus*Math.Sin(argument));
      }
      
      ///
      /// Modulus (radius) of the complex number. 
      ///
      public double Modulus
      {
         get { return Math.Sqrt(this.Re*this.Re+this.Im*this.Im); }
      }
      
      ///
      /// Argument (angle) of the complex number
      ///
      public double Argument
      {
         get { return Math.Atan2(this.Im,this.Re);}
      }
      
      /// The conjugate complex number. 
      ///
      /// The conjugate of a complex number \f$z=a+ib\f$ is defined as 
      /// \f$\bar{z}=a-ib\f$.
      ///
      public Complex Conjugate
      {
         get { return new Complex(this.Re,-this.Im); }
      }
      
      ///
      /// Implicit cast from a <tt>double</tt>. 
      ///
      public static implicit operator Complex(double r)
      {
         return new Complex(r,0);
      }
      
      ///
      /// Implicit cast from <tt>int</tt>.
      ///
      public static implicit operator Complex(int i) 
      {
         return new Complex(i,0);
      }

      ///
      /// Overloaded binary <tt>+</tt> operator.
      ///
      public static Complex operator +(Complex z, Complex s)
      {
         return new Complex(z.Re + s.Re,z.Im + s.Im);
      }
      
      ///
      /// Overloaded binary <tt>-</tt> operator.
      ///
      public static Complex operator -(Complex z, Complex s)
      {
         return new Complex(z.Re - s.Re, z.Im - s.Im);
      }
      
      ///
      /// Overloaded unary <tt>-</tt> operator.
      ///
      public static Complex operator -(Complex z)
      {
         return new Complex(-z.Re,-z.Im);
      }
      
      ///
      /// Overloaded binary \f$*\f$ operator
      ///
      public static Complex operator *(Complex z, Complex s)
      {
         return new Complex(z.Re * s.Re - z.Im * s.Im, z.Re * s.Im + z.Im * s.Re);
      }
      
      ///
      /// Overloaded binary <tt>/</tt> operator. 
      ///
      public static Complex operator /(Complex z, Complex s)
      {
         double d = s.Re*s.Re + s.Im*s.Im;
         Complex res = z * s.Conjugate;

         res.Re /= d;
         res.Im /= d;
         
         return res;
      }

      public bool Equals(Complex c)
      {
         return (this.Re == c.Re && this.Im == c.Im);
      }
      
      ///
      /// String value of the complex number. 
      ///
      /// This method checks the sign and value of the imaginary part. Some examples:
      /// \code 
      ///  new Complex(1,1).ToString();   // "1 + 1i" 
      ///  new Complex(1,-1).ToString();  // "1 - 1i" 
      ///  new Complex(1,0).ToString();   // "1" 
      ///  new Complex(0,1).ToString();   // "1i"
      ///  new Complex(-1,1).ToString();  // "-1 + 1i"
      /// \endcode
      ///
      public override string ToString()
      {
         if (this.Im == 0) {
            return this.Re.ToString();
         } else if (this.Re == 0) {
            return this.Im.ToString() + "i";
         } else {
            return String.Format("{0} {1} {2}i",
                                 this.Re,
                                 (this.Im < 0)?('-'):('+'),
                                 (this.Im < 0)?(-this.Im):(this.Im));
         }
      }

   } //class Complex

} //namespace FFT

---