1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
/*
* Vector3D.h
*
* Created on: Mar 1, 2011
* Author: Jakob Odersky
*/
#ifndef VECTOR3D_H_
#define VECTOR3D_H_
#include <iostream>
#include <sstream>
#include <math.h>
#include <stdexcept>
#include "Printable.h"
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
* surtout naturelle.
* Ainsi, chaque operation sur un vecteur retourne une nouvelle instance. La
* performance perdue ainsi est minimale pour une classe ne contenant que trois
* champs.
*/
class Vector3D: public Printable {
private:
/** Composante x. */
double x;
/** Composante y. */
double y;
/** Composante z. */
double z;
public:
/** Cree une nouvelle instance de <code>Vector3D</code>.
* @param _x 1e composante
* @param _y 2e composante
* @param _z 3e composante
*/
Vector3D(double _x, double _y, double _z) : x(_x), y(_y), z(_z) {};
/** Retourne la composante x de ce vecteur. */
double getX() const {return x;};
/** Retourne la composante y de ce vecteur. */
double getY() const {return y;};
/** 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. */
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. */
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>. */
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>. */
Vector3D operator* (double n) const {return Vector3D(x * n, y * n, z * n);};
/** Retourne l'oppose 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>. */
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>. */
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.
*/
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);};
/** Vecteur unitaire de ce vecteur. */
Vector3D operator~() const {
if (getNorm() != 0.0) return (*this) / getNorm();
else throw std::domain_error("Zero vector does not have a unit vector.");
};
/** 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. */
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 passés en argument)*/
double tripleproduct(const Vector3D& v, const Vector3D& w) const;
/** 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;
};
Vector3D operator* (double n, const Vector3D& v);
} // namespace
#endif /* VECTOR3D_H_ */
|
