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.

7 files changed, 66 insertions, 57 deletions

diff --git a/JOURNAL.txt b/JOURNAL.txt
index 89395f3..4caff6a 100644
--- a/JOURNAL.txt
+++ b/JOURNAL.txt
@@ -6,3 +6,4 @@
 [10/03/2011 jakob] Definition de la classe particule.
 [12/03/2011 jakob] Mise en place d'un systeme de makefiles recursifs. Le makefile principale appelle des makefiles dans les differents repertoires source. Voir document "structure.pdf" pour plus de detailles.
 [13/03/2011 jakob] Creation d'un systeme de test automatise. Les fichiers test compiles sont executes par un script shell et leur valeur de retour. Ce script est aussi appele par make, via la command `make test'.
+[../03/2011 christian] Premiers widgets (boutons, fenêtres, curseurs) sous QT.
\ No newline at end of file
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;
 
 }