/***************************************************************************
                          complex-temp.hpp  -  description
                             -------------------
    begin                : Fri Jan 17 19:41:58 CST 2003
    copyright            : (C) 2003 by Daniel Eric Smith
    email                : 
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/



#include <math.h>
#include <iomanip.h>

template <class X> class complex {
  X real,imag;
 public:
  complex() {real=0; imag=0;}
  complex(X x) {real=x; imag=0;}
  complex(X r, X i) {real=r; imag=i;}  //parameterized construtor
  void set(X r, X i);                  //initializes z
  void show() {cout <<real<<"+"<<imag<<"i"<<endl;}
  X Re();                                //returns the real part of z
  X Im();                                //returns the imagaginary part of z
  X mod();                                  //returns the modulus of z
  X arg();                                  //returns the argument of z
/*
CONJUGATE AND ARITMETIC
*/
  complex<X> operator~();                           //complex conjugate operator ~(a+bi)=>a-bi
  friend complex<X> operator+(complex<X> z, complex<X> w); //complex addition z+w
//  friend complex<X> operator+(complex<X> z, X r);
//  friend complex<X> operator+(X r, complex<X> z);
//  friend complex<X> operator-(complex<X> z, complex<X> w);                  //complex subtraction z-w
//  friend complex<X> operator-(complex<X> z, X r);
//  friend complex<X> operator-(X r, complex<X> z);
//  friend complex<X> operator*(complex<X> z, complex<X> w);                  //complex multiplication
//  friend complex<X> operator*(complex<X> z, X r);
//  friend complex<X> operator*(X r, complex<X> z);
//  friend complex<X> operator/(complex<X> z, complex<X> w);                  //complex division
//  friend complex<X> operator/(complex<X> z, X r);
//  friend complex<X> operator/(X r, complex<X> z);
//  complex<X> operator=(complex<X> w);                  //complex equality
/*
OUTPUT
*/
//  friend istream& operator>>(istream& s, complex<X>& z);
//  friend ostream& operator<<(ostream& s, complex<X> z);
/*
EXPONENTIAL
*/  
//  friend complex<X> exp(complex<X> z);
/*
TRIG
*/
//  friend complex<X> sin(complex<X> z);
//  friend complex<X> cos(complex<X> z);
//  friend complex<X> tan(complex<X> z);
//  friend complex<X> cot(complex<X> z);
//  friend complex<X> sec(complex<X> z);
//  friend complex<X> csc(complex<X> z);
//  friend complex<X> asin(complex<X> z);
//  friend complex<X> acos(complex<X> z);
//  friend complex<X> atan(complex<X> z);
/*
HYPERBOLIC TRIG
*/
//  friend complex<X> sinh(complex<X> z);
//  friend complex<X> cosh(complex<X> z);
//  friend complex<X> tanh(complex<X> z);
//  friend complex<X> coth(complex<X> z);
//  friend complex<X> sech(complex<X> z);
//  friend complex<X> csch(complex<X> z);
//  friend complex<X> asinh(complex<X> z);
//  friend complex<X> acosh(complex<X> z);
//  friend complex<X> atanh(complex<X> z);
/*
LOG
*/
//  friend complex<X> log(complex<X> z);
/*
EXPONENT
*/
// friend complex<X> pow(complex<X> z, complex<X> w);
// friend complex<X> pow(complex<X> z, X x);
// friend complex<X> pow(X x, complex<X> w);
};

/*****************************
*                            *
* I defines imagaginary unit *
*                            *
*****************************/
//const complex<X> I(0,1);





template <class X> void complex<X>::set(X r, X i)
{
  real=r;
  imag=i;
}

template <class X> X complex<X>::Re()
{
  return real;
}

template <class X> X complex<X>::Im()
{
  return imag;
}

template <class X> X complex<X>::mod()
{
  return sqrt(pow(real,2)+pow(imag,2));
}

template <class X> X complex<X>::arg()
{
  return atan2(imag,real);
}




/**************************
* CONJUGATE AND ARITMETIC *
**************************/

/****************
*               *
* ~z  CONJUGATE *
*               *
****************/
template <class X> complex<X> complex<X>::operator~()
{
  complex<X> temp;

  temp=*this;
  temp.imag=(-1)*imag;

  return temp;
}
/****************
*               *
* z+w  ADDITION * 
*               *
****************/
template <class X> complex<X> operator+(complex<X> z, complex<X> w)
{
	complex<X> zsum;
	
	zsum.real=z.real+w.real;
	zsum.imag=z.imag+w.imag;

	return zsum;
}
/*complex<X> operator+(complex<X> z, X r)
{
  complex<X> zsum,t(r);

  zsum.real=z.real+t.real;
  zsum.imag=z.imag+t.imag;

  return zsum;
}
complex<X> operator+(X r, complex<X> z)
{
  return z+r;
}*/
/******************
*                 *
* z-w SUBTRACTION *
*                 *
******************/
/*template <class X> complex<X> operator-(complex<X> z, complex<X> w)
{
  complex<X> zdiff;

  zdiff.real=z.real-w.real;
  zdiff.imag=z.imag-w.imag;

  return zdiff;
}
template <class X> complex<X> operator-(complex<X> z, X r)
{
  complex<X> zdiff,t(r);

  zdiff.real=z.real-t.real;
  zdiff.imag=z.imag-t.imag;

  return zdiff;
}
template <class X> complex<X> operator-(X r, complex<X> z)
{
  complex<X> zdiff,t(r);

  zdiff.real=t.real-z.real;
  zdiff.imag=t.imag-z.imag;

  return zdiff;  
}*/
/*********************
*                    *
* z*w MULTIPLICATION *
*                    *
*********************/
/*template <class X> complex<X> operator*(complex<X> z, complex<X> w)
{
  complex<X> zprod;

  zprod.real=z.real*w.real-z.imag*w.imag;
  zprod.imag=z.real*w.imag+z.imag*w.real;

  return zprod;
}
template <class X> complex<X> operator*(complex<X> z, X r)
{
	complex<X> zprod;

	zprod.real=z.real*r;
	zprod.imag=z.imag*r;

	return zprod;
}
template <class X> complex<X> operator*(X r, complex<X> z)
{
	return z*r;
}*/
/***************
*              *
* z/w DIVISION *
*              *
***************/
/*template <class X> complex<X> operator/(complex<X> z, complex<X> w)
{
  complex<X> zquot,num,denom,wc;
  wc=~w;
  
  num = z * wc;
  denom = w * wc;
  
  zquot.real=num.real/denom.real;
  zquot.imag=num.imag/denom.real;

  return zquot;
}
template <class X> complex<X> operator/(complex<X> z, X r)
{
	complex<X> zquot;

	zquot.real=z.real/r;
	zquot.imag=z.imag/r;

	return zquot;
}
template <class X> complex<X> operator/(X r, complex<X> z)
{
	complex<X> zquot, zc, denom,num;

	zc=~z;
	num=r*zc;
	denom=z*zc;

	zquot.real=num.real/denom.real;
	zquot.imag=num.imag/denom.real;

  return zquot;
}*/
/***************
*              *
* z=w EQUALITY *
*              *
***************/
/*template <class X> complex<X> complex<X>::operator=(complex<X> w)
{
  real=w.real;
  imag=w.imag;

  return *this;
}*/




/***************
* INPUT/OUTPUT *
***************/
/*istream& operator>>(istream& s, complex<X>& z)
{
  s>>z.real>>z.imag;
  return s;
}

ostream& operator<<(ostream& s, complex<X> z)
{
 X imag2;

  if(z.imag>=0)
    {  
      s<<z.real<<"+"<<z.imag<<"i";
    }
  else
    {
      imag2=(-1)*z.imag;
      s <<z.real<<"-"<<imag2<<"i";
    }
  return s;
}*/

/*********************
*                    *
* exp(z) EXPONENTIAL *
*                    *
*********************/
/*template <class X> complex<X> exp(complex<X> z)
{
	complex<X> e;

	e.real=exp(z.real)*cos(z.imag);
	e.imag=exp(z.real)*sin(z.imag);

	return e;
}*/


/*************************
* TRIGONMETRIC FUNCTIONS *
*************************/

/*********
*        *
* sin(x) *
*        *
*********/
/*template <class X> complex<X> sin(complex<X> z)
{
	return ((exp(z*I)-exp((-1)*z*I))/(2*I));
}*/

/*********
*        *
* cos(x) *
*        *
*********/
/*template <class X> complex<X> cos(complex<X> z)
{
	return ((exp(z*I)+exp((-1)*z*I))/2);
}*/

/*********
*        *
* tan(x) *
*        *
*********/
/*template <class X> complex<X> tan(complex<X> z)
{
	return sin(z)/cos(z);
}*/

/*********
*        *
* cot(x) *
*        *
*********/
/*template <class X> complex<X> cot(complex<X> z)
{
	return cos(z)/sin(z);
}*/

/*********
*        *
* sec(x) *
*        *
*********/
/*template <class X> complex<X> sec(complex<X> z)
{
	return 1/cos(z);
}*/

/*********
*        *
* csc(x) *
*        *
*********/
/*template <class X> complex<X> csc(complex<X> z)
{
	return 1/sin(z);
}*/
/**********
*         *
* asin(x) *
*         *
**********/
/*template <class X> complex<X> asin(complex<X> z)
{
  complex<X> t;

  return (-1)*I*log(I*z+pow(1-z*z,.5));
}*/

/**********
*         *
* acos(x) *
*         *
**********/
/*template <class X> complex<X> acos(complex<X> z)
{
	return (-1)*I*log(z+I*pow(1-z*z,.5));
}*/

/**********
*         *
* atan(x) *
*         *
**********/
/*template <class X> complex<X> atan(complex<X> z)
{
	return I/2*log((I+z)/(I-z));
}*/



/************************************
* HYPERBOLIC TRIGONMETRIC FUNCTIONS *
************************************/

/**********
*         *
* sinh(x) *
*         *
**********/
/*template <class X> complex<X> sinh(complex<X> z)
{
	return ((exp(z)-exp((-1)*z))/2);
}*/

/**********
*         *
* cosh(x) *
*         *
**********/
/*template <class X> complex<X> cosh(complex<X> z)
{
	return ((exp(z)+exp((-1)*z))/2);
}*/

/**********
*         *
* tanh(x) *
*         *
**********/
/*template <class X> complex<X> tanh(complex<X> z)
{
	return sinh(z)/cosh(z);
}*/

/**********
*         *
* coth(x) *
*         *
**********/
/*template <class X> complex<X> coth(complex<X> z)
{
	return cosh(z)/sinh(z);
}*/

/**********
*         *
* sech(x) *
*         *
**********/
/*template <class X> complex<X> sech(complex<X> z)
{
	return 1/cosh(z);
}*/

/**********
*         *
* csch(x) *
*         *
**********/
/*template <class X> complex<X> csch(complex<X> z)
{
	return 1/sinh(z);
}*/
/**********
*         *
* asinh(x) *
*         *
**********/
/*template <class X> complex<X> asinh(complex<X> z)
{
	return log(z+pow(z*z+1,.5));
}*/

/**********
*         *
* acosh(x) *
*         *
**********/
/*template <class X> complex<X> acosh(complex<X> z)
{
	return log(z+pow(z*z-1,.5));
}*/

/**********
*         *
* atanh(x) *
*         *
**********/
/*template <class X> complex<X> atanh(complex<X> z)
{
  return .5*log((1+z)/(1-z));
}*/

/***********************
*                      *
* LOGARITHMIC FUNCTION *
*                      *
***********************/
/*template <class X> complex<X> log(complex<X> z)
{
  X m,a;
  complex<X> l;

  m=z.mod();
  a=z.arg();
  
  l.real=log(m);
  l.imag=a;

  return l;
}*/

/***********
*          *
* EXPONENT *
*          *
***********/
/*template <class X> complex<X> pow(complex<X> z, complex<X> w)
{
  return exp(w*log(z));
}
complex<X> pow(complex<X> z, X x)
{
  return exp(x*log(z));
}
complex<X> pow(X x, complex<X> w)
{
  return exp(w*log(x));
}*/