Bonjour,

Dans l'optique de faire un moteur physique, j'ai choisi d'utiliser les template pour faire des arbres syntaxiques et simplifier mes calculs.
le système est éxpliqué dans ce tutoriel:
http://loulou.developpez.com/tutorie...taprog/#LIII-C

Je travaille sur des vecteur de 3 double et des matrices de 3*3 doubles.
Ce que je veux faire est dériver une expression mathématique, pour ensuite rentrer dans un solveur les tèrmes inconnus( les tèrmes inconnus seront les tèrmes de dérivée seconde). Pour l'instant j'ai simplement implémenté la dérivation et l'évaluation de l'expression. Et le problème est que le compilateur n'inline pas assez l'arbre syntaxique, or sa complexité devient quadratique en fonction du nombre d'éléments dans l'arbre syntaxique. On peut facilement le voir lorsque l'on fait une sortie assembleur:
Par exemple si l'arbre syntaxique est réellement construit (ce qui ne devrait pas arriver si l'inlining fonctionne bien):

Pour une suite d'additions la taille de la variable de l'expression a la taille de l'ensemble des variable qu'il contitent
Code : Sélectionner tout - Visualiser dans une fenêtre à part
sizeof(v1+v2+v3+v4+v5+v6+v7+v8)==sizeof(v1)*8
Or la construction de l'arbre se fait comme suit:
(avec Tn+1==Opplus<Tn,T> et
Code : Sélectionner tout - Visualiser dans une fenêtre à part
sizeof(Tn)==sizeof(T)*n
)
Code : Sélectionner tout - Visualiser dans une fenêtre à part
Opplus<Tn,T>(Tn a, T b):op1(a),op2(b){}
La construction du type intérmédière Tn se fait en copiant une variable de taille n*sizeof(T)
Or il ya n type intérmédière construit donc la taille totale des variables déplacée est sizeof(T)n*(n+1)/2

Ce qui fait beaucoup, la complexité devient quadratique alors que l'on voulait gagner en complexité!!
Le compilateur ne fait pas son travail! Deplus cela devient dangereux lorsque je dérive une expression qui fait intervenir des multiplication:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
sizeof(derive(derive(v*v*v)))==sizeof(v)*27
J'ai donc de gros template, si le template n'est pas optimisé la complexité finale dans le pire des cas est de
27*28/2*C(copie)+27*C(opérations)
alors qu'il ne devrait y avoir seulement 27*C(opérations)

Voilà le code du template pour quelques opérations(ce code fonctionne):
essais.h
matr9d.cpp
matr9d.h
essais.cpp
patrons.h

matr9f.h et matr9f.cpp contienne le vecteur de 3 double et la matrice de 3*3 double, avec plein d'opérations.
patrons.h contient deux trois template
essai.cpp contient le main et essai.h contient l'arbre syntaxique.

On peut essayer différentes expressions qui réalisent la même chose entre le calcul direct et le calcul par évaluationde l'arbre syntaxique. On voit que la sortie assembleur effectuée avec l'arbre syntaxique est plus longue.

compilation pour sortie assembleur:
g++ -O2 -S -std=c++0x *.cpp


Y a-t-il un truc pour régler ce problème?

Merci d'avance pour vos réponses