#ifndef CMPLX
	#define CMPLX
/*
 *  complex arithmetic C++ class Cmplx
 *  by Dick Kostelnicek 05/12/2021
 *  operations with (double)d, (double)c, (Cmplx)w, and (Cmplx)z
 *  yields Cmplx:       w=Cmplx(d,c), w=z, w=d, +z, -z, 
 *                      w+z, w+=z, w+d, w+=d, d+z, 
 *                      w-z, w-=z, w-d, w-=d, d-z, 
 *                      w*z, w*=z, w*d, w*=d, d*z,
 *                      w/z, w/=z, w/d, w/=d, d/z, 
 *                      conj(z), exp(z); log(z), sin(z),
 *                      cos(z), polar(d, c), pow(w,z)
 *  yields double:      Re(z), Im(z), mag(z), arg(z)
 *  yields bool:        w==z; w!=z, 
 *  output streaming:   cout << "w = " << w << endl;
 */

	#include <math.h>    // sqrt(), sin(), cos(), atan2()
	#include <iostream>  // streaming Cmplx value
	using namespace std; // define cout and endl

	class Cmplx
	{
	    private:
	        double x = 0; // real part
	        double y = 0; // Imaginary part
	        
	    public:
            // constructor
            Cmplx(double re = 0.0, double im = 0.0);

            // Cmplx = Cmplx
            Cmplx& operator = (const Cmplx& z); 

            // Cmplx = double
            Cmplx& operator = (const double& d); 

           // comparison
            bool operator == (const Cmplx& z) const;
            
           // differentiation
            bool operator != (const Cmplx& z) const;
            
            // +Cmplx
            Cmplx operator + () const; 

            // -Cmplx
            Cmplx operator - () const; 

            // Cmplx + Cmplx
            Cmplx operator + (Cmplx const& z) const; 
 
            // Cmplx += Cmplx
            Cmplx& operator += (Cmplx const& z); 
 
            // Cmplx + double
            Cmplx operator + (double const& d) const; 

            // Cmplx += double
            Cmplx& operator += (double const& d); 
           
            // double + Cmplx
            friend Cmplx operator + (const double& d, const Cmplx& z);
           
            // Cmplx - Cmplx
            Cmplx operator - (Cmplx const& z) const; 

            // Cmplx -= Cmplx
            Cmplx& operator -= (Cmplx const& z); 

            // Cmplx - double
            Cmplx operator - (double const& d) const; 

            // Cmplx -= double
            Cmplx& operator -= (double const& d);             

            // double - Cmplx
            friend Cmplx operator - (const double& d, const Cmplx& z);
          
            // Cmplx * Cmplx
            Cmplx operator * (Cmplx const& z) const; 

            // Cmplx *= Cmplx
            Cmplx& operator *= (Cmplx const& z); 

            // Cmplx * double
            Cmplx operator * (double const& d) const; 

            // Cmplx *= double
            Cmplx& operator *= (double const& d);

            // double * Cmplx
            friend Cmplx operator * (const double& d, const Cmplx& z);

            // Cmplx / Cmplx
            Cmplx operator / (Cmplx const& z) const;

            // Cmplx /= Cmplx
            Cmplx& operator /= (Cmplx const& z); 

            // Cmplx / double
            Cmplx operator / (double const& d) const; 
 
            // Cmplx /= double
            Cmplx& operator /= (double const& d); 

            // double / Cmplx
            friend Cmplx operator / (const double& d, const Cmplx& z);

            // real part
            friend double Re(Cmplx const& z);

            // imaginary part
            friend double Im(Cmplx const& z);

            // conjugate
            friend Cmplx conj(Cmplx const& z);

            // magnitude
            friend double mag(Cmplx const& z);

            // argument (radians)
            friend double arg(Cmplx const& z);

            // exponentiate
            friend Cmplx exp(Cmplx const& z); 

            // natural log
            friend Cmplx log(Cmplx const& z);
            
            // sin
            friend Cmplx sin(Cmplx const& z);

            // cos
            friend Cmplx cos(Cmplx const& z);

            //  output  as: cout << Cmplx << endl
            friend ostream& operator << (ostream& os, const Cmplx& z);
	};

    // Polar to Cmplx 
    Cmplx polar(const double& rho, const double& theta);
   
    #define pow(base, exponent) (exp(exponent*log(base)))
   
#endif