*J'ai revu les 3 premier exercises du projet et modifie quelques reponses (jusqu'a P7.2 compris) et fichiers tests.

*Rajoute la classe MutableVector3D pour representer des vecteurs mutables.

8 files changed, 259 insertions, 306 deletions

diff --git a/reponses.lyx b/reponses.lyx
index 096f8e4..f73b117 100644
--- a/reponses.lyx
+++ b/reponses.lyx
@@ -97,6 +97,9 @@ opérateurs
 Ces méthodes s'appuient entre-elles, par exemple la méthode `opposée' retourne
  le vecteur multiplié par moins un et la méthode `soustraction' additionne
  l'opposé.
+ C'est à partir de cette idee que nous avons aussi implémenté une norme
+ au carré (=produit scalaire du vecteur avec lui-même) et une norm (=racine
+ de la norme au carré).
  Ces appels consécutifs diminuent la performance d'une façon minimale mais
  évitent un duplicage de code considérable.
 \end_layout
@@ -108,7 +111,8 @@ Un vecteur est complètement invariable.
  De même, tous les opérations internes du sens mathématique (qui renvoyent
  un vecteur), renvoyent une nouvelle instance d'un vecteur.
  En aucun cas l'instance d'un vecteur n'est modifiée! Ceci facilite énormément
- le raisonement sur toute variable de type vecteur.
+ le raisonement sur toute variable de type vecteur, c'est-à-dire qu'on peut
+ toujours être sûr que personne n'a modifié le vecteur sur lequel on travaille.
  De plus, l'invariance d'un vecteur paraît naturelle, comme celle d'un nombre
  réel.
 \end_layout
@@ -119,6 +123,15 @@ Quelques vecteurs remarquables sont définis comme variables statiques constante
  i, j, k selon respectivement les axes x, y et z.
 \end_layout
 
+\begin_layout Standard
+Pour contourner la perte de performance due à l'immutabilité des vecteurs,
+ nous avons rajouté un classe `MutableVector3D'.
+ Cette classe représente des vecteurs mutables lesquelles peuvent changer
+ leurs coordonnées.
+ Ces vecteurs sont presque exclusivement utilisés pour représenter des champs
+ qui varient souvent tel que la position d'une particule.
+\end_layout
+
 \begin_layout Section*
 Question P3.1
 \end_layout
@@ -130,6 +143,11 @@ Nous n'avons pas rajouté un constructeur de copie.
  l'utilisation du constructeur de copie par défaut suffit.
 \end_layout
 
+\begin_layout Standard
+En revanche la classe `MutableVector3D' contient un constructeur de copie
+ qui copie les champs d'un vecteur donné.
+\end_layout
+
 \begin_layout Section*
 Question P3.2
 \end_layout
@@ -158,6 +176,8 @@ En ajoutant un constructeur par coordonnées sphériques, les attributs de
  la classe ne devraient pas forcémant être changées.
  Il serait toute à fait envisageable, de garder les coordonnées carthésiennes
  comme attributs et de convertir les coordonnées sphériques avec le constructeur.
+ L'accès et la modification des coordonnées shpériques pourrait égelement
+ se faire par un méthode convertissant les deux types de coordonnées.
 \end_layout
 
 \begin_layout Subsection*
@@ -207,24 +227,6 @@ Question P5.1
 \end_layout
 
 \begin_layout Standard
-
-\emph on
-\begin_inset ERT
-status open
-
-\begin_layout Plain Layout
-
-
-\backslash
-color{red}{Réponse incohérente! La question conçernant l'énergie me perturbe...}
-\end_layout
-
-\end_inset
-
-
-\end_layout
-
-\begin_layout Standard
 Les membres d'une particule représentant le facteur gamma
 \begin_inset Formula $\gamma$
 \end_inset
@@ -265,7 +267,7 @@ si il est défini comme variable, il faudrait le mettre à jour à chaque fois
 Contrairement à un attribut, une méthode est évaluée à chaque fois qu'on
  l'appelle.
  Ceci a l'avantage que si le résultat d'une méthode dépend d'une variable,
- la variable pourra être modifiée sans considération de la méthode.
+ la variable pourra être modifiée sans autre considération.
  Ainsi, si le facteur gamma est une méthode, une mise à jour de la vitesse
  pourra être effectuée directement sans explicitement changer 
 \begin_inset Formula $\gamma$
@@ -276,175 +278,55 @@ Contrairement à un attribut, une méthode est évaluée à chaque fois qu'on
 
 \begin_layout Standard
 Dans le cas de notre projet, nous avons décidés d'implémenter l'énergie
- sous forme d'attribut et le facteur gamma sous forme de méthode.
+ sous forme de méthode et le facteur gamma sous forme d'attribut.
  Ceci pour plusieurs raisons:
 \end_layout
 
 \begin_layout Enumerate
-Au cours de la simulation, la vitesse sera changée très fréquemment, beaucoup
- plus que les appels à gamma.
- Une implémentation de gamma sous forme de méthode améliore donc la performance.
+Au cours de la simulation, le facteur gamma est accédé autant de fois que
+ la vitesse, il est donc plus rapide de n'evoluer une racine qu'une seule
+ fois pour un pas de temps.
 \end_layout
 
 \begin_layout Enumerate
-Le premier argument pourrait s'appliquer également à l'énergie, or il faut
- remarquer que l'énergie est une grandeur spécifiée durant la création d'une
- particule et que en fait la vitesse dépend de l'énergie
-\begin_inset Foot
-status open
-
-\begin_layout Plain Layout
-Complément mathématique: 
-\begin_inset Quotes eld
-\end_inset
-
-Aux énergies atteintes dans un accélérateur, les particules sont tellement
- proches de la vitesse de la lumière qu'il faudrait garder au moins 7 décimales
- pour que la vitesse permette de connaître l'énergie de façon assez précise.
- On caractérise donc plutôt une particule en termes d'énergie totale que
- de vitesse.
-\begin_inset Quotes erd
-\end_inset
-
+L'énergie est accédée beaucoup plus rarement que la vitesse mais dépend
+ quand même de cette dernière, ainsi nous avons décidé de l'implémenter
+ sous forme de méthode.
+\end_layout
 
+\begin_layout Section*
+Question P6.1
 \end_layout
 
-\end_inset
+\begin_layout Standard
+Pour représenter et organiser les éléments, nous avons créé une classe abtsraite
+ `Element'.
+ Celle-ci contient tous les attributs généraux d'un élément.
+ De plus, elle contient des méthodes virtuelles pures tels que la détermination
+ si une particule a heurté le bord ou est passé au suivant.
+\end_layout
 
-.
- On pourrait alors penser à définir la vitesse comme méthode mais d'après
- l'argument 1, ce serait complètement absurde au niveau de la performance.
+\begin_layout Standard
+Dans la hierarchie en dessous de `Element' se trouvent deux classes representant
+s les élements droits et courbes.
+ Ceux-ci implémentent tout méthode relatif à la géométrie d'un élément (p.ex.
+ les méthodes mentionés ci-dessus).
 \end_layout
 
-\begin_layout Section*
-Question P6.1
+\begin_layout Standard
+Finalement, en dessous de ces classes se trouvent les implémentations concrètes
+ telles que les quadripoles, dipoles, etc...
 \end_layout
 
 \begin_layout Standard
-Pour représenter et organiser les 
-\family typewriter
-\size small
-Element
-\family default
-\size default
-s, nous avons choisi dans ce projet de coder les 
-\family typewriter
-\size small
-Element
-\family default
-\size default
-s 
-\family typewriter
-\size small
-[Magnetic (StraightElement
-\family default
-\size default
- et 
-\family typewriter
-\size small
-CurvedElement)
-\family default
-\size default
- et 
-\family typewriter
-\size small
-Electric
-\family default
-\size default
-] sous formes de classes.
- Concrètement, la classe 
-\family typewriter
-\size small
-Element
-\family default
-\size default
- est la classe grand-mère, les trois classes filles sont les classes
-\family typewriter
-\size small
- StraightElement
-\family default
-\size default
-, 
-\family typewriter
-\size small
-CurvedElement
-\family default
-\size default
- et 
-\family typewriter
-\size small
-Magnetic
-\family default
-\size default
-.
- Les trois classes petites-filles sont 
-\family typewriter
-\size small
-MagneticStraightElement
-\family default
-\size default
-, 
-\family typewriter
-\size small
-MagneticCurvedElement
-\family default
-\size default
- et 
-\family typewriter
-\size small
-Electric
-\family default
-\size default
-, où 
-\family typewriter
-\size small
-MagneticStraightElement
-\family default
-\size default
- hérite à la fois de 
-\family typewriter
-\size small
-Magnetic
-\family default
-\size default
- et de 
-\family typewriter
-\size small
-StraightElement
-\family default
-\size default
-, et où 
-\family typewriter
-\size small
-MagneticCurvedElement
-\family default
-\size default
- hérite de 
-\family typewriter
-\size small
-Magnetic
-\family default
-\size default
- et de 
-\family typewriter
-\size small
-CurvedElement
-\family default
-\size default
-.
- 
-\family typewriter
-\size small
-Electric
-\family default
-\size default
- n'hérite 'que' de 
-\family typewriter
-\size small
-StraightElement
-\family default
-\size default
-.
+Nous n'avons pas faits de classes séparés pour des élements générants un
+ champ électrique ou magnétique car nous considérons qu'un élément ne générant
+ pas de champ 
+\emph on
+possède
+\emph default
+ un champ nul.
+ (voir question P6.2)
 \end_layout
 
 \begin_layout Section*
@@ -452,43 +334,18 @@ Question P6.2
 \end_layout
 
 \begin_layout Standard
-Les champs magnétiques et électriques sont représentés à l'aide d'un 
-\family typewriter
-\size small
-Vector3D
-\family default
-\size default
- indiquant la direction et l'intensité du champ, et nous allons nous arranger
- pour que sa norme soit initialisée une fois pour toutes (pour garder l'intensit
-é de champ constante).
- Ainsi, à chaque nouvelle manipulation (modification d'orientation) du 
-\family typewriter
-\size small
-Vector3D
-\family default
-\size default
- 
-\family typewriter
-\size small
-field
-\family default
-\size default
-, nous ferons appel à la méthode 
-\family typewriter
-\size small
-rotate
-\family default
-\size default
-.
- Ce faisant, puisque la rotation est une isométrie, nous pouvons définir
- n'importe quelle orientation que pourrait prendre le champ, en nous assurant
- d'avoir une intensité de champ constante.
+Les champs magnétiques et électriques sont représentés par les méthodes
+ `magneticFieldAt' et `electricFieldAt'.
+ Ces méthodes prennent comme paramètre une position et renvoyent un vecteur
+ représentant le champ à cette position.
 \end_layout
 
 \begin_layout Standard
-En effet, en physique on représente les lignes de champ par des lignes parrallèl
-es, continues, et nous disons que le champ a une certaine intensité, qui
- reste la même tout le long des lignes.
+Ceci représente concrètement les lignes de champs à un endroit donné.
+\end_layout
+
+\begin_layout Standard
+En effet, en physique on représente les lignes de champ par des lignes continues.
  Or dans ce projet, cela ne nous intéresse pas de représenter ces lignes.
  Puisque les seules interactions de ces champs avec les particules invoquent
  des vecteurs représentant l'intensité et la direction du champ à l'endroit
@@ -515,10 +372,10 @@ Question P6.3
 Nous représentons le centre de courbure 
 \family typewriter
 \size small
-centerOfCurvature
+curvatureCenter
 \family default
 \size default
- à l'aide d'un 
+ à l'aide d'un attribut du type 
 \family typewriter
 \size small
 Vector3D
@@ -530,24 +387,7 @@ Vector3D
 k
 \family default
 \size default
- à une fonction statique, qui nous renvoie 
-\series bold
-la
-\series default
- position du centre de courbure (cf.
- constructeur de 
-\family typewriter
-\size small
-curved
-\family default
-\size default
- dans 
-\family typewriter
-\size small
-CurvedElement.cc
-\family default
-\size default
-).
+ au constructeur des éléments courbes.
 \end_layout
 
 \begin_layout Standard
@@ -555,8 +395,8 @@ En effet, le centre de courbure d'une courbe est défini d'une manière unique
  si nous avons :
 \end_layout
 
-\begin_layout Standard
-- une position d'entrée 
+\begin_layout Itemize
+une position d'entrée 
 \family typewriter
 \size small
 entry
@@ -565,8 +405,8 @@ entry
 ;
 \end_layout
 
-\begin_layout Standard
-- une position de sortie 
+\begin_layout Itemize
+une position de sortie 
 \family typewriter
 \size small
 exit
@@ -575,8 +415,8 @@ exit
 ;
 \end_layout
 
-\begin_layout Standard
-- une courbure
+\begin_layout Itemize
+une courbure
 \family typewriter
 \size small
  k
@@ -591,9 +431,9 @@ curvatureRadius
  ) avec son signe !;
 \end_layout
 
-\begin_layout Standard
-- une convention à l'aide de laquelle nous savons, en fonction du signe
- du rayon, de quel côté de l'Element la courbe se courbe.
+\begin_layout Itemize
+une convention à l'aide de laquelle nous savons, en fonction du signe du
+ rayon, de quel côté de l'Element la courbe se courbe.
 \begin_inset Foot
 status open
 
@@ -661,24 +501,24 @@ Question P7.1
 \end_layout
 
 \begin_layout Standard
-La classe
+La classe 
 \family typewriter
 \size small
- Accelerator
+Accelerator
+\family sans
+ 
 \family default
 \size default
- est conçue de manière à ce que les détails d'implémentation soient inexistants,
- tout est dans la partie publique, sauf les attributs dans l'espace 
-\shape italic
-protected
-\shape default
-, afin de pouvoir y avoir accès depuis l'interne.
- Par ailleurs, en ce qui concerne les méthodes de deux ou trois lignes,
- à savoir la plupart, sont déclarées 
-\shape italic
-inline
-\shape default
-.
+un accélerateur.
+ Elle contient une collection de particules et d'élements (en attributs).
+ De plus, nous avons décidé qu'un accélérateur sera entièrement responsable
+ de la gestion de ses particules et elements.
+ Cela implique que lors de l'ajout d'un de ces derniers, il sera copié.
+\end_layout
+
+\begin_layout Standard
+Cette copie entraîne d'eutres conséquences tel que le rajout d'un méthode
+ `clone' dans les éléments et particules.
 \end_layout
 
 \begin_layout Section*
@@ -699,31 +539,16 @@ Accelerator
 
 \begin_layout Standard
 L'opérateur '=' : de même que pour le constructeur de copie, sa déclaration
- en privé empêche la comparaison entre 
-\family typewriter
-\size small
-Accelerator
-\family default
-\size default
-s, puisque cet opérateur a déjà été surchargé pour les 
-\family typewriter
-\size small
-Element
-\family default
-\size default
-s, nous ne voudrions pas de confusion avec la classe 
-\family typewriter
-\size small
-Accelerator
-\family default
-\size default
-, elle-même composée de divers 
-\family typewriter
-\size small
-Element
-\family default
-\size default
-s.
+ en privé empêche la copie d'un accélérateur vers un autre.
+\end_layout
+
+\begin_layout Standard
+Ces restrictions sont présents pour éviter des problèmes de responsabilités
+ d'allocation et de délocation de mémoire (car un accélérateur contient
+ beaucoup de pointeurs d'éléments et de particules qui eux-mêmes pointent
+ vers des particules).
+ Mais aussi d'un point de vue logique: comment serait-ce physiquement possible
+ de copier un accélérateur dans un état donné avec tous ses particules?
 \end_layout
 
 \begin_layout Section*
diff --git a/src/main/Accelerator.h b/src/main/Accelerator.h
index 2fe0b1a..deeaf69 100644
--- a/src/main/Accelerator.h
+++ b/src/main/Accelerator.h
@@ -26,7 +26,7 @@ private :
 	Accelerator (Accelerator const& other) {}
 
 	/** Opérateur '=' ne faisant rien. */
-	void operator= (Accelerator const& other) const {}
+	void operator= (Accelerator const& other) {}
 
 protected:
 
@@ -148,7 +148,7 @@ public:
 			Vector3D a = particle.getForce() / (particle.getGamma() * particle.getMass());
 			particle.setVelocity(particle.getVelocity() + a * dt);
 
-			particle.setPosition(particle.getPosition() + particle.getVelocity() * dt);
+			particle.translate(particle.getVelocity() * dt);
 			particle.setForce(Vector3D::Null);
 
 			if (particle.getElement()->isBeside(particle)) std::cout << "Particle hit wall!" << std::endl;
diff --git a/src/main/Particle.cc b/src/main/Particle.cc
index 405b6b5..230f049 100644
--- a/src/main/Particle.cc
+++ b/src/main/Particle.cc
@@ -33,14 +33,16 @@ Vector3D Particle::getPosition() const {return position;}
 
 void Particle::setPosition(const Vector3D& pos) {position = pos;}
 
+void Particle::translate(const Vector3D& dx) {position += dx;}
+
 Vector3D Particle::getForce() const {return force;}
 
 void Particle::setForce(const Vector3D& f) {force = f;}
 
-void Particle::applyForce(const Vector3D& f) {force = force + f;}
+void Particle::applyForce(const Vector3D& f) {force += f;}
 
 void Particle::applyMagneticForce(const Vector3D& b, double dt) {
-	if (b != Vector3D::Null) {
+	if (dt != 0 && b != Vector3D::Null) {
 		Vector3D f = charge * velocity.cross(b);
 		applyForce(f.rotate(velocity.cross(f), (dt * f.norm()) / (2 * gamma * mass * velocity.norm())));
 	}
diff --git a/src/main/Particle.h b/src/main/Particle.h
index 78ee905..7c16176 100644
--- a/src/main/Particle.h
+++ b/src/main/Particle.h
@@ -26,13 +26,13 @@ class Particle: public Printable, public Cloneable {
 private:
 
 	/** Position de cette particule. [m] */
-	Vector3D position;
+	MutableVector3D position;
 
 	/** Vitesse de cette particule. [m/s] */
-	Vector3D velocity;
+	MutableVector3D velocity;
 
 	/** Force résultante sur cette particule. [N] */
-	Vector3D force;
+	MutableVector3D force;
 
 	/** Masse de cette particule. [kg] */
 	double mass;
@@ -69,6 +69,9 @@ public:
 	/** Affecte la position de cette particule. [m] */
 	void setPosition(const Vector3D& pos);
 
+	/** Translate cette particule. */
+	void translate(const Vector3D& dx);
+
 	/** Retourne la force résultante sur cette particule. [N] */
 	Vector3D getForce() const;
 
diff --git a/src/main/Vector3D.cc b/src/main/Vector3D.cc
index 94952c3..fc7fc2b 100644
--- a/src/main/Vector3D.cc
+++ b/src/main/Vector3D.cc
@@ -86,6 +86,62 @@ Vector3D const Vector3D::j = Vector3D(0.0, 1.0, 0.0);
 //c.f. header
 Vector3D const Vector3D::k = Vector3D(0.0, 0.0, 1.0);
 
+MutableVector3D::MutableVector3D(double _x, double _y, double _z): Vector3D(_x, _y, _z) {};
+MutableVector3D::MutableVector3D(const Vector3D& v): Vector3D(v.getX(), v.getY(), v.getZ()) {};
+
+void MutableVector3D::update() {
+	normCache = -1;
+}
+
+void MutableVector3D::setX(double x) {
+	this->x = x;
+	update();
+}
+
+void MutableVector3D::setY(double y) {
+	this->y = y;
+	update();
+}
+
+void MutableVector3D::setZ(double z) {
+	this->z = z;
+	update();
+}
+
+void MutableVector3D::operator=(const Vector3D& v) {
+	x = v.getX();
+	y = v.getY();
+	z = v.getZ();
+	update();
+}
+
+void MutableVector3D::operator+=(const Vector3D& v) {
+	x += v.getX();
+	y += v.getY();
+	z += v.getZ();
+	update();
+}
+
+void MutableVector3D::operator-=(const Vector3D& v) {
+	x -= v.getX();
+	y -= v.getY();
+	z -= v.getZ();
+	update();
+}
+
+void MutableVector3D::operator*=(double n) {
+	x *= n;
+	y *= n;
+	z *= n;
+	update();
+}
+
+void MutableVector3D::operator/=(double n) {
+	x /= n;
+	y /= n;
+	z /= n;
+}
+
 //c.f. header
 Vector3D operator* (double n, const Vector3D& v) {
 	return v * n;
diff --git a/src/main/Vector3D.h b/src/main/Vector3D.h
index ee7ffcc..21f484f 100644
--- a/src/main/Vector3D.h
+++ b/src/main/Vector3D.h
@@ -21,12 +21,10 @@ namespace vhc {
  *  Ainsi, chaque opération sur un vecteur retourne une nouvelle instance. La
  *  performance ainsi perdue est minimale pour une classe ne contenant que trois
  *  champs.
- *  Les méthodes d'un vecteur sont toutes très simples et implémentées dans le header,
- *  afin d'être développées 'inline' durant la compilation, ce qui est plus rapide.
  */
 class Vector3D: public Printable {
 
-private:
+protected:
 	/** Composante x. */
 	double x;
 
@@ -132,6 +130,42 @@ public:
 
 };
 
+/** Un vecteur mutable de dimension trois. Contrairement a sa super classe, les composantes des instances
+ *  d'un vecteur mutable peuvent varier.
+ *  Bien que le raisonement sur une classe mutable soit plus difficile (i.e. on ne peut pas facilement savoir si quelqu'un l'a
+ *  modifiee), elle peur apporter un gain de performance.
+ *  L'utilisation de cette classe n'est donc pas recommendee sauf pour des cas ou un vecteur changerait tres souvent comme
+ *  les coordonnees d'une particule par exemple. */
+class MutableVector3D: public Vector3D {
+
+private:
+
+	/** Methode pour mettre a jour ce vecteur (reinisialier toute sorte de cache etc...). Appele quand ce vecteur est modifie. */
+	void update();
+
+public:
+
+	MutableVector3D(double _x, double _y, double _z);
+	MutableVector3D(const Vector3D& v);
+
+	/** Assigne une valeur x a la premiere composante de ce vecteur. */
+	void setX(double x);
+
+	/** Assigne une valeur y a la deuxieme composante de ce vecteur. */
+	void setY(double y);
+
+	/** Assigne une valeur z a la deuxieme composante de ce vecteur. */
+	void setZ(double z);
+
+	void operator=(const Vector3D& v);
+
+	void operator+=(const Vector3D& v);
+	void operator-=(const Vector3D& v);
+	void operator*=(double n);
+	void operator/=(double n);
+
+};
+
 /** Surcharge externe de la mutliplication scalaire. */
 Vector3D operator* (double n, const Vector3D& v);
 
diff --git a/src/test/PacticleTest.cc b/src/test/PacticleTest.cc
new file mode 100644
index 0000000..4bc5a59
--- /dev/null
+++ b/src/test/PacticleTest.cc
@@ -0,0 +1,28 @@
+/*
+ * PacticleTest.cc
+ *
+ *  Created on: Apr 25, 2011
+ *      Author: jakob
+ */
+
+#include <iostream>
+#include "constants.h"
+#include "Particle.h"
+#include "Vector3D.h"
+
+using namespace std;
+using namespace vhc;
+using namespace constants;
+
+int main() {
+	Particle p1 = Particle(Vector3D::Null, PROTON_MASS, E, 1 * GeV, Vector3D::i);
+	Particle p2 = Particle(Vector3D(5,3,2), ELECTRON_MASS, E, 1.5 * GeV, Vector3D::j);
+	Particle p3 = p1;
+
+	cout << p1 << endl;
+	cout << p2 << endl;
+	cout << p3 << endl;
+
+
+	return 0;
+}
diff --git a/src/test/Vector3DTest.cc b/src/test/Vector3DTest.cc
index d090682..c9bd3c7 100644
--- a/src/test/Vector3DTest.cc
+++ b/src/test/Vector3DTest.cc
@@ -16,18 +16,37 @@ using namespace std;
 using namespace vhc;
 
 
-bool printTest();
-
 int main() {
-	//equality test
-	assert(Vector3D(1, 2, 3) == Vector3D(1, 2, 3));
-	assert(Vector3D(1, 2.4, 3) != Vector3D(1, 2, 3));
+	Vector3D vect1(1.0, 2, -0.1);
+	Vector3D vect2(2.6, 3.5, 4.1);
+	Vector3D vect3 = vect1;
+
+	cout << "Vecteur 1 :";
+	cout << vect1;
+
+	cout << "Vecteur 2 :";
+	cout << vect2;
+
+	cout << "Le vecteur 1 est ";
+	if (Vector3D::ae(vect1, vect2)) {
+	    cout << "egal au";
+	} else {
+	    cout << "différent du";
+	}
+	cout << " vecteur 2," << endl << "et est";
+	if (Vector3D::ae(vect1, vect3)) {
+	    cout << "egal au";
+	} else {
+	    cout << "différent du";
+	}
+	cout << " vecteur 3." << endl;
+
 
 	//addition test
-	assert(Vector3D(1, -0.9, 57683) + Vector3D(-1, 0.9, -57683) == Vector3D::Null);
+	assert(Vector3D::ae(Vector3D(1, -0.9, 57683) + Vector3D(-1, 0.9, -57683), Vector3D::Null));
 
 	//addition, multiplication test
-	assert(Vector3D(4, 0, 16) / 4 == -Vector3D(0.25, 0, 1) * -4);
+	assert(Vector3D::ae(Vector3D(4, 0, 16) / 4, -Vector3D(0.25, 0, 1) * -4));
 
 	//length test
 	assert(Vector3D(0,3,4).norm() == 5);
@@ -50,17 +69,3 @@ int main() {
 
 	return 0;
 }
-
-bool printTest() {
-	cout << "PRINT TEST" << endl;
-	cout << Vector3D(1,2,3) << endl;
-	char answer;
-	do {
-		cout << "Was 'Vector3D(1,2,3)' displayed? (y/n)" << endl;
-		cin >> answer;
-	} while (answer != 'y' && answer != 'n');
-	cout << "END PRINT TEST" << endl;
-
-	if (answer == 'y') return true;
-	else return false;
-}