//developement d'une classe pour les nombres complexes
#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

class Complexe {
  public:
    //constructeurs
    Complexe();
    Complexe(double re_z, double im_z);
    Complexe(const Complexe &r);     //constructeur de copie
    
    //fonctions d'acces
    double getModZ() const;
    double getPhaseZ() const;

    //fonctions surchargees
    Complexe operator+(const Complexe &) const;
    Complexe operator-() const;
    Complexe operator-(const Complexe &) const;
    Complexe operator*(const Complexe &) const;
    Complexe operator/(const Complexe &) const;
    
    //autres methodes publiques
    void print() const;
    Complexe conjugue() const;
    double norm() const;

  private:    
    double reZ, imZ;
    double modZ, phaseZ;
};

//constructeurs
Complexe::Complexe() {
}
Complexe::Complexe(double re_Z, double im_Z): reZ(re_Z), imZ(im_Z) {
  //les autres donnees privees sont initialisees 
  //lors de l'initialisation de la classe
  modZ = sqrt(reZ*reZ+imZ*imZ);
  //double tang = imZ/reZ;
  phaseZ = atan(imZ/reZ);
}
Complexe::Complexe(const Complexe &z): reZ(z.reZ), imZ(z.imZ) {
}

//fonctions d'acces
double Complexe::getModZ() const {
  return modZ;
}
double Complexe::getPhaseZ() const {
  return phaseZ;
}

//operateurs surchargees
Complexe Complexe::operator+(const Complexe &v) const {
  Complexe res(reZ+v.reZ,imZ+v.imZ);
  return res;
}
Complexe Complexe::operator-() const {
  Complexe res(-reZ,-imZ);
  return res;
}
Complexe Complexe::operator-(const Complexe &v) const {
  Complexe res(reZ-v.reZ,imZ-v.imZ);
  return res;
}
Complexe Complexe::operator*(const Complexe &v) const {
  //pour la multiplication des complexes on peut utilizer aussi
  //la notation polaire, mais la precision peut etre pire
  //  float reAux = modZ*v.modZ *cos(phaseZ+v.phaseZ);
  //  float imAux = modZ*v.modZ *sin(phaseZ+v.phaseZ);
  double reAux = reZ*v.reZ - imZ*v.imZ;
  double imAux = reZ*v.imZ + imZ*v.reZ;

  Complexe res(reAux,imAux);
  return res;
}
Complexe Complexe::operator/(const Complexe &v) const {
  //la division entre complexes z/v est en fait z*v.conjugue()/v.norm()^2
  //on pourrait aussi definir la division exactement de cette maniere,
  //mais il faudrait prevoir la division d'un nombre complexe par un reel
  if (v.modZ==0)
    cout << "Attention !, division par zero !" << endl;
  double reAux = (reZ*v.reZ + imZ*v.imZ) / (v.modZ*v.modZ);
  double imAux = (imZ*v.reZ - reZ*v.imZ) / (v.modZ*v.modZ);

  Complexe res(reAux,imAux);
  return res;
}

//methodes publiques
//nous n'imprimons pas la partie reelle si cette est zero 
//meme pour la partie imaginaire
//si les deux partie sont egaux a zero, on imprime 0
void Complexe::print() const {
  if (reZ!=0) {
    cout << setprecision(5) << setw(7) << reZ;
    if (imZ!=0) {    
      if (imZ>0)
        cout<<" + ";
      else 
        cout<<" - ";
      cout << setprecision(5) << setw(7) << fabs(imZ) << " i";
    }
  }
  else 
    if (imZ!=0)
      cout << setprecision(5) << setw(7) << imZ << " i";
    else
      cout << setprecision(5) << setw(7) << 0;
  cout << endl;
}

Complexe Complexe::conjugue() const {
  Complexe res(reZ,-imZ);
  return res;
}

double Complexe::norm() const {
  return modZ;
}

int main(){
  double re,im;
  cout << "Entrez la partie reelle d'un nombre complexe : ";
  cin >> re;
  cout <<"et la partie imaginaire : ";
  cin >> im;
  Complexe a(re,im);
  cout << "a = ";   a.print();
  cout << "mod a: " << a.getModZ() << endl;
  cout << "phase a: " << a.getPhaseZ()/M_PI*180.0 << endl;

  Complexe b(0.,-0.9899887);
  cout << "b = ";
  b.print();

  Complexe c = a-b;
  cout << "c = a - b = ";
  c.print();

  Complexe d = a*b;
  cout << "d = a * b = ";
  d.print();

  Complexe f = d.conjugue();
  cout << "f = d* = ";
  f.print();

  Complexe g = c/a;
  cout << "g = c / a = ";
  g.print();
  
  cout << "mod a = " << a.norm() << ", mod b = " << b.norm()
       << ", mod c = " << c.norm() << "," << endl;
  cout << "mod d = " << d.norm() << ", mod f = " << f.norm()
       << ", mod g = " << g.norm() << endl;

  return 0;
}