Comme certains l´on peut etre deja lu sur un autre topic, j´ai fait récemment une classe en c++ qui peut recevoir une chaine de caractère, par exemple: sin(3*ln(4*x-1)^2)-2*tan(2/(x+1)), qui possède d´autre part une fonction qui teste la validité mathématique de la formule ( on ne peut pas écrire: 3sincos(x+a) par exemple), une fonction qui renvoie la valeur réelle pour un certain x et une fonction qui renvoie la valeur de la dérivée en x.

J´ai tenté de faire une fonction qui calcule l´intégrale entre deux bornes a et b. Je l´ai fait avec la technique de Riemann càd prendre de tout petits intervalles de largeur p et pour chacun on calcule les valeurs de la fonction et on additionne ces valeurs que l´on a multilpiées par p. On obtient ainsi une approximation relativement bonne ( elle est d´autant meilleur si on a pris des intervalles p très petits...) de l´intégrale.
Le problème c´est que pour avoir une précision satisfaisantes ( 0.00001) je suis obligé de découper mon intervalle en 100000 petits intervalles et ma fonction prend beaucoup de temps ( +-15 secondes sur un AMD3600).
Je me suis demandé s´il n´existe pas un algorithme plus approprié ( soit pour sortir la valeur d´une fonction soit pour l´intégration) qui soit plus rapide...

D´autre part j´ai envisagé autre chose pour ma lecture de fonction, mais je sais pas si c´est faisable:
Plutot que de devoir " scanner" ma cahine de caractères à chaque fois que je veux calculer une valeur, est-ce qu´il serait possible de demander à ma classe de faire ceci quand on lui propose une chaine:
- la classe recoit la cahine et test sa validité mathématique.
- la classe " crée" code source ( en c++ par exemple ou en asm si j´ai pas d´autre choix) en fonction de la chaine recue, puis le compile. Dans ce code se trouvera seulement une fonction semblable à celle qui a été introduite dans la chaine et lors de l´execution du programme celui-ci renvoie la valeur de la formule en fonction de x.
par exemple si l´utilisateur rentre la chaine:
sin(3*x)+1
on crée le code source suivant:
int nvellefonction(double dX)
{
return sin(3*dX)+1;
}
qui sera executé beaucoup plus rapidement que le " scanning" recurssif de ma fonction.

PS: si vous avez d´autres idées à rajouter dans la classe fonction, dite le moi !

Merci.

tu scannes la chaine a chaque fois que tu evalues la fonction ?
il y a de tres fortes chances pour que ce soit la tokenisation qui te bouffe 99% du temps, et non le calcul en lui meme.
La generation de code peut etre un peu tordue, j´irai plutot voir du cote automates, ou piles d´operateurs.
quand le modele d´evaluation sera rapide, la tu pourras attaquer l´algo, pour plus de rapidite.

je sais pas ce que c´est les automates et les piles d´opérateurs...

lorsque tu calcule l´intégrale, déjà tu ne revérifie pas la validité ?

pour l´évaluation, disont qu´il existe des méthode.
Si je devait le faire je transformerait la chaine en une chaine postfixé ( plus facile à manipuler) et ensuite tu peut calculer tout ce qui ne dépend pas de x, ce qui te laisse beaucoup moins de calcule à chaque fois.

Pour l´algo de l´intégrale lui même générallement on utilise des trucs genre, pour chaque intervalle p : 1 fois la valeur à gauche de l´intervalle + 4 fois la valeur au milieu plus une fois la valeur à droite ( sachant que sauf au début et à la fin la valeur à la fin est celle au début de l´interval suivant) et tout divise le tout par 6 avant de le multiplier par p.

Ca a un non ( je ne m´en rappelle plus) mais ça converge beaucoup plus vite vers la vrai valeur de l´intégrale qu´une simple somme de Riemman.

non la validité est seulement vérifiée lorsque j´introduit la formule dans la classe.
Pour les parties qui ne dépendent pas de x j´y avais pas pensé, je vais améliorer ca !
et sinon qu´estce que tu entends paar chaine postfixée ? ( sorry je débute et j´ai pas encore lu tout le bouquin)

générallement on note les opération en infixe c´est à dire que les opérateur sont au milieu des opérande : 4+5
Mais en postfixe, il sont à près : 4 5 +

ces deux lignes sont par exemple equivalentes :
( 3+5)*8-sqrt(12)*3
3 5 + 8 * 12 sqrt 3 * -
Tu remarque qu´en syntaxe postfixée il n´y a pas besoin de parenthèse et qu´on ne se soucie pas de la priorité des opérateurs.
Ce qui fait qu´on évalue beaucoup plus vite une telle expression.

Transformer des expression infixe en expression postfixe peut se faire de manière pas trop compliqué et une fois que c´est fait, tu profite à fond de la vitesse.

Ok je vois l´idée...
et dans ton exemple, pour faire la distinction entre 3 5 et 35 tu fais quoi ?
et ta chaine tu la lis de droite à gauche alors ?
Jvois pas trop comment on se ballade dedans alors... mais je vais y réfléchir

Et puis quand tu as par exemple 4+5+6
tu le codes 4 5 + 6 + ?
( ouais ca a l´air d´etre ca)

J´ai deja fait un truc comme ca en cours de logique ( écriture polonaise comme on appelle ca)
mais l´oppérateur se mettait devant...

c´est exactement ça, c´est ce qu´on appelle l´écriture polonaise inverse ( l´opérateur est dérrière).

4+5+6 tu peut l´écrire
4 5 + 6 +
ou 4 5 6 + +
pour faire la différence entre 35 et 3 5 il n´y a pas de problème tu regarde les espaces ( pas comme à l´écrit ou c´est plus dur).

Mais par contre tu lis bien la chaine de gauche à droite, tu pousse les valeur que tu lis ans une pile au fur et a mesure et dès que t´as un opérateur tu l´applique.

Si ça t´interesse je peut t´expliquer ça bien plus en détail mais là je doit partir.

Ouais je veux bien un ptit briefing la dessus,
J´ai deja commencé ma fonction qui transforme ma chaine en écriture polonaise mais je l´ai pas fait en inverse: 4+5*6 devient +4:*5:6
Je sais pas si c´est moins bien mais je trouve plus faicle de lui donner d´abord l´opérateur.
D´autre part j´ai simplifié les fonctions comme sin(x) ou ln(x). ainsi sin(x+1)-ln(5*3) devient
-s+x:1:l*5:3 comme ca je n´ai meme plus de parenthèses et je n´ai qu´un seul simbole à tester à chaque oppération ( ce qui me premet d´utiliser le switch...)
En fait la forme polonaise dans ce sens me permetra de facilement chercher la dérivée de facon formelle car il faut connaitre l´opérateur avant...

Un autre truc: j´hésite entre mettre ma nouvelle fonction dans une liste simplement pointée ou un tableau. L´avantage de la liste c´est que je ne gaspille pas de mémoire mais je crois que c´est un peu plus rapide avec le tableau...

Tu peux m´envoyer les info sur mon mail, ce sera plus facile...
ducheprog@gmail.com