boost::numeric::ublas::vector pour de la physique

Version imprimable

09/08/2012, 18h46
killwin

boost::numeric::ublas::vector pour de la physique
Bonjour,

J'aurais deux questions,

la première c'est comment différencier les vecteurs classiques du std et ceux de boost en utilisant using namespace pour les deux ?

par exemple j'ai ça :

std::vector<string> a;
boost::numeric::ublas::vector<float> b;
______

question 2, je trouve mon code pas très lisible, je débute avec ce genre de vecteurs pour faire de la physique :

Quand j'aditionne deux vecteurs en 3D par exemple j'écris ça :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 vector<float> a(3); vector<float> b(3); vector<float> c(3); a(0) = 3.2f; a(1) = 2.2f; a(2) = 1.0f; b(0) = 3.2f; b(1) = 4.5f; b(2) = 1.4f; c = a + b;
, qui est un peu lourd je trouve et on ne retrouve pas du tout les x, y, z de la physique. Je suis sur qu'on peut écrire plus simplement et qu'il y a un truc qui m'échappe surtout niveau déclaration.

Merci d'avance

Créer une classe pour te simplifier la vie en surchargeant les opérateurs que tu as besoin (operator+ dans ton cas)
Voici le debut:

Code:

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
#ifndef VECTOR3_HPP
#define VECTOR3_HPP
 
#include <ostream>
 
 
/// Container for 3 value
template <class T>
class Vector3
{
public:
 
	/// x
	T x;
 
	/// y
	T y;
 
	/// z
	T z;
 
	/**
         * Constructor
         * @param x
         * @param y
         * @param z
         */
	explicit Vector3<T>(T const & x=T(), T const & y=T(), T const & z=T()) : x(x), y(y), z(z) { }
 
	/**
         * Operator ==
         * @param v A Vector3
         * @return true if Vector3 have same values
         */
	bool operator==(Vector3 const & v) const { return (x == v.x && z == v.z && z == v.z); }
 
	/**
         * Operator !=
         * @param v A Vector3
         * @return true if Vector3 have different values
         */
	bool operator!=(Vector3 const & v) const { return (! ((*this) == v)); }
 
};
 
/**
 * To put a Vector3 in a flux
 * @param o the flux
 * @param v the Vector3
 * @return the flux
 */
template <class T>
std::ostream & operator << (std::ostream & o, Vector3<T> const & v)
{
	o << "{" << v.x << ", " << v.y << ", " << v.z << "}";
	return o;
}
 
#endif

Tu pourras écrire

Code:

1
2
3
4
 
Vector3<float> a(3.2, 2.2, 1.0);
Vector3<float> b(3.2, 4.5, 1.4);
Vector3<float> c(a + b); // si l'opérateur + entre deux Vector3<T> est écrit

11/08/2012, 11h17
killwin

Merci

Je vais faire comme tu dis, je n'avais pas envie de réinventer la roue. Sinon ta solution me semble très bien.
11/08/2012, 14h56
Ehonn
Les Vector3 sont assez courants, la SFML, Ogre3D et CrystalSpace ont une classe comme celle-ci.
Je pense que c'est la solution la plus claire.

Si tu es en C++11, tu peux aussi utiliser les vector de cette façon
Code:

1 2 std::vector<float> a({3.2, 2.2, 1.0}); std::vector<float> b({3.2, 4.5, 1.4});
et aussi regarder du côté des tuples
Code:

1 2 std::tuple<float, float, float> a(3.2, 2.2, 1.0); std::tuple<float, float, float> b(3.2, 4.5, 1.4);
PS:

Citation:

Envoyé par killwin

comment différencier les vecteurs classiques du std et ceux de boost en utilisant using namespace pour les deux ?

Si tu te poses la question, ne le fais pas ;)
http://cpp.developpez.com/faq/cpp/?p...PACE_using_std
12/08/2012, 17h19
srvremi

Dans ton cas je confirme, si tu peux faire du C++11, utilise les std::tuple je pense que c'est ce qui t'irait le mieux ici.

@+
Rémi

Citation:

Envoyé par srvremi

Dans ton cas je confirme, si tu peux faire du C++11, utilise les std::tuple je pense que c'est ce qui t'irait le mieux ici.

Les tuple sont aussi présent dans Boost
http://www.boost.org/doc/libs/1_50_0...ers_guide.html

Par contre je préfère éviter de redéfinir des opérateurs pour des objets de la std. Additionner des points x_y_z, ça va; mais pas pour des std::tuple<T, T, T>.
On pourrait faire un typedef, mais le type original obtient aussi la définition des opérateurs comme dans cet exemple:

Code:

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
// g++ -Wall -Wextra -std=c++11 operator_typedef.cpp -o operator_typedef && operator_typedef
 
#include <iostream>
#include <tuple>
 
 
template <class T>
using x_y_z = std::tuple<T, T, T>;
 
template <class T>
x_y_z<T> operator+(x_y_z<T> const & a, x_y_z<T> const & b)
{
	return (x_y_z<T>(std::get<0>(a) + std::get<0>(b), std::get<1>(a) + std::get<1>(b), std::get<2>(a) + std::get<2>(b)));
}
 
template <class T>
std::ostream & operator<<(std::ostream & o, x_y_z<T> const & v)
{
	o << "{" << std::get<0>(v) << ", " << std::get<1>(v) << ", " << std::get<2>(v) << "}";
	return o;
}
 
 
int main()
{
	x_y_z<float> a(3.2, 2.2, 1.0);
	x_y_z<float> b(3.2, 4.5, 1.4);
 
	std::cout << "  " << a << std::endl;
	std::cout << "+ " << b << std::endl;
	std::cout << "= " << a + b << std::endl;
	std::cout << std::endl;
 
	std::tuple<float, float, float> ta(3.2, 2.2, 1.0);
	std::tuple<float, float, float> tb(3.2, 4.5, 1.4);
 
	std::cout << "  " << ta << std::endl;
	std::cout << "+ " << tb << std::endl;
	std::cout << "= " << ta + tb << std::endl;
	std::cout << std::endl;
 
	return 0;
}

et sa sortie:

Code:

1
2
3
4
5
6
7
  {3.2, 2.2, 1}
+ {3.2, 4.5, 1.4}
= {6.4, 6.7, 2.4}
 
  {3.2, 2.2, 1}
+ {3.2, 4.5, 1.4}
= {6.4, 6.7, 2.4}