Discussion :

[davcha]

Hello,

Ce qui suit est un bout de code épuré (de beaucoup de choses) concernant une librairie de calcul matriciel.

L'idée est de construire des expressions sous forme d'arbre, grâce à l'application d'une succession d'opérateurs et fonctions, puis de résoudre le calcul grâce à la conversion implicite.

Je pensais cela possible, j'ai quelques doutes face à certaines difficultés.
Ici, apparemment, ce qui m'embête est que le C++ n'accepte qu'une seule conversion implicite définie par l'utilisateur à la fois.
Le code qui suit instancie des matrices (mat), et je m'attendais à ce que ces mat soient converties implicitement en ExprMat, qui sont un type dérivé de Expr. Seulement, le compilateur cherche à convertir mat directement en Expr.

Des idées ?

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class mat;
class Expr;
class ExprMat : public Expr{
  ExprMat(mat& x);
}
 
class ExprAdd : public Expr{
  ExprAdd(Expr* left, Expr* right);
  operator mat();
}
 
template<class L, class R>
ExprAdd operator+(L& left, R& right){
  return ExprAdd(&left, &right);
}
 
// stuff
 
mat a,b;
mat c = a+b;

[gbdivers]

Bonjour

Le message d'erreur exacte aurait été bien

Si tu as plusieurs conversion implicite possible, le compilateur va avoir un problème pour trouver la bonne, c'est normal. Voir le détail des règles de résolution d'appel de fonction

Sinon, ça se fait sans problème ce que tu veux faire, ça porte même un nom : "expression template", et comme le nom l'indique, ça se base sur les templates. Voir Les "expression templates", ou comment booster vos calculs matriciels ou un bon livre de méta prog C++ (Vandervoorde; Abhrams)

[davcha]

Ouaip, je viens de trouver une solution qui se base également sur les templates.
Très intéressant l'article de l'autre côté aussi. Je vais m'en inspirer.

Merci

[davcha]

Je viens de réaliser...

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
// Spécialisation pour l'addition
template <class T, class U> struct BinaryOp<T, U, Add> : public BinaryOpBase<T, U>
{
    BinaryOp(T I1, U I2) : BinaryOpBase<T, U>(I1, I2) {}
    inline double operator *() {return *It1 + *It2;}
};

BinaryOp(T i1...), pas de référence ici. Si jamais i1 est une matrice 10000x10000, c'est pas top non ?

[gbdivers]

Ce ne sont pas des matrices qui sont passé à ce niveau, mais des opérateurs qui permettent de construire l'arbre
Les matrices sont passées aux feuilles de l'arbre, qui utilise des vector const& et des itérateurs