5 files changed, 105 insertions, 10 deletions

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);