Implémenté une méthode rotation vectorielle, à optimiser.

Rajouté les accents dans les commentaires, mis à jour le journal.
Subsiste une erreur dans le fichier Particule.h.

6 files changed, 65 insertions, 57 deletions

diff --git a/src/main/Element.h b/src/main/Element.h
index 7d4eb23..b49de64 100644
--- a/src/main/Element.h
+++ b/src/main/Element.h
@@ -16,22 +16,22 @@ namespace vhc {
 class Element {
 
 private:
-	/** Empeche la copie d'elements et facilite ainsi la gestion de pointeurs.
-	 *  Pourquoi aurait-on besoin de copier un element? */
+	/** Empêche la copie d'éléments et facilite ainsi la gestion de pointeurs.
+	 *  Pourquoi aurait-on besoin de copier un élément? */
 	Element(const Element& e);
 
 protected:
 
-	/** Position du centre de la face d'entree. */
+	/** Position du centre de la face d'entrée. */
 	Vector3D entryPosition;
 
 	/** Position du centre de la face de sortie. */
 	Vector3D exitPosition;
 
-	/** Rayon de la chambre a vide. */
+	/** Rayon de la chambre à vide. */
 	double radius;
 
-	/** Pointeur sur l'element suivant. */
+	/** Pointeur sur l'élément suivant. */
 	Element *next;
 
 public:
diff --git a/src/main/Makefile b/src/main/Makefile
index f992fbd..44160be 100644
--- a/src/main/Makefile
+++ b/src/main/Makefile
@@ -1,37 +1,37 @@
 #########################################################################
-#                         Makefile recursif                             #
+#                         Makefile récursif                             #
 #=======================================================================#
-# Les variables suivantes sont definis dans un makefile plus haut.      #
-# BASEDIR   repertoire de base du projet                                #
-# SRCDIR    repertoire contenant le code source                         #
-# BINDIR    repertoire ou sont places toutes objets compiles            #
+# Les variables suivantes sont définies dans un makefile plus haut.     #
+# BASEDIR   répertoire de base du projet                                #
+# SRCDIR    répertoire contenant le code source                         #
+# BINDIR    répertoire où sont placés tous les objets compilé           #
 #########################################################################
 
-# Nom du repertoire contenant ce makefile
+# Nom du répertoire contenant ce makefile
 LOCALDIR = main
 
-# ==> Ajouter ici les objets a compiler
-# Si un objet necessite une compilation non-standard (i.e. pas de regle du style Foo.o : Foo.cc Foo.h), rajouter
-# cette regle.
+# ==> Ajouter ici les objets à compiler
+# Si un objet nécessite une compilation non-standard (i.e. pas de règle du style Foo.o : Foo.cc Foo.h), rajouter
+# cette règle.
 LOCALOBJS = Vector3D.o Particle.o Printable.o Element.o
 OBJS=$(addprefix $(BINDIR)/$(LOCALDIR)/,$(LOCALOBJS))
 .PHONY = lib
 
 all: checkdirs lib
 
-# Verifie l'existance du repertoire de sortie
+# Vérifie l'existence du répertoire de sortie
 checkdirs: $(BINDIR)/$(LOCALDIR)
 
-# Cree le repertoire de sortie
+# Crée le répertoire de sortie
 $(BINDIR)/$(LOCALDIR):
 	@mkdir -p $@
 
-# Cree une librairie statique des fichiers objets 
+# Crée une librairie statique des fichiers objets 
 lib: $(OBJS)
 	@echo "Packing library..."
 	ar rcs $(BINDIR)/$(LOCALDIR)/libvhc.a $(OBJS)
 	@echo "Done packing library."  
 
-# Regle implicite qui modifie le repertoire de destination des fichiers .o
+# Règle implicite qui modifie le répertoire de destination des fichiers .o
 $(BINDIR)/$(LOCALDIR)/%.o: %.cc
 	$(CXX) $(CXXFLAGS) -c $< -o $@
\ No newline at end of file
diff --git a/src/main/Particle.h b/src/main/Particle.h
index 418a192..d5a600d 100644
--- a/src/main/Particle.h
+++ b/src/main/Particle.h
@@ -16,7 +16,7 @@
 
 namespace vhc {
 
-/** Classe representant une particule.
+/** Classe représentant une particule.
  * TODO poser question sur l'energie, gamma, qdm*/
 class Particle: public Printable {
 
@@ -28,10 +28,10 @@ private:
 	/** Vitesse de cette particule. */
 	Vector3D velocity;
 
-	/** Force resultante sur cette particule. */
+	/** Force résultante sur cette particule. */
 	Vector3D force;
 
-	/** Masse de cette particlue. */
+	/** Masse de cette particule. */
 	double mass;
 
 	/** Charge de cette particule. */
@@ -57,7 +57,7 @@ public:
 		mass(mass),
 		charge(charge) {
 
-		velcocity = constants::c * sqrt(1 - (mass * mass) / (energy * energy));
+		velocity = constants::c * sqrt(1 - (mass * mass) / (energy * energy));
 	};
 
 
@@ -67,10 +67,10 @@ public:
 	/** Affecte la position de cette particule. */
 	void setPosition(const Vector3D& pos) {position = pos;}
 
-	/** Retourne la force resultante sur cette particule. */
+	/** Retourne la force résultante sur cette particule. */
 	Vector3D getForce() const {return force;}
 
-	/** Affecte la force resultante sur cette particule. */
+	/** Affecte la force résultante sur cette particule. */
 	void setForce(const Vector3D& f) {force = f;}
 
 	/** Applique une force sur cette particule. */
@@ -90,7 +90,7 @@ public:
 
 	double getGamma() const {return energy / (mass * constants::c2);}
 
-	/** Retourne une representation en chaine de cette particule. */
+	/** Retourne une représentation en chaîne de cette particule. */
 	std::string toString() const {
 		std::stringstream s;
 		s << "Particle:"	<< "\n";
diff --git a/src/main/Printable.h b/src/main/Printable.h
index 1baf4bf..5dd030c 100644
--- a/src/main/Printable.h
+++ b/src/main/Printable.h
@@ -12,17 +12,17 @@
 
 namespace vhc {
 
-/** Classes abstraite heritee par tout objet imprimable. */
+/** Classe abstraite héritée par tout objet imprimable. */
 class Printable {
 
 public:
 
-	/** Retourne une representation en chaine de cet objet imprimable. */
+	/** Retourne une représentation en chaîne de caractères de cet objet imprimable. */
 	virtual std::string toString() const = 0;
 
 };
 
-/** Ajoute la representation en chaine de <code>p</code> a <code>output</code>. */
+/** Ajoute la représentation en chaîne de <code>p</code> à <code>output</code>. */
 std::ostream& operator<< (std::ostream& output, const Printable& p);
 
 }
diff --git a/src/main/Vector3D.h b/src/main/Vector3D.h
index 70effef..d22787a 100644
--- a/src/main/Vector3D.h
+++ b/src/main/Vector3D.h
@@ -16,17 +16,18 @@
 
 namespace vhc {
 
-/** Un vecteur de dimension trois. Les instances de cette classes sont completement
- *  invariables, c'est-a-dire un vecteur une fois initialise, ses composantes ne
- *  peuvent plus etres modifies.
- *  Le fait qu'un vecteur ne possede pas d'etat, facilite le raisonement et parait
+/** Un vecteur de dimension trois. Les instances de cette classes sont complètement
+ *  invariables, c'est-à-dire qu'un vecteur une fois initialisé, ses composantes ne
+ *  peuvent plus êtres modifiées.
+ *  Le fait qu'un vecteur ne possède pas d'état, facilite le raisonnement et paraît
  *  surtout naturel.
- *  Ainsi, chaque operation sur un vecteur retourne une nouvelle instance. La
- *  performance perdue ainsi est minimale pour une classe ne contenant que trois
+ *  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 methodes d'un vecteur sont toutes tres simples et implementes dans le header
- *  afin d'etre developpes 'inline' durant la compilation et ainsi d'etre plus rapides.
- *  TODO ! definir la rotation d'un vecteur autour d'un autre vecteur
+ *  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.
+ *  TODO ! définir la matrice de rotation d'un vecteur autour d'un autre vecteur (Faire un typedef?),
+ *  		puis une méthode de multiplication matrice-vecteur, ce serait plus joli.
  */
 class Vector3D: public Printable {
 
@@ -42,7 +43,7 @@ private:
 
 public:
 
-	/** Cree une nouvelle instance de <code>Vector3D</code>.
+	/** Crée une nouvelle instance de <code>Vector3D</code>.
 	 *  @param _x 1e composante
 	 *  @param _y 2e composante
 	 *  @param _z 3e composante
@@ -58,33 +59,33 @@ public:
 	/** Retourne la composante z de ce vecteur. */
 	double getZ() const {return z;};
 
-	/** Verifie si ce vecteur et le vecteur <code>v</code> sont eqaux, i.e. qu'ils ont les memes composantes. */
+	/** Vérifie si ce vecteur et le vecteur <code>v</code> sont éqaux, 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;};
 
-	/** Verifie si ce vecteur et le vecteur <code>v</code> sont differents, i.e. qu'ils ont des composantes differentes. */
+	/** 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));};
 
-	/** Addition de vecteurs. Retourne un nouveau vecteur resultant de l'addition de ce vecteur avec <code>v</code>. */
+	/** 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);};
 
-	/** Multiplication scalaire. Retourne un nouveau vecteur resultant de la multiplication de ce vecteur par <code>n</code>. */
+	/** 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);};
 
-	/** Retourne l'oppose de ce vecteur. */
+	/** Retourne l'opposé de ce vecteur. */
 	Vector3D operator-() const {return (*this) * (-1.0);};
 
-	/** Soustraction de vecteurs. Retourne un nouveau vecteur resultant de la soustraction de ce vecteur avec <code>v</code>. */
+	/** 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;};
 
-	/** Division scalaire. Retourne un nouveau vecteur resultant de la division de ce vecteur par <code>n</code>. */
+	/** 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) ;};
 
 	/** 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;};
 
-	/** Produit vectoriel. Retourne le produit vectoriel directe (main droite) de ce vecteur avec le vecteur <code>v</code>.
-	 *  Nous avons decide de ne pas utiliser l'operateur `^' pour representer le produit vectoriel car sa precedence est plus
-	 *  basse que toutes autres operations binaires sur les vecteurs.
+	/** 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);};
 
@@ -93,23 +94,30 @@ public:
 		if (getNorm() != 0.0) return (*this) / getNorm();
 		else throw std::domain_error("Zero vector does not have a unit vector.");
 	};
-	/** retourne le vecteur unitaire */
+	/** Retourne le vecteur unitaire */
 	Vector3D getUnit() const {return ~(*this);}
 
 	/** Retourne la norme du vecteur. */
 	double getNorm() const {return sqrt(dot(*this));};
 
-	/** Retourne une representation en chaine de ce vecteur. */
+	/** Retourne une représentation en chaîne de caractères de ce vecteur. */
 	std::string toString() const {
 		std::stringstream s;
 		s << "Vector3D(" << x << ", " << y << ", " << z << ")";
 		return s.str();
 	};
 
-	/** Retourne le produit mixte de 3 vecteurs (Le vecteur fait un produit scalaire
-	 * 	avec le produit vectoriel de deux vecteurs passes en argument). */
-	double tripleProduct(const Vector3D& v, const Vector3D& w) const {
-		return dot(v.cross(w));
+	/** 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)); }
+
+	/** Rotation vectorielle. Retourne le produit de ce vecteur avec la matrice de rotation
+	 * (d'angle <code>theta</code>, de direction donnée par le vecteur <code>d</code>).
+	 * Source : http://upload.wikimedia.org/math/5/1/f/51f1345467a490f41539fdedf9c4b8da.png */
+	Vector3D rotate(const Vector3D& d,const double& theta) const {
+		return Vector3D(((~d).x*(~d).x+(1-(~d).x*(~d).x)*cos(theta))*x+((~d).x*(~d).y*(1-cos(theta))-(~d).z*sin(theta))*y+((~d).x*(~d).z*(1-sin(theta))+(~d).y*sin(theta))*z,
+						((~d).x*(~d).y*(1-cos(theta))+(~d).z*sin(theta))*x+((~d).y*(~d).y+(1-(~d).y*(~d).y)*cos(theta))*y+((~d).y*(~d).z*(1-sin(theta))-(~d).x*sin(theta))*z,
+						((~d).x*(~d).z*(1-sin(theta))-(~d).y*sin(theta))*x+((~d).y*(~d).z*(1-sin(theta))+(~d).x*sin(theta))*y+((~d).z*(~d).z+(1-(~d).z*(~d).z)*cos(theta))*z);
 	}
 
 	/** Vecteur nul. (0,0,0) */
diff --git a/src/main/constants.h b/src/main/constants.h
index 94e1f20..df2afe6 100644
--- a/src/main/constants.h
+++ b/src/main/constants.h
@@ -13,13 +13,13 @@ namespace vhc {
 /** Contient des constantes physiques. */
 namespace constants {
 
-/** Vitesse de la lumiere dans le vide [m/s]. */
+/** Vitesse de la lumière dans le vide [m/s]. */
 const double c = 299792458;
 
-/** Vitesse de la lumiere dans le vide au caree [m/s]. */
+/** Vitesse de la lumière dans le vide au carré [m/s]. */
 const double c2 = c * c;
 
-/** Charge elementaire [C]. */
+/** Charge élémentaire [C]. */
 const double e = 1.60217653E-19;
 
 }