Comment exécuter une expression RPN - Page 1

je n'ai trouvé que la méthode maison ( à l'observation car je n'en fait pas au school ) suivante pour exécuter du RPN :

"( 5 - c ) * ( c + a ) / x" correspond en RPN à " x c a + / c 5 - * "

- envoi de x c a sur la pile
- Addition
- division
- envoi de c 5 sur la pile
- Soustraction
- Multiplication

Pouvez vous m'éclairer s'il existe une méthode meilleure

ben non, qu'est-ce que tu voudrais de mieux ? enfin ca dépend de quelles sont tes contraintes de vitesse (si empiler un nombre prend *vraiment* trop de temps, ou si tu as des nbs en precision illimitée et que tu veux faire tes additions sur place, ou...), mais a priori c'est plutot efficace...

sinon petites remarques :
- en général on écrit plutot "5 c -" pour "5-c", ou "c a + x /" pour "(c+a)/x" (a l'envers de ce que tu fais, quoi)
- la plupart des langages (dont le C), considerent les operateurs +, -, * et / comme associatifs a gauche, i.e. a*b*c/d/e*f/g = ((((((a*b)*c)/d)/e)*f)/g), la tu as fait le contraire...

Merci Pollux, je me sens rassuré pour l'efficacité du code. c'est exactement l'effet voulu.

________________________________________________________________
Ok pour l'associativité mais ça change quoi au résultat final ?

Parceque mon convertisseur RPN analyse l'expression de gauche à droite.

ça va pas le faire de le refaire en commençant à droite.

ca ne change rien au résultat il me semble !
_________________________________________________________________
Je vais pouvoir intégré Le Parser d'expression à mon Interpreteur.
Celui-ci utilise les même type de variable que le TI-Basic.


En fait je trouve contraignant d'empiler.
donc je fait comme ceci :

"( 5 - c ) * ( c + a ) / x" correspond en RPN à " x c a + / c 5 - * "

correspond dans mon language à :

# # *
c 5 -
x # /
c a +

ce qui fait à l'exécution puisque c'est organisé comme une Pile :
a+c
(a+c)/x
5 -c
( 5- c) *(a+c)/x

Le #
représente donc le résultat du dernier calcul.

_______________________________________________________________________________
Je fait un Interpreteur pour MYLIB. Un genre de Basic.
Avec la méthode que j'utilise, Les variables définies dans le code sont directement référencées comme argument des fonctions sans recopie dans la pile.
La pile ne me sert qu'à déposer temporairement les résultats calculs intermédiaires.

ce qui revient a garder les 2 premiers niveaux de la pile dans un endroit spécial, en fait... mais si tu te contentes de passer des références plutot que de recopier quand tu empiles, l'empilement devient négligeable, non ? (c'est ce que je faisais dans GT-Basic, chaque variable [temporaire ou non] avait un handle sur 2 octets [plus rapide et plus compact qu'une adresse], j'empilais le handle pour passer des arguments, et la fonction appelée se chargeait de dépiler et de libérer les handles temporaires qd elle avait fini c'est bien plus efficace que la methode tios, i.e. recopie bourrin )

[rha ca me donne envie de faire un GT-Basic pour TI mais sans compilo on-calc toussa ]

tu m'enleve les mot de la bouche.
C'est exactement comme que je procède :

Le # indique une référence de type ESI à un argument situé soit dans une variable soit dans le code.
l'argument est référencé dans une structure puis utilisé lors de l'appel à la fonction.

l'interpreteur est déjà fait.
comme je n'avais pas fait de parser, je me suis mis pendant ces 3 jours à potasser le sujet sur une feuille , histoire de tirer quelque règle maison pour le parser.

je suis assez content du résultat.
je vais gerer les erreurs de syntaxe maintenant.

Au fait pollux , jamais entendu parler de GT-Basic

ou peut-on l'essayer ?

nulle part, c'était un gros vaporware ^^

theroeme de l'aiguillage

ben oui, +∞ ≤ +∞ ^^

Et c 'est quoi encore ce gtools ?

au moins gstools a eu un beta

Ca fume!!!