UniverseSimulator/Vecteur.java at master · Bobavince/UniverseSimulator · GitHub

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
/** Classe gérant les vecteurs 3 lignes 1 colonne, pour toutes les opérations courantes.
 * Note : le programme ne devrait pas se servir des composantes sur Z.
 */
public class Vecteur{

	private double[] vect = new double[3];

	/** Constructeur d'un vecteur
	 * @param x : la composante sur X
	 * @param y : la composante sur Y
	 * @param z : la composante sur Z
	 */
	public Vecteur(double x, double y, double z){
		vect[0] = x;
		vect[1] = y;
		vect[2] = z;
	}

	/** Getteur du vecteur sous forme de tableau de double
	 * @return le tableau de double représentant le vecteur
	 */
	public double[] getTabVecteur(){
		return vect;
	}

	/** Setteur de composante pour un vecteur
	 * @param composante : 0, 1 ou 2 (ne fait rien sinon)
	 * @param a : la valeur à appliquer à la composante
	 */
	public void setComposante(int composante,double a){
		if(composante==0 || composante==1 || composante==2){
			vect[composante] = a;
		}
	}

	/** Méthode standard de comparaison de vecteurs entres eux.
	 * @param param : Veteur à comparer
	 * @return un boolean, true si les vecteurs sont identiques, false sinon.
	 */
	public boolean equals(Vecteur param){
		boolean res = false;
		if (param != null){
			res = (vect[0] == param.getTabVecteur()[0])
					&& (vect[1] == param.getTabVecteur()[1])
					&& (vect[2] == param.getTabVecteur()[2]);
		}
		return res;
	}

	/* Méthode standard du Vecteur
	 */
	public String toString(){
		return "("+vect[0]+","+vect[1]+","+vect[2]+")";
	}

	/** Méthode effectuant une addition d'un vecteur avec celui passé en paramètre, renvoyé sous forme d'un troisième vecteur
	 * @param param : le vecteur à additioner
	 * @return le vecteur somme
	 */
	public Vecteur addition(Vecteur param){ // Vecteur ou void ? modif irr�versible du vecteur ?
		Vecteur res = new Vecteur(0,0,0);
		if (param != null){
			res.setComposante(0, vect[0] + param.getTabVecteur()[0]);
			res.setComposante(1, vect[1] + param.getTabVecteur()[1]);
			res.setComposante(2, vect[2] + param.getTabVecteur()[2]);
		}
		return res;
	}

	/** Méthode effectuant une soustraction d'un vecteur avec celui passé en paramètre, renvoyé sous forme d'un troisième vecteur
	 * @param param : le vecteur à soustraire
	 * @return le vecteur différence
	 */
	public Vecteur soustraction(Vecteur param){
		Vecteur res = new Vecteur(0,0,0);
		if (param != null){
			res.setComposante(0, vect[0] - param.getTabVecteur()[0]);
			res.setComposante(1, vect[1] - param.getTabVecteur()[1]);
			res.setComposante(2, vect[2] - param.getTabVecteur()[2]);
		}
		return res;
	}

	/** Méthode effectuant la multiplication des composantes d'un vecteur par un scalaire
	 * @param a : le scalaire qui multipliera le vecteur résultat
	 * @return : le vecteur multiplié
	 */
	public Vecteur multScalaire(double a){
		Vecteur res = new Vecteur(vect[0]*a, vect[1]*a, vect[2]*a);
		return res;
	}

	/** Méthode effectuant un produit scalaire sur deux vecteurs et renvoyant le résultat en double.
	 * @param param : le vecteur qui sera le second memebre du produit scalaire
	 * @return le résultat du produit scalaire sous forme de double.
	 */
	public double prodScalaire(Vecteur param){
		double res =0;
		if (param != null){
			res = vect[0]*param.getTabVecteur()[0]
					+ vect[1]*param.getTabVecteur()[1]
							+ vect[2]*param.getTabVecteur()[2];
		}
		return res;
	}

	/** Méthode de calcul du module d'un vecteur au carré (sans utilisation de pow)
	 * @return : la norme du vecteur au carré
	 */
	public double moduleCarre(){
		return vect[0]*vect[0] + vect[1]*vect[1] + vect[2]*vect[2];
	}

	/** Méthode renvoyant le module d'un vecteur. (avec sqrt)
	 * @return : la norme du vecteur
	 */
	public double module(){
		return Math.sqrt(this.moduleCarre());
	}

	/** Méthode normalisant un vecteur (le divisant par sa norme)
	 * @return : le vecteur normalisé
	 */
	public Vecteur normalise(){
		return this.multScalaire(1/this.module());
	}

}