je n´aipas retrouver ce que je cherchais, mais j´ai retrouver qqch d´aprochant.

c´est à dire un truc qui expliqyue ( assez sommairement il est vrai) comment covertir des expression infixé, en expression postfixé.
Expression postfixé dont tout le monde sait qu´il est extremement facile de les interprété ( si tu ne le sait pas, renseigne toi sur le RPN, et tu verra que c´est très puissant).

Je ne voudrais pas faire celui qui rabache, mais avec une grammaire, tu n´as pas de probleme de priorites des operations ( pour peu que tu aies choisis la bonne au depart).
Je pense que c´est plus simple de proceder ainsi que de passer par une transformation de l´expression.
L´avantage est que tu n´as qu´une seule passe en utilisant une grammaire. Tu testes la syntaxe et tu evalue en meme temps. Tu n´as pas non plus d´arbre a construire, c´est transparent. Il ne faut pas de structure de donnee particuliere.

Cette methode est p-e moins intuitive a comprendre et a mettre en oeuvre ( reflechir sur papier avant), mais le programme est bcp plus simple a la fin.
Je trouve ca " propre" et " ultime"

Ok je vais me pencher sur la grammaire dans ce cas
Je jeterais aussi un oeil sur les expression infixées et postfixée car j´ai déjà rencontré le terme sur le sujet.

Dommage car mon petit arbre fonctionne vachement bien

Merci a vous deux en tout cas

Raah les liens que tu m´as donné en première page i_am_the_law sont out pour l´instant, juste quand je voulais y faire un tour
J´y retournerai plus tard...
Néanmoins l´usage d´une grammaire entraine elle tout de même l´utilisation d´un arbre binaire pour l´évaluation de l´expression ?

La grammaire c´est bien ; ).

Utilise Lex et yacc sous linux.

Et le Caml ça puxxx . ..

Salutations ! voici l´adresse d´un mod solo pour Half-life : http://www.stargatehl.new.fr dites nous ce que vous pensez du site et des models ! on recherche des codeurs et des mappeurs aussi, alors si vou voulez vou joindre à nous, venez ! ( mai il fo fer ses preuves avant ^^ ) bon, je vous laisse commenter ! ^^

Après une petite étude du sujet, il me semble tout de même qu´une grammaire soit un peu complexe vis à vis de la simplicité des expression que j´ai à manipuler : les tutos qu´il m´a été donné de voir traite de grammaires très complexes avec des verbes, sujets, etc...).
Les opérateurs se réduisant simplement à :
( je manipule des expression de logique)

´+´ : ou
´.´ : et
´*´ : ou-exclusif
´/´ : opposé

et ´(´,´)´ bien sûr.

Sacahant que l´opérateur ´.´ a préséance sur ´+´ et ´*´.

A moins qu´il y aie un manière d´implémenter une grammaire très simple pour ce cas très particulier, je vais voir...

Oui tu peux le faire de façon très simple.

Le tout c´est de commencer.

Tu n´as pas besoin de voir toutes ces notions sur les grammaires. Les seules choses dont tu as besoin c´est de savoir faire la table d´analyse et de savoir ou et comment calculer les attributs ( pour evaluer l´expression).
Il me semble que dans les liens, il y avait des exemples sur une grammaire pour les expressions arithmetiques et d´autres exemples simples.

Pour ce que tu veux faire, une grammaire qui aurait cette tete la, pourrait marcher
S->L ( L = expression logique)
L->L+E|L*E|E ( E = expression avec et)
E->N|E.N ( N se rapporte a une partie avec un nombre)
N->val|/N|(L)

Elle est pas LL1, j´ai un peu la flemme de la transformer, mais je pense que ca devrait marcher.

Si tu deroules les regles pour qqs expressions tu veras que les " et" sont toujours places plus bas qu´un ou donc evalues plus tot.
Enfin c´est si je me suis pas trompe dans les regles
Si ca marche pas, et si tu decides de suivre cette methode, je pourrai tjrs regarder plus en details.

Si tu continues avec la methode des arbres, tu peux essayer de recombiner ton arbre, mettre les operations prioritaires en bas dans l´arbre.

J´ai encore trouvé des liens sur le sujet : j´y jette un oeil...

http://www.lrde.epita.fr/fr/~akim/compil/th-langage.pdf
http://www.cs.luther.edu/du/~leekent/tutorials/ll1.html

âr grammaire, tu veux dire une grammaire pour l´utilisateur finale aussi ? un langage qu´il aurait besoin d´apprendre ( même très simple) ?
Si oui, il te FAUT le RPN. c´est simple, extremement puissant, très facile à interpréter et même à compiler ( c´est proche de l´asm). ça s´apprend très facilement, et on ne s´en lasse jamais tant c´est puissant.

Mon programme se charge d´évaluer des expressions de logique ( comparables à des espressions arithmétiques très simples afin d´en retourner le résultat)

Si l´utilisateur entre :

1+(1.0).(0.1+(1+1).0)

Le programme lui retourne 1.
Bon c´est sûr que vu comme ca ca à l´air parfaitement débile et inutile, mais le but est en fait de simuler des circuits logiques combinatoire au final
Donc bon la grammaire pour l´utilisateur est intuitive.
Je me repencherai sur les grammaires demain

ah ok, j´avais pas vu cete partie du problème.

mais dans ce cas, il n´y a pas vraiment de problème de préséance d´opérateur ou autre.

il suffit que tu lise de gauche à droite et que tu remplisse une pile :

tu lis le 1 tu le mets dans la pile.

tu lis le + tu le mets dans une autre pile.

puis la parenthèse tu la mets dans la pile du + quand enfin tu arrive à une parenthèse fermante ou à la fin de l´expression tu sors deux éléments de la pile de gauche ( pourquoi de gauche ? ) tu leurs applique l´expression de droite, tu mets le résultat dans la pile de gauche et tu vire l´opération de la pile de droite ( tu a enlevé les 1 et ou 0 de la pile de gauche).

et tu continu jusqu´a ce que la pile soit vide.

je suis pas sur que j´ai été clair.

ce que je voulais dire c´est que je vois pas l´interet d´une grammaire ou d´un arbre ( trop compliqué) alors qu´on peut résoudre ce problème avec des piles ( 2) d´une manière plus simple à mon gout.

dans tout les cas, lag-it, la SI c´est mauvais pour la santé à trop haute dose...

Il n´y a pas forcement de parentheses autour du " et", du moins c´est ce que j´en ai compris, sinon son systeme d´arbre marchait je crois. Le probleme c´est 1+1.1 et il faut calculer 1.1 en 1er.

Ensuite, je vois 2 autres pb a ton systeme.
Tu ne sais pas combien d operations etaient ds la parentheses ( on depile combien d elements apres une parentheses fermante?)
Tu vas dire qu´on a qu´a mettre un compteur, mais si les parentheses sont imbriquees, ca devient vite lourd de compter
genre ( 1+(1.1)+(1.(1+(1.1).1+1.(1+1+1))))
qu´arrive-t-il si on a 1.1+1).1 ?
C´est complique de gerer le bon parenthesage ( sauf si on considere que l´expression entree est valide).

" C´est complique de gerer le bon parenthesage ( sauf si on considere que l´expression entree est valide)."

Eh bin justement : pour le moment il ne traite que des expressions valides

A priori je me casse la tête pour pas grand chose étant donné que l´objectif du programme est de permettre à l´utilisateur de concevoir un circuit logique combinatoire de manière graphique avec des portes logiques que le programme se chargera de simuler : les fonctions chargées de construire l´expression/l´arbre à partir de composant placés ne rencontreront pas le problème de la priorité de et p/r à ou et xor étant donné que la construction sera réalisée de telle sorte que tout se passe bien.
Cependant j´aimerai éventuellement associer une console au projet qui permette d´entrer les equations directement dedans, voir de construire les circuits à partir d´une equation.

Sinon concerant le systeme de creation d´arbre, il est extêmement simple :
On lit l´expression de gauche à droite et s´il on rencontre :

´(´ On crée un nouveau fils que l´on affecte à la partie gauche ou droite du noeud père ( noeud " courant") selon si sa partie gauche est ou non déjà affectée et on défini ce nouveau fils comme le noeud " courant".

´)´ On défini le noeud courant comme le noeud père du noeud courant

´+´,´.´,...
On affecte cet opérateur comme l´opérateur du noeud courant

etc pour les valeur 0, 1 et les variables.

Sachant que l´instruction recue en entrée de la fonction est bien formatée :

x+y+z doit être : ( x+y)+z ou x+(y+z) ( étant donné la structure binaire de l´arbre)
x+y.z -> x+(y.z) ( (x+y).z ne convient pas ! )
. ..

Et moi j´aimerai bien pouvoir écrire la fonction qui passe de l´expressionentrée à l´expression bien formatée.
Il y a moyen de faire ca crade en bourrinant, mais j´aimerai un truc propre.
Je me penche sur les grammaires

dnob > Je pourrais il est vrai envisager l´usage d´une pile, mais plus d´arbre alors

" dans tout les cas, lag-it, la SI c´est mauvais pour la santé à trop haute dose..."

Je sais j´en fais depuis la seconde ( option ISI puis SI au lieu de SVT). Tu va faire info ?

" ´)´ On défini le noeud courant comme le noeud père du noeud courant"

C´est l´inverse

" " C´est complique de gerer le bon parenthesage ( sauf si on considere que l´expression entree est valide)."

Eh bin justement : pour le moment il ne traite que des expressions valides "

testé que l´expression est valide est très simple, il suffit de vérifier que toute les parenthèse opuverte sont fermé et vice versa ( ont peut le faire avec une pile encore pour être ur qu´on n´en ferme pas trop d´affilé) et que les symbole sont séparé par des opérateur et vice versa.

pour info, je te renvoie à ce sujet d´info qui traite exactement de ça : http://pepinlebref.free.fr/mpsi2/math/concours/info_centrale.pdf

Quand je dis pas si simple c´est qu´il y a des cas particuliers.
Les operateurs unaires se trouvent entre un operateur binaire et un nombre, les binaires entre 2 nombres ou nombre / unaire..etc

Si tu veux tester la syntaxe en meme temps que l´evaluation de l´expression, ca reste complique.

Le programme n´est pas clair et je le maintiens, on n´ajoute pas facilement des fonctionnalites.

Pour moi, la solution la plus propre et qui se rapporte le moins au bricolage ca reste l´utilisation d´une grammaire.
Sans structure de donnees particuliere, en 1 seule lecture de l´expression, tu fais l´evaluation de l´expression et le test de la syntaxe. Le code reste clair, il y a pas 50 if imbriques, et on rajoute facilement de nouvelles fonctionnalites.