Migration de tous les implementations dans les fichier .h vers les fichiers .cc

1 files changed, 23 insertions, 39 deletions

diff --git a/src/main/Vector3D.h b/src/main/Vector3D.h
index a7764df..c4935e2 100644
--- a/src/main/Vector3D.h
+++ b/src/main/Vector3D.h
@@ -10,7 +10,7 @@
 
 #include <sstream>
 #include <math.h>
-#include "exception.h"
+#include "exceptions.h"
 #include "Printable.h"
 
 namespace vhc {
@@ -48,87 +48,71 @@ public:
 	 *  @param _y 2e composante
 	 *  @param _z 3e composante
 	 */
-	Vector3D(double _x, double _y, double _z) : x(_x), y(_y), z(_z), normCache(-1) {};
+	Vector3D(double _x, double _y, double _z);
 
 	/** Retourne la composante x de ce vecteur. */
-	double getX() const {return x;};
+	double getX() const;
 
 	/** Retourne la composante y de ce vecteur. */
-	double getY() const {return y;};
+	double getY() const;
 
 	/** Retourne la composante z de ce vecteur. */
-	double getZ() const {return z;};
+	double getZ() const;
 
 	/** Vérifie si ce vecteur et le vecteur <code>v</code> sont égaux, i.e. qu'ils ont les mêmes composantes. */
-	bool operator== (const Vector3D& v) const {return x == v.x && y == v.y && z == v.z;};
+	bool operator== (const Vector3D& v) const;
 
 	/** Vérifie si ce vecteur et le vecteur <code>v</code> sont différents, i.e. qu'ils ont des composantes différentes. */
-	bool operator!= (const Vector3D& v) const {return !((*this) == (v));};
+	bool operator!= (const Vector3D& v) const;
 
 	/** Addition de vecteurs. Retourne un nouveau vecteur résultant de l'addition de ce vecteur avec <code>v</code>. */
-	Vector3D operator+ (const Vector3D& v) const {return Vector3D(x + v.x, y + v.y, z + v.z);};
+	Vector3D operator+ (const Vector3D& v) const;
 
 	/** Multiplication scalaire. Retourne un nouveau vecteur résultant de la multiplication de ce vecteur par <code>n</code>. */
-	Vector3D operator* (double n) const {return Vector3D(x * n, y * n, z * n);};
+	Vector3D operator* (double n) const;
 
 	/** Retourne l'opposé de ce vecteur. */
-	Vector3D operator-() const {return (*this) * (-1.0);};
+	Vector3D operator-() const;
 
 	/** Soustraction de vecteurs. Retourne un nouveau vecteur résultant de la soustraction de ce vecteur avec <code>v</code>. */
-	Vector3D operator- (const Vector3D& v) const {return (*this) + -v;};
+	Vector3D operator- (const Vector3D& v) const;
 
 	/** Division scalaire. Retourne un nouveau vecteur résultant de la division de ce vecteur par <code>n</code>. */
-	Vector3D operator/ (double n) const {return (*this) * (1.0 / n) ;};
+	Vector3D operator/ (double n) const;
 
 	/** Produit scalaire. Retourne le produit scalaire de ce vecteur avec le vecteur <code>v</code>. */
-	double dot(const Vector3D& v) const {return x * v.x + y * v.y + z * v.z;};
+	double dot(const Vector3D& v) const;
 
 	/** Produit vectoriel. Retourne le produit vectoriel direct (main droite) de ce vecteur avec le vecteur <code>v</code>.
 	 *  Nous avons decidé de ne pas utiliser l'operateur `^' pour représenter le produit vectoriel car sa précédence est plus
 	 *  basse que toutes autres opérations binaires sur les vecteurs.
 	 */
-	Vector3D cross(const Vector3D& v) const {return Vector3D(y * v.z - v.y * z, v.x * z - x * v.z, x * v.y - v.x * y);};
+	Vector3D cross(const Vector3D& v) const;
 
 	/** Vecteur unitaire de ce vecteur. */
-	Vector3D operator~() const {
-		if (norm() != 0.0) return (*this) / norm();
-		else throw UnsupportedOperationException("Zero vector does not have a unit vector.");
-	};
+	Vector3D operator~() const;
+
 	/** Retourne le vecteur unitaire */
-	Vector3D unit() const {return ~(*this);}
+	Vector3D unit() const;
 
 	/** Retourne la norme du vecteur. */
-	double norm() const {
-		if (normCache == -1) normCache = sqrt(dot(*this));
-		return normCache;
-	}
+	double norm() const;
 
 	/** Retourne la norme du vecteur au carre. */
-	double normSquare() const {return dot(*this);}
+	double normSquare() const;
 
 	/** Retourne une représentation en chaîne de caractères de ce vecteur. */
-	virtual std::string toString() const {
-		std::stringstream s;
-		s << "(" << x << ", " << y << ", " << z << ")";
-		return s.str();
-	};
+	virtual std::string toString() const;
 
-	double angle(const Vector3D& v) const {return acos(dot(v) / norm() / v.norm());}
+	double angle(const Vector3D& v) const;
 
 	/** Produit mixte de 3 vecteurs. Retourne le produit scalaire de ce vecteur
 	 * 	avec le produit vectoriel de deux vecteurs <code>v</code> et <code>w</code>). */
-	double tripleProduct(const Vector3D& v, const Vector3D& w) const { return dot(v.cross(w)); }
+	double tripleProduct(const Vector3D& v, const Vector3D& w) const;
 
 	/** Rotation vectorielle. Retourne le vecteur courant, évalué dans la formule en <code>a</code>,
 	 * le vecteur de l'axe, et en <code>t</code>, l'angle de rotation. */
-	Vector3D rotate(const Vector3D& axis, double t) const {
-		const Vector3D& x = *this;
-		const Vector3D& a = ~axis;
-
-		//cos(t) x + ( 1-cos(t) ) (x*a) a + sin(t) a ^ x
-
-		return x * cos(t) + a * x.dot(a) * (1-cos(t)) +  a.cross(x) * sin(t);
-	}
+	Vector3D rotate(const Vector3D& axis, double t) const;
 
 	/** Vecteur nul. (0,0,0) */
 	static const Vector3D Null;