métaprogrammation, expression templates et conversion de types

Version imprimable

25/01/2007, 14h38
grob1212

métaprogrammation, expression templates et conversion de types
Bonjour,

pour apprendre la métaprogrammation et comprendre les expressions templates, je suis entrain de "jouer" avec une petite classe vecteur et je voudrait savoir s'il existe une solution au problème que je me suis posé :

chaque vecteur est défini par un type et une dimension :
Code:

1 2 3 4 5 6 7 8 template<class type, int dim> class vecteur { protected: type val[ dim]; ... };
je désire simplement effectuer, à l'aide des expressions templates, l'addition de deux vecteurs. Existe-t-il un moyen d'additionner deux vecteurs dont le type est différent, tout en respectant les règles de conversions standards (sans se préoccuper des dimensions dans un premier temps). Par exemple,
la somme de deux variables mettant en jeu un float et un int donne un float par la conversion implicitement du int en float. En clair, est-t-il possible que la surcharge de l'opérateur + avec deux vecteurs de types différents puisse donner en sortie un vecteur du type le plus grand ?

Exemple :
Code:

1 2 3 4 5 6 vecteur<int, 4> vi; vecteur<double,4> vd; vi + vd; // conceptuellement, la somme des deux vecteurs //devrait donner un vecteur de type vecteur<double, 4>
Je ne sais pas si j'ai été assez clair, et je remercie toutes les personnes qui auront eu la patiente de me lire jusqu'au bout :)

Merci beaucoup.

C'est possible, simplement à un moment où un autre tu auras besoin d'une structure qui définit ces règles de conversion, genre une classe de traits.
Code:

1 2 3 4 5 6 7 8 9 10 template <typename T1, typename T2> struct MachinTraits; template <> struct MachinTraits<float, int> {typedef float Type;}; template <> struct MachinTraits<double, int> {typedef double Type;}; template <> struct MachinTraits<char, int> {typedef int Type;}; // ... pour chaque paire de types ! template <typename T1, typename T2> Vector<MachinTraits<T1, T2>::Type> operator +(const Vector<T1>&, const Vector<T2>&);
Après, il y a peut-être moyen de faire ça plus simplement (genre en utilisant la taille pour les types entiers), mais l'idée est là.

25/01/2007, 15h13
grob1212

Merci Laurent,

il y a encore bien des aspects que je ne maîtrise pas en C++ (dont les traits). Il faudrait que je trouve une référence bien complète sur le sujet.
25/01/2007, 15h35
Jean-Marc.Bourguet

The Complete Template Guide, de Vandevoorde et Josutis, est indispensable si on touche aux templates en profondeur.
25/01/2007, 15h46
grob1212

Décidément, quelle réactivité sur le forum, je suis vraiment impressionné :)

Je suis entrain de tester la méthode avec les traits. Même si c'est un peu lourd, en se limitant à quelques types, c'est encore gérable. Encore quelques petites erreurs à corriger et je posterai le source (aidera-t-il quelqu'un ?)

Dans tous les cas, merci beaucoup à tous, je vais de ce pas voir la référence.
25/01/2007, 15h58
loufoque

On peut aussi faire typeof(double(0) + float(0)) si tu utilises GCC ou autre avec extensions du genre (qui devraient être aussi disponibles dans C++09)

On peut peut-être le faire aussi avec result_of, mais je vois pas trop comment.
25/01/2007, 20h43
r0d

Citation:

Envoyé par grob1212

Encore quelques petites erreurs à corriger et je posterai le source (aidera-t-il quelqu'un ?)

Oui bien sûr. Il y a un topic dédié à cela sur le forum. Tout code (propre et qui fonctionne) est le bienvenu :D
26/01/2007, 10h46
Charlemagne

J'ai moi même été confronté à ce genre de problèmes pour l'implémentation d'une bibliothèque mathématique (GPL):
http://www.ient.rwth-aachen.de/team/...al/genial.html

Regarde plus particulièrement la page suivante de ma doc (en anglais):
http://www.ient.rwth-aachen.de/team/...e70180x34f6b7c

Voici la syntaxe que j'utilise:

DenseVector<int>::self X(4,1); // X=[1 1 1 1]
DenseVector<float>::self Y(4,1.5); // Y=[1.5 1.5 1.5 1.5]
cout << X+Y << endl; // [2.5 2.5 2.5 2.5]
cout << X+value_cast<int>(Y) << endl; // [2 2 2 2]
26/01/2007, 10h59
JolyLoic

Citation:

Envoyé par Jean-Marc.Bourguet

The Complete Template Guide, de Vandevoorde et Josutis, est indispensable si on touche aux templates en profondeur.

C'est C++ Templates, the complete guide le titre, et j'appuie Jean-Marc quant à la qualité de ce livre.
26/01/2007, 11h01
Laurent Gomila

Citation:

J'ai moi même été confronté à ce genre de problèmes pour l'implémentation d'une bibliothèque mathématique (GPL):
http://www.ient.rwth-aachen.de/team/...al/genial.html

Regarde plus particulièrement la page suivante de ma doc (en anglais):
http://www.ient.rwth-aachen.de/team/...e70180x34f6b7c

Ce qui aurait été intéressant serait que tu nous dises comment tu as géré ça dans ton code ;)

Citation:

Envoyé par Laurent Gomila

Ce qui aurait été intéressant serait que tu nous dises comment tu as géré ça dans ton code ;)

Mon implémentation des "expression templates" utilise en arrière plan le genre de méta-programmation suivante. Il est possible de faire plus évolué pour choisir les promotions, mais cette implémentation m'a toujours suffis.

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
template<int cond,class A, class B> struct IF {};
template<class A,class B> struct IF<0, A, B> { typedef B RET; };
template<class A,class B> struct IF<1, A, B> { typedef A RET; };
 
template<int m,int n> struct EQUAL         { enum { RET=(m==n)?1:0 }; };
template<int m,int n> struct NOT_EQUAL     { enum { RET=(m!=n)?1:0 }; };
template<int m,int n> struct LOWER         { enum { RET=(m<n)?1:0 }; };
template<int m,int n> struct GREATER       { enum { RET=(m>n)?1:0 }; };
template<int m,int n> struct LOWER_EQUAL   { enum { RET=(m<=n)?1:0 }; };
template<int m,int n> struct GREATER_EQUAL { enum { RET=(m>=n)?1:0 }; };
 
 
 
 
template<class T> struct promotion {  };
 
#define DECLARE_PROMOTION(TYPE,RANK) template<> struct promotion< TYPE > { enum { rank = RANK }; }; template<> struct promotion<const TYPE > { enum { rank = RANK }; };
 
DECLARE_PROMOTION(unsigned char,         1)
DECLARE_PROMOTION(char,                  2)
DECLARE_PROMOTION(unsigned short,        3)
DECLARE_PROMOTION(short,                 4)
DECLARE_PROMOTION(unsigned int,          5)
DECLARE_PROMOTION(int,                   6)
DECLARE_PROMOTION(unsigned long,         7)
DECLARE_PROMOTION(long,                  8)
DECLARE_PROMOTION(float,                 9)
DECLARE_PROMOTION(double,               10)
DECLARE_PROMOTION(long double,          11)
 
template<class T>
struct promotion_traits
{
  typedef T value_type;
};
 
template<class T>
struct promotion_traits<const T>
{
  typedef typename promotion_traits<T>::value_type value_type;
};
 
template<class T1,class T2>
struct promotion2_traits
{
  typedef typename IF<LOWER<promotion<T1>::rank,promotion<T2>::rank>::RET, T2, T1>::RET value_type;
//  typedef T1 value_type;
};
 
template<class T1,class T2> struct promotion2_traits<const T1,      T2> { typedef typename promotion2_traits<T1,T2>::value_type value_type; };
template<class T1,class T2> struct promotion2_traits<      T1,const T2> { typedef typename promotion2_traits<T1,T2>::value_type value_type; };
template<class T1,class T2> struct promotion2_traits<const T1,const T2> { typedef typename promotion2_traits<T1,T2>::value_type value_type; };
 
template<class G> class Vector;
template<class G,class V> struct promotion2_traits<Vector <G>,complex<V> > { typedef typename Vector<G>::template rebind<typename promotion2_traits<typename Vector<G>::const_value_type,complex<V> >::value_type>::other value_type; };
template<class V,class G> struct promotion2_traits<complex<V>,Vector <G> > { typedef typename Vector<G>::template rebind<typename promotion2_traits<complex<V>,typename Vector<G>::const_value_type >::value_type>::other value_type; };
 
template<class G> class Matrix;
template<class G,class V> struct promotion2_traits<Matrix <G>,complex<V> > { typedef typename Matrix<G>::template rebind<typename promotion2_traits<typename Matrix<G>::const_value_type,complex<V> >::value_type>::other value_type; };
template<class V,class G> struct promotion2_traits<complex<V>,Matrix <G> > { typedef typename Matrix<G>::template rebind<typename promotion2_traits<complex<V>,typename Matrix<G>::const_value_type >::value_type>::other value_type; };
 
template<int D,class G> class Array;
template<int D,class G,class V>   struct promotion2_traits<Array<D,G >,complex<V>  > { typedef typename Array<D,G>::template rebind<typename promotion2_traits<typename Array<D,G>::const_value_type,complex<V> >::value_type>::other value_type; };
template<class V,int D,class G>   struct promotion2_traits<complex<V> ,Array<D,G > > { typedef typename Array<D,G>::template rebind<typename promotion2_traits<complex<V> ,typename Array<D,G>::const_value_type>::value_type>::other value_type; };
 
 
template<class T1,class T2,class T3>
struct promotion3_traits
{
  typedef typename promotion2_traits<typename promotion2_traits<T1,T2>::value_type, T3>::value_type value_type;
//  typedef T1 value_type;
};
 
#define PROMOTE(T) typename promotion_traits< T >::value_type
//#define PROMOTE2(T1,T2) T1
#define PROMOTE2(T1,T2) typename promotion2_traits< T1,T2 >::value_type
//#define PROMOTE3(T1,T2,T3) T1
#define PROMOTE3(T1,T2,T3) typename promotion3_traits< T1,T2,T3 >::value_type

27/01/2007, 09h35
grob1212

Merci Charlemagne, et joli travail. Je crois que tout cela va me faire progresser rapidement. Mon problème est que je ne raisonne pas encore en considérant la méta-programmation comme un langage à part entière (en somme j'ai encore du mal à me faire aux IF<>...), mais ca va venir.

A titre de curiosité combien de temps as-tu mis pour développer ta librairie (en séparant la formation aux expression templates du développement proprement dit) ? Etait-ce seul ou en équipe ?

Merci à tous pour ces contributions. Si vous en avez d'autres je suis preneur :)
27/01/2007, 12h32
Charlemagne

Citation:

Envoyé par grob1212

A titre de curiosité combien de temps as-tu mis pour développer ta librairie (en séparant la formation aux expression templates du développement proprement dit) ? Etait-ce seul ou en équipe ?

Seul. (mes collègues ne programment qu'en C ou Matlab)
J'ai débuté la librairie y'a environ 6 ans.
Depuis 1 an, je n'y apporte plus trop d'extensions, je me contente principalement de la maintenir.
J'ai pas mal d'autres modules mathématiques rattachés à cette librairie, dont je me sers en traitement d'images, mais j'estime qu'ils ne sont pas assez généraux, utiles ou accomplis pour être mis en ligne.

Séparer le temps de programmation des "expression templates" du reste n'est pas facile car je n'utilise pas vraiment les "expression templates", mais une implémentation personnelle qui est indissociable des vecteurs/matrices.
Dans l'ensemble, mes containers Vector/Matrix n'ont plus trop évolués après la 1ère année de programmation, représentant peut-être 6 mois de travail à temps plein. Mais par la suite, bien d'autres modules sont venus se greffer...