Complété le fichier réponses, crée la classe courbe, modifié la fonction rotation vectorielle.

5 files changed, 63 insertions, 11 deletions

diff --git a/src/main/Courbe.cc b/src/main/Courbe.cc
new file mode 100644
index 0000000..4318c97
--- /dev/null
+++ b/src/main/Courbe.cc
@@ -0,0 +1,21 @@
+/*
+ * Courbe.cc
+ *
+ *  Created on: 21 mars 2011
+ *      Author: christian
+ */
+
+#include "Courbe.h"
+
+namespace vhc {
+
+Courbe::Courbe(): courbureCenter(0,0,0) {
+	// TODO Auto-generated constructor stub
+
+}
+
+Courbe::~Courbe() {
+	// TODO Auto-generated destructor stub
+}
+
+}
diff --git a/src/main/Courbe.h b/src/main/Courbe.h
new file mode 100644
index 0000000..b316632
--- /dev/null
+++ b/src/main/Courbe.h
@@ -0,0 +1,28 @@
+/*
+ * Courbe.h
+ *
+ *  Created on: 21 mars 2011
+ *      Author: christian
+ */
+
+#ifndef COURBE_H_
+#define COURBE_H_
+
+#include<Element.h>
+
+namespace vhc {
+
+class Courbe : public Element {
+protected:
+	/** Postion de centre de courbure
+	 * (rayon de courbure implicite). */
+	Vector3D courbureCenter;
+
+public:
+	Courbe();
+	virtual ~Courbe();
+};
+
+}
+
+#endif /* COURBE_H_ */
diff --git a/src/main/Element.h b/src/main/Element.h
index b49de64..754287f 100644
--- a/src/main/Element.h
+++ b/src/main/Element.h
@@ -34,12 +34,20 @@ protected:
 	/** Pointeur sur l'élément suivant. */
 	Element *next;
 
+	/** Intensité (constante) du champ.
+	 * TODO à améliorer */
+	double fieldIntensity;
+
+	/** Direction du champ magnétique, invariant dans l'espace. */
+	Vector3D fieldDirection;
+
 public:
 	Element();
 	virtual ~Element();
 
 	virtual bool isOutside(const Particle& p) const = 0;
 
+	/* TODO Et si la valeur de retour était un pointeur? */
 	virtual bool isPast(const Particle& p) const = 0;
 
 	Vector3D getEntryPosition() const {return entryPosition;}
diff --git a/src/main/Vector3D.h b/src/main/Vector3D.h
index d22787a..f601c89 100644
--- a/src/main/Vector3D.h
+++ b/src/main/Vector3D.h
@@ -26,8 +26,6 @@ namespace vhc {
  *  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.
- *  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 {
 
@@ -59,7 +57,7 @@ public:
 	/** Retourne la composante z de ce vecteur. */
 	double getZ() const {return z;};
 
-	/** Vérifie si ce vecteur et le vecteur <code>v</code> sont éqaux, i.e. qu'ils ont les mêmes composantes. */
+	/** 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;};
 
 	/** Vérifie si ce vecteur et le vecteur <code>v</code> sont différents, i.e. qu'ils ont des composantes différentes. */
@@ -111,13 +109,10 @@ public:
 	 * 	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);
+	/** 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& a,const double& t) const {
+		return ((cos(t)*this)+((1-cos(t))*((this->dot((~a)))*this))+(sin(t)*((~a).cross(this))));
 	}
 
 	/** Vecteur nul. (0,0,0) */
diff --git a/src/test/Vector3DTest.cc b/src/test/Vector3DTest.cc
index fe3120f..2ad92ad 100644
--- a/src/test/Vector3DTest.cc
+++ b/src/test/Vector3DTest.cc
@@ -25,7 +25,7 @@ int main() {
 	//addition test
 	assert(Vector3D(1, -0.9, 57683) + Vector3D(-1, 0.9, -57683) == Vector3D::Null);
 
-	//addition, mutliplication test
+	//addition, multiplication test
 	assert(Vector3D(4, 0, 16) / 4 == -Vector3D(0.25, 0, 1) * -4);
 
 	//length test