Complex number source code

//   complex.h - declaration of class
//   of complex number
//
//   The code is property of LIBROW
//   You can use it on your own
//   When utilizing credit LIBROW site

#ifndef _COMPLEX_H_
#define _COMPLEX_H_

class complex
{
protected:
   //   Internal presentation - real and imaginary parts
   double m_re;
   double m_im;

public:
   //   Imaginary unity
   static const complex i;
   static const complex j;

   //   Constructors
   complex(): m_re(0.), m_im(0.) {}
   complex(double re, double im): m_re(re), m_im(im) {}
   complex(double val): m_re(val), m_im(0.) {}

   //   Assignment
   complex& operator= (const double val)
   {
      m_re = val;
      m_im = 0.;
      return *this;
   }

   //   Basic operations - taking parts
   double re() const { return m_re; }
   double im() const { return m_im; }

   //   Conjugate number
   complex conjugate() const
   {
      return complex(m_re, -m_im);
   }

   //   Norm   
   double norm() const
   {
      return m_re * m_re + m_im * m_im;
   }

   //   Arithmetic operations
   complex operator+ (const complex& other) const
   {
      return complex(m_re + other.m_re, m_im + other.m_im);
   }

   complex operator- (const complex& other) const
   {
      return complex(m_re - other.m_re, m_im - other.m_im);
   }

   complex operator* (const complex& other) const
   {
      return complex(m_re * other.m_re - m_im * other.m_im,
         m_re * other.m_im + m_im * other.m_re);
   }

   complex operator/ (const complex& other) const
   {
      const double denominator = other.m_re * other.m_re +
         other.m_im * other.m_im;
      return complex((m_re * other.m_re + m_im * other.m_im) / denominator,
         (m_im * other.m_re - m_re * other.m_im) / denominator);
   }

   complex& operator+= (const complex& other)
   {
      m_re += other.m_re;
      m_im += other.m_im;
      return *this;
   }

   complex& operator-= (const complex& other)
   {
      m_re -= other.m_re;
      m_im -= other.m_im;
      return *this;
   }

   complex& operator*= (const complex& other)
   {
      const double temp = m_re;
      m_re = m_re * other.m_re - m_im * other.m_im;
      m_im = m_im * other.m_re + temp * other.m_im;
      return *this;
   }

   complex& operator/= (const complex& other)
   {
      const double denominator = other.m_re * other.m_re +
         other.m_im * other.m_im;
      const double temp = m_re;
      m_re = (m_re * other.m_re + m_im * other.m_im) / denominator;
      m_im = (m_im * other.m_re - temp * other.m_im) / denominator;
      return *this;
   }

   complex& operator++ ()
   {
      ++m_re;
      return *this;
   }

   complex operator++ (int)
   {
      complex temp(*this);
      ++m_re;
      return temp;
   }

   complex& operator-- ()
   {
      --m_re;
      return *this;
   }

   complex operator-- (int)
   {
      complex temp(*this);
      --m_re;
      return temp;
   }

   complex operator+ (const double val) const
   {
      return complex(m_re + val, m_im);
   }

   complex operator- (const double val) const
   {
      return complex(m_re - val, m_im);
   }

   complex operator* (const double val) const
   {
      return complex(m_re * val, m_im * val);
   }

   complex operator/ (const double val) const
   {
      return complex(m_re / val, m_im / val);
   }

   complex& operator+= (const double val)
   {
      m_re += val;
      return *this;
   }

   complex& operator-= (const double val)
   {
      m_re -= val;
      return *this;
   }

   complex& operator*= (const double val)
   {
      m_re *= val;
      m_im *= val;
      return *this;
   }

   complex& operator/= (const double val)
   {
      m_re /= val;
      m_im /= val;
      return *this;
   }

   friend complex operator+ (const double left, const complex& right)
   {
      return complex(left + right.m_re, right.m_im);
   }

   friend complex operator- (const double left, const complex& right)
   {
      return complex(left - right.m_re, -right.m_im);
   }

   friend complex operator* (const double left, const complex& right)
   {
      return complex(left * right.m_re, left * right.m_im);
   }

   friend complex operator/ (const double left, const complex& right)
   {
      const double denominator = right.m_re * right.m_re +
         right.m_im * right.m_im;
      return complex(left * right.m_re / denominator,
         -left * right.m_im / denominator);
   }

   //   Boolean operators
   bool operator== (const complex &other) const
   {
      return m_re == other.m_re && m_im == other.m_im;
   }

   bool operator!= (const complex &other) const
   {
      return m_re != other.m_re || m_im != other.m_im;
   }

   bool operator== (const double val) const
   {
      return m_re == val && m_im == 0.;
   }

   bool operator!= (const double val) const
   {
      return m_re != val || m_im != 0.;
   }

   friend bool operator== (const double left, const complex& right)
   {
      return left == right.m_re && right.m_im == 0.;
   }

   friend bool operator!= (const double left, const complex& right)
   {
      return left != right.m_re || right.m_im != 0.;
   }
};

#endif