/* * Vector3D.h * * Created on: Mar 1, 2011 * Author: Jakob Odersky */ #ifndef VECTOR3D_H_ #define VECTOR3D_H_ #include #include "Printable.h" namespace vhc { /** 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 opération sur un vecteur retourne une nouvelle instance. La * performance ainsi perdue est minimale pour une classe ne contenant que trois * champs. */ class Vector3D: public Printable { protected: /** Composante x. */ double x; /** Composante y. */ double y; /** Composante z. */ double z; /** Cache de norme. (-1 si pas encore calcule) */ mutable double normCache; public: /** Crée une nouvelle instance de Vector3D. * @param _x 1e composante * @param _y 2e composante * @param _z 3e composante */ Vector3D(double _x, double _y, double _z); /** Retourne la composante x de ce vecteur. */ double getX() const; /** Retourne la composante y de ce vecteur. */ double getY() const; /** Retourne la composante z de ce vecteur. */ double getZ() const; /** Vérifie si ce vecteur et le vecteur v sont égaux, i.e. qu'ils ont les mêmes composantes. */ bool operator== (const Vector3D& v) const; /** Vérifie si ce vecteur et le vecteur v sont différents, i.e. qu'ils ont des composantes différentes. */ bool operator!= (const Vector3D& v) const; /** Addition de vecteurs. Retourne un nouveau vecteur résultant de l'addition de ce vecteur avec v. */ Vector3D operator+ (const Vector3D& v) const; /** Multiplication scalaire. Retourne un nouveau vecteur résultant de la multiplication de ce vecteur par n. */ Vector3D operator* (double n) const; /** Retourne l'opposé de ce vecteur. */ Vector3D operator-() const; /** Soustraction de vecteurs. Retourne un nouveau vecteur résultant de la soustraction de ce vecteur avec v. */ Vector3D operator- (const Vector3D& v) const; /** Division scalaire. Retourne un nouveau vecteur résultant de la division de ce vecteur par n. */ Vector3D operator/ (double n) const; /** Produit scalaire. Retourne le produit scalaire de ce vecteur avec le vecteur v. */ double dot(const Vector3D& v) const; /** Produit vectoriel. Retourne le produit vectoriel direct (main droite) de ce vecteur avec le vecteur v. * 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; /** Vecteur unitaire de ce vecteur. */ Vector3D operator~() const; /** Retourne le vecteur unitaire */ Vector3D unit() const; /** Retourne la norme euclidienne du vecteur. */ double norm() const; /** Retourne la norme de ce vecteur correspondant au minimum des composantes. */ double minNorm() const; /** Retourne la norme du vecteur au carre. */ double normSquare() const; /** Retourne une représentation en chaîne de caractères de ce vecteur. */ virtual std::string toString() const; 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 v et w). */ double tripleProduct(const Vector3D& v, const Vector3D& w) const; /** Rotation vectorielle. Retourne le vecteur courant, évalué dans la formule en a, * le vecteur de l'axe, et en t, l'angle de rotation. */ Vector3D rotate(const Vector3D& axis, double t) const; /** Verifie si les vecteurs u et v sont approximativement égaux, i.e. que la norme de leur difference est plus petit qu'un epsilon. */ static bool ae(const Vector3D& u, const Vector3D& v, double epsilon = std::numeric_limits::epsilon()); /** Vecteur nul. (0,0,0) */ static const Vector3D Null; /** Vecteur unitaire, d'axe x. (1, 0, 0) */ static const Vector3D i; /** Vecteur unitaire, d'axe y. (0, 1, 0) */ static const Vector3D j; /** Vecteur unitaire, d'axe z. (0, 0, 1) */ static const Vector3D k; }; /** 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); } // namespace #endif /* VECTOR3D_H_ */