solution

Printed by Vincent Granet
oct. 04, 16 19:35
complexe0.cpp
#include <iostream>
#include <cmath>
oct. 04, 16 19:35
complexe0.cpp
Page 2/3
return complexe(this−>preelle−c.preelle, this−>pimg−c.pimg);
}
#include "complexe0.hpp"
complexe complexe::operator−(complexe c) const {
return this−>moins(c);
}
using namespace std;
const double complexe::eps = 1E−05;
const complexe complexe::I = complexe(0,1);
/*
* Construit un objet Complexe à partir de deux
* paramètres double qui représentent les coordonnées
* polaires (rho et theta) d’un complexe.
*
* @param r un double
* @param t un double
* @return un Complexe
*/
complexe complexe::polComplexe(double r, double t){
return complexe(r*cos(t),r*sin(t));
}
double complexe::getPreelle(void) const {
return this−>preelle;
}
void complexe::setPreelle(double r) {
this−>preelle = r;
}
double complexe::getPimg(void) const {
return this−>pimg;
}
/*
* Rôle : renvoie this * c
*
* @param c un complexe.
* @return complexe.
*/
complexe complexe::mult(complexe c) const {
// Faire le produit des normes et la somme des phases
// de this et c et construire un Complexe qui sera donc le
// produit de this par c
return complexe::polComplexe(this−>rho()*c.rho(), this−>theta()+c.theta());
}
void complexe::setPimg(double i) {
this−>pimg = i;
}
void complexe::ecrireComplexe(void) const {
cout << "(" << this−>getPreelle() << "," << this−>getPimg() << ")";
}
std::ostream& operator<< (std::ostream& f, const complexe& c) {
c.ecrireComplexe();
return f;
}
complexe complexe::operator*(complexe c) const {
return this−>mult(c);
}
// Les fonctions de conversion polaires
/*
* Renvoie la norme de l’objet complexe courant.
*/
double complexe::rho(void) const {
return sqrt(this−>preelle*this−>preelle + this−>pimg*this−>pimg);
}
/*
* Rôle : renvoie this / c
*
* @param c un complexe.
* @return complexe.
*/
complexe complexe::div(complexe c) const {
// Faire la division des normes et la différence des phases
// de this et c et construire un Complexe qui sera donc le
// produit de this par c
return complexe::polComplexe(this−>rho()/c.rho(), this−>theta()−c.theta());
}
/*
* Renvoie la phase de l’objet complexe courant.
*/
double complexe::theta(void) const {
return atan2(this−>pimg, this−>preelle);
}
complexe complexe::operator/(complexe c) const {
return this−>div(c);
}
/*
* Rôle : renvoie this + c
*/
complexe complexe::plus(complexe c) const {
return complexe(this−>preelle+c.preelle, this−>pimg+c.pimg);
}
/*
* Teste si le paramètre complexe c et
* de l’objet courant sont égaux.
* Le test est fait à un epsilon près.
*
* @param c un complexe
*/
bool complexe::egal(complexe c) const {
return fabs(this−>preelle−c.preelle)<eps && fabs(this−>pimg−c.pimg)<eps;
}
complexe complexe::operator+(complexe c) const {
return this−>plus(c);
}
/*
* Rôle : renvoie this − c
*/
complexe complexe::moins(complexe c) const {
mardi octobre 04, 2016
Printed by Vincent Granet
Page 1/3
1/4
2/4
mardi octobre 04, 2016
Printed by Vincent Granet
oct. 04, 16 19:35
complexe0.cpp
Page 3/3
Printed by Vincent Granet
complexe0.hpp
oct. 04, 16 19:35
Page 1/1
#ifndef COMPLEXE_HPP
#define COMPLEXE_HPP
bool complexe::operator==(complexe c) const {
return this−>egal(c);
}
#include <iostream>
class complexe {
private:
static const double eps;
static const complexe I;
double preelle;
double pimg;
public:
// constructeurs
complexe(double r=0, double i=0) : preelle(r), pimg(i) {}
complexe(complexe const& c) : preelle(c.preelle), pimg(c.pimg) {}
// le destructeur (pédagogique)
~complexe(void) {
// std::cout << "destr comp\n";
}
// accesseurs
double getPreelle(void) const;
double getPimg(void) const;
// mutateurs
void setPreelle(double r);
void setPimg(double i);
// les méthodes
double rho(void) const;
double theta(void) const;
/**
* Teste si le paramètre complexe c et
* de l’objet courant sont différents.
* Le test est fait à un epsilon près.
*
* @param c un complexe.
*/
bool complexe::different(complexe c) const {
return !this−>egal(c);
}
bool complexe::operator!=(complexe c) const {
return this−>different(c);
}
/* Rôle : renvoie le conjugué du complexe courant.
*
* @return <complexe
*/
complexe complexe::conjugue(void) const {
return complexe(this−>preelle, −this−>pimg);
}
complexe complexe::operator~(void) const {
return this−>conjugue();
}
complexe conjugue(void) const;
static complexe polComplexe(double r, double t);
complexe plus(complexe c) const;
complexe moins(complexe c) const;
complexe mult(complexe c) const;
complexe div(complexe c) const ;
bool different(complexe c) const;
bool egal(complexe c) const;
// surcharge des opérateurs
complexe
complexe
complexe
complexe
operator+(complexe
operator−(complexe
operator*(complexe
operator/(complexe
c)
c)
c)
c)
const;
const;
const;
const;
complexe operator~(void) const;
bool operator!=(complexe c) const;
bool operator==(complexe c) const;
// Entrées/Sorties
void ecrireComplexe(void) const;
};
#endif //
mardi octobre 04, 2016
3/4
4/4
COMPLEXE_HPP
mardi octobre 04, 2016