Besoin d'aide pour un Algo

**Spinoza23** · 13/02/2007, 14h31

Voila, j'ais un algo a créer pour que cela devienne un programme en java... Le souci c'est que je n'arrive pas a faire l'algo... Je vous montre ce que je dois faire...

L'utilisateur veut faire une addition par exemple... de 15 + 3 + 2 ( =20 j'suis trop fort... )

Voici une expression :

"Addition de [valeur1 ou expression1] avec [valeur2 ou expression2]"

Admetons que l'utilisateur veuille changer la première valeur (entendez ici le contenu des premiers crochets [...] ) , il clique alors sur valeur1, la modifie et met a la place 15. Il valide alors et voici l'expression qui apparait :

"Addition de [15] avec [valeur2 ou expression2]"

Es ce que c'est clair??? Je continue; Il clique donc maintenant sur expression2 car il veut ajouter une autre addition... Il choisi l'expression Addition, valide et voici a quoi ressemble l'expression :

"Addition de [15] avec [Addition de [valeur1 ou expression1] avec [valeur2 ou expression2]]"

Ca devient plus chaud a suivre mais j'espère que vous comprenez...; Il modifie enfin les deux valeurs (valeur1 et valeur2) pour ajouter 2 et 3.... L'expression finale est donc :

"Addition de [15] avec [Addition de [2] avec [3]]"

Et la je vous parle que de l'affichage...donc imaginez un peut le code pour une telle chose...
Il est évident pour moi que ceci va se faire via des Si imbriqués...
Une autre précision : je dois faire cela pour plusieurs expressions...

Addition de [valeur1 ou expression1] avec [valeur2 ou expression2]
Soustraction de [valeur1 ou expression1] avec [valeur2 ou expression2]
Multiplication de [valeur1 ou expression1] avec [valeur2 ou expression2]
Division de [valeur1 ou expression1] avec [valeur2 ou expression2]
Arrondi la [valeur1 ou expression1] sur [valeur2 ou expression2] décimal
Partie entière de [valeur1 ou expression1]
Entier supérieur à [valeur1 ou expression1]
Valeur absolue de [valeur1 ou expression1]
Signe de [valeur1 ou expression1]
Elève [valeur1 ou expression1] à la puissance [valeur2 ou expression2]
Modulo de [valeur1 ou expression1] par [valeur2 ou expression2]
Racine carrée de [valeur1 ou expression1]
Concaténation de [valeur1 ou expression1] avec [valeur2 ou expression2]
Longueur de [valeur1 ou expression1]
Extraction de [valeur1 ou expression1] à partir de [valeur2 ou expression2] sur une longueur de [valeur3 ou expression3]
Position de [valeur1 ou expression1] dans [valeur2 ou expression2]
Suppression des espaces à gauche de [valeur1 ou expression1]
Suppression des espaces à droite de [valeur1 ou expression1]
Conversion en Majuscule de [valeur1 ou expression1]
Conversion en Minuscule de [valeur1 ou expression1]
Conversion en texte de [valeur1 ou expression1] sur une longueur de [valeur2 ou expression2]
Conversion en numérique de [valeur1 ou expression1]
Code ASCII du caractère [valeur1 ou expression1]
Caractère du code ASCII [valeur1 ou expression1]
Si [aleur1 ou expression1] est NULL affiché [valeur2 ou expression2]
Première valeur non NULL dans [valeur1 ou expression1], [valeur2 ou expression2], …..
Dans le cas où [valeur1 ou expression1] est égal à [valeur2 ou expression2] affiché [valeur3 ou expression3] sinon si égal à [valeur4 ou expression4] affiché [valeur5 ou expression5] … sinon affiché [valeur6 ou expression6]
Moyenne de [valeur1 ou expression1]
Somme de [valeur1 ou expression1]
Minimum de [valeur1 ou expression1]
Maximum de [valeur1 ou expression1]
Nombre de valeur de [valeur1 ou expression1]
Nombre de valeur distincte [[U]valeur1 ou expression1]

Et donc etre capable de passer de l'une a l'autre sans problème...

Mon code en java (le début) donne ceci :

Code :

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
21
22
23
24
25
26
27
28
29
          if ("valeur1".equals(he.getDescription().toLowerCase()))
          {
          /**            Addition de [valeur1 ou expression1] avec [valeur2 ou expression2]**/
              lo_wbuffer.append ("<html><body>");              
              lo_wbuffer.append ("Addition de <b>[</b>"); 
              lo_wbuffer.append ("<a href=\"valeur1\">Valeur1</a>");
              lo_wbuffer.append (" <b>]</b>");
              lo_wbuffer.append ("</body></html>");
              statusBar.setText ("Valeur1");
          }
          else if ("expression1".equals(he.getDescription().toLowerCase()))
          {
              lo_wbuffer.append ("<html><body>");              
              lo_wbuffer.append ("Addition de <b>[</b>"); 
              lo_wbuffer.append ("<a href=\"valeur4\">Valeur4</a>");
              lo_wbuffer.append (" <b>]</b>");
              lo_wbuffer.append ("</body></html>");
              statusBar.setText ("Valeur2");
          }              
          else
          {
              lo_wbuffer.append ("<html><body>");              
              lo_wbuffer.append ("Expression : <b>[</b>"); 
              lo_wbuffer.append ("<a href=\"valeur1\">Valeur1</a>");
              lo_wbuffer.append (" <b>] ou [</b><u> ");
              lo_wbuffer.append ("<a href=\"valeur2\">Valeur2</a></u><b>]</b>"); 
              lo_wbuffer.append ("</body></html>");
              statusBar.setText ("Expression");
          }

Je suis donc bloqué sur mon algo... voila... j'espere avoir été assez clair... Merci d'avance pour votre aide

**reggae** · 13/02/2007, 16h58

C'est plus spécifiqus au langage qu'à l'algorithmique...

En gros, une fois ta chaîne finale obtenue, il te suffira de la diviser en parcelle telle "Addition de" ou "Soustraction", etc.

Tu sauvegarde tout dans un tableau de String. Grâce à la position des éléments dans le tableau, tu pourra prévoir l'imbrication des éléments et les résoudre ainsi plus facilement...

**Spinoza23** · 13/02/2007, 17h00

Ca a l'air assez chaud... tu ne pourrais pas me montrer un exemple? ca m'aiderais beaucoup... Merci

**reggae** · 13/02/2007, 17h48

Malheureusement, mes connaissances Java sont plutôt faibles...

Mais voilà comment je procéderais:
L'affichage à l'écran serait formé de plusieurs chaîne String, de type Opération, Argument et Séparateur(parenthèses et crochets). L'utilisation des classes me semble indiquée.

Ensuite tu peux manipuler tes chaînes en les insérant dans le nombre de String équivalent à celui de tes paranthèses.
Prenons un cas "((3-1)+2)...". Parcours ton String jusqu'à ")". Attention! si tu tombes sur "(" en premier, cela change la donne!

Un fois ta chaîne rognée, il te suffira d'y lire les opérateurs(tu peux utiliser des enum) que tu transformeras donc en signes mathématiques...
Ex: "Addition de" sera remplacé par "+".

Te voici donc avec une chaîne similaire à un vulgaire calcul arithmétique...
Ex: 5*((3+2)-1)

Pour éviter de réinventer la roue, tu files ton String final à un interprêteur qui va te résoudre simplement le calcul... Ca doit certainement être possible en Java...

C'est pas très clair, j'en suis conscient et navré. Mais il m'apparaît comme inévitable de faire déplacer ton post vers le forum Java, car tes ennuis, ainsi que les solutions semblent être plus liés au langage qu'à l'algorithmique.

A++

PS: tu devrais sûrement pouvoir trouver de l'aide ici.

**souviron34** · 14/02/2007, 02h20

euh...

Non moi je ferais pas dépendre ça du langage..

Mais ton algo de base me semble beaucoup trop compliqué... Enfin pas compliqué mais pas générique.

Tu n'as pas assez modélisé (eh oui c'est quelqu'un qui fait du C qui te dit que c'est pas assez orienté objet

)

j'ai déjà fait un truc comme ça...

Attends je le cherche...

OK voilà le principe :

1) tu définis les opérateurs que tu souhaites ( +, -, *, / , &, etc..)
2) tu définis une structure d'opération (forcément uniquement 2 opérandes)
3) dans cette structure tu prévois un ordre, et un type de variable pour chaque opérande
4) tu saisis ou fait saisir l'opération
5) tu analyses la CONCEPTION de l'opération :

tu cherches les opérateurs, tu comptes les parenthèses ouvertes et fermées, donc tu déduis un ordre dans lequel la succession des opérateurs doit se faire, avec quel type d'opérande à chaque fois. Un opérande peut être lui-même une opération.
6) tu exécutes la suite des opérations dans l'ordre :

celles qui ont le plus grand indice d'ordre (le plus grand nombre de parenthèses) en premier
Pour chacune des opérations ET pour chacun des opérandes, tu vérifies si l'opérande est lui-même une opération.
Si oui tu le calcules

7) tu as le résultat

un exemple de structure d'operation :

Code :

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
 
#define OPER_ADD  0
#define OPER_SUB  1
#define OPER_MUL  2
#define OPER_DIV  3
 
typedef struct _Mon_Operation {
 
  int               Type ;
  int               Order ;
 
  int               FirstOper ;
  int               SecondOper ;
 
  Mes_Variables    *First ;
  Mes_Variables    *Second ;
 
  Boolean            ResultIsInTempo ;
 
} Mon_Operation ;

Et un exemple de code :

Code :

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
 
/* Exemple de code */
 
      /* For each point does the succession of operations */
 
for ( i = 0 ; i < N_Operations ; i++ )
  {
     if ( Operations[i].Type == OPER_NOP )
       continue ;
 
      /* First checks for real operands */
     IsConstant1 = False ;
     IsConstant2 = False ;
 
  // ici on affecte les variables du premier opérande 
      if ( Operations[i].First != (Mes_Variables *)NULL )
        {
           IsConstant1 = Operations[i].First->IsConstant ;
 
           if ( ! IsConstant1 )
             {
             }
           else
             {
             }
        }
 
  // ici on affecte les variables du second opérande
      if ( Operations[i].Second != (Mes_Variables *)NULL )
        {
           IsConstant2 = Operations[i].Second->IsConstant ;
 
           if ( ! IsConstant2 )
            {
            }
          else
            {
            }
        }
 
 // Et maintenant on fait les vraies opérations
 
      switch ( Operations[i].Type )
        {
 
           case OPER_ADD :
                     // Si type est numérique 
              if ( le_type_de vals_0 est numérique )
                    Result = vals_0 + vals_1 ;
              else
                     // Sinon ajoute 2 chaines par exemple
              break ;
 
           case OPER_SUB :
              Result = vals_0 - vals_1 ;
              break ;
 
           case OPER_DIV :
              Result = vals_0 / vals_1 ;
              break ;
      }

**Spinoza23** · 14/02/2007, 09h57

tu m'a ecrit :

2) tu définis une structure d'opération (forcément uniquement 2 opérandes)

Je ne comprend pas trop ce que c'est??? désolé

**souviron34** · 14/02/2007, 12h11

eh bien par exemple la structure donnée plus haut :

une opération du style : a + b

a deux opérandes (a et b) et un opérateur (+)

l'opérateur est le type de l'opération
a et b peuvent chacun soit être une valeur (directe) soit le résultat d'une opération

exemple :

((a+b)*(a-b)) + (3*5)

la première modélisation est :

A = ((a+b)*(a-b))
B = (3*5)

Operation 1 = A + B (ordre 0)

A est ensuite fait de :

Operation 2 :

A = A' * B' (ordre 1)

A' = a + b
B" = a - b

d'ou :

Operation 3 :

A' = a + b (ordre 2)

Opération 4 :

B" = a - b (ordre 2)

et enfin

Opération 5 : (ordre 1)

B = 3 * 5

Et tu fais les opérations par ordre décroissant :

tu commences par calculer A', puis B' (ordre 2)
puis A puis B (ordre 1)
et enfin l'opération 1 (ordre 0)

Voilà...

Si tu prends la structure que j'ai indiqué plus haut (en C, mais le principe est valable quel que soit le langage)

* le type est si c'est +, -, *, / ou .....
* l'ordre est le niveau de profondeur (voir ci-dessus)
* First et Second désignent les opérandes (gauche et droite) si ce sont les éléments ultimes (exemple ici a et b) et non le résultat d'une opération
* FirstOper et SecondOper désignent des opérandes (gauche ou droite) qui seraient le résultat d'une opération (exemple ici A ou B)

Donc en gros pour l'opération indiquée ci-dessus :

tableau de 5 opérations :

1 er élément : type = +
First = a
Second = b

2 ...............: type = -
First = a
Second = b

3 ............... : type = *
FirstOper = 1ere opération
SecondOper = 2nde opération

4 .................: type = *
First = 3
Second = 5

5 .................: type = +
FirstOper = 3ième opération
SecondOper = 4ième opération

**Spinoza23** · 15/02/2007, 09h17

Mouais... c'est pas très clair pour moi... mais je comprend ce que tu veux dire... mais dans le cas suivant, tu fais comment ??

Code :

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

Dans le cas où [valeur1 ou expression1] est égal à [valeur2 ou expression2] affiché [valeur3 ou expression3] sinon si égal à [valeur4 ou expression4] affiché [valeur5 ou expression5] … sinon affiché [valeur6 ou expression6]

J'ais des cas tellement varient que c'est pas facile...

et si pour ce que tu as poster avant tu pouvais me montrer un bout d'algo ca m'aiderai vraiment... Je te remercie

**souviron34** · 15/02/2007, 13h26

c'est juste un type d'opération supplémentaire : OPER_TESTEGAL

En gros si je suis ton post, quasiment chaque ligne de ton encart

Addition de [valeur1 ou expression1] avec [valeur2 ou expression2]
Soustraction de [valeur1 ou expression1] avec [valeur2 ou expression2]
Multiplication de [valeur1 ou expression1] avec [valeur2 ou expression2]
Division de [valeur1 ou expression1] avec [valeur2 ou expression2]
Arrondi la [valeur1 ou expression1] sur [valeur2 ou expression2] décimal
Partie entière de [valeur1 ou expression1]
Entier supérieur à [valeur1 ou expression1]
Valeur absolue de [valeur1 ou expression1]
Signe de [valeur1 ou expression1]
Elève [valeur1 ou expression1] à la puissance [valeur2 ou expression2]
Modulo de [valeur1 ou expression1] par [valeur2 ou expression2]
Racine carrée de [valeur1 ou expression1]
Concaténation de [valeur1 ou expression1] avec [valeur2 ou expression2]
Longueur de [valeur1 ou expression1]
Extraction de [valeur1 ou expression1] à partir de [valeur2 ou expression2] sur une longueur de [valeur3 ou expression3]
Position de [valeur1 ou expression1] dans [valeur2 ou expression2]
Suppression des espaces à gauche de [valeur1 ou expression1]
Suppression des espaces à droite de [valeur1 ou expression1]
Conversion en Majuscule de [valeur1 ou expression1]
Conversion en Minuscule de [valeur1 ou expression1]
Conversion en texte de [valeur1 ou expression1] sur une longueur de [valeur2 ou expression2]
Conversion en numérique de [valeur1 ou expression1]
Code ASCII du caractère [valeur1 ou expression1]
Caractère du code ASCII [valeur1 ou expression1]
Si [aleur1 ou expression1] est NULL affiché [valeur2 ou expression2]
Première valeur non NULL dans [valeur1 ou expression1], [valeur2 ou expression2], …..
Dans le cas où [valeur1 ou expression1] est égal à [valeur2 ou expression2] affiché [valeur3 ou expression3] sinon si égal à [valeur4 ou expression4] affiché [valeur5 ou expression5] … sinon affiché [valeur6 ou expression6]
Moyenne de [valeur1 ou expression1]
Somme de [valeur1 ou expression1]
Minimum de [valeur1 ou expression1]
Maximum de [valeur1 ou expression1]
Nombre de valeur de [valeur1 ou expression1]
Nombre de valeur distincte [[u]valeur1 ou expression1]

est un type d'opération (avec quelques redondances)

Tu te définis donc une suite de #define représentant chacune de ces opérations.

Puis (avec par exemple la structure Operation indiquée plus haut) tu te définis un tableau de ces structures, en mettant les bons champs, et en ajustant l'ordre..

Enfin tu fais rouler... En faisant par exemple comme j'ai indiqué (une boucle sur toutes les opérations, puis un switch sur le type)..

Pour l'exemple, j'en ai un mais il est beaucoup trop compliqué, et j'ai vraiment pas le temps de te le mettre à jour. Mais avec le principe ci-dessus tu devrais t'en sortir...

PS: tu peux même rajouter (avant de créer le tableau) le fait de rentrer (ou de setter directement) une chaîne de caractères (ou l'ensemble comme cité) et de faire une petite analyse syntaxique, afin de pouvoir créer dynamiquement le tableau des structures. (j'ai bien cet exemple, mais franchement comme c'était intégré à un gros logiciel, ce sera plus compliqué de le comprendre que d'essayer de mettre à plat ce que je viens de te dire).

Principe :

Entrez l'opération :
if ( pow ( ((a + b) * (c + d)), 6 ) + sqrt( ((e+f)/4) ) == VAL1 ) printf ("toto")
else
printf ("tata")

Analyse syntaxique :

pow
sqrt
+
*
/

Création du tableau

+ (a , b , Priorité 1)
+ (c , d , Priorité 1)
* (résultat de 1, résultat de 2, Priorité 2 )
+ (e , f , Priorité 2)
/ (résultat de 4, 4, Priorit 2 )
pow (résultat de 3, 6, Priorité 3)
sqrt (résultat de 5, , Priorité 3)
+ (résultat de 6, résultat de 7, Priorité 4)

Là tu as le résultat.

Et maintenant tu peux soit faire la même chose avec les traitements (opération TEST_EGAL, PRINT, etc..) soit juste te servir du résultat dans un code normal...

**Zavonen** · 15/02/2007, 14h03

Il s'agit d'un problème plus que classique d'évaluation d'expressions (ici algébriques).
Indépendament du langage il faut d'abord définir la GRAMMAIRE servant à définir les expressions que l'on veut évaluer.
Ces grammaires s'écrivent généralement avec le formalisme BNF, et on en trouve toutes faites sous forme de listes de règles de substitution.
Du genre:
Expression := Constante
Expression := Variable
Expression:= ( Expression )
Expression := ( Expression OperateurBinaire Expression)
.....
OperateurBinaire := { +, -, *, /}
Constante := Tout flottant double précision (ou autre type)
Variable := Toute lettre majuscule (par exemple)

La grammaire définit donc un ensemble de chaînes de caractères répondant à la définition d'une "expression". Plus cet ensemble de règles est conséquent et plus les expressions que l'on peut traiter sont complexes.

Il faut ensuite fournir un second ensemble de règles permettant l'évaluation d'une expression.
L'évaluation se fait en général dans un certain environnement E (ensemble de liaisons variables-valeurs):
Ces règles peuvent être du genre:
Val(Constante,E) = sa valeur (rien à faire) indépendant de E
Val (X) = La valeur liée à X dans E
Val((Exp),E) = Val(Exp,E)
Val (Exp1 OB Exp2) = Opérateur OB appliqué aux arguments ValExp1 et ValExp2

Donc, avant même de commencer il faut écrire noir sur blanc, et sans rapport avec aucun langage de programmation l'ensemble des expressions qu'on veut reconnaître et évaluer.

Ensuite il faut traduire les règles édictées dans le langage cible, tout dépend de ce que le langage prévoit (des listes, des A-lists, des 'maps', etc...)

Ce que vous souhaitez écrire n'est en fait qu'une interface utlisateur pour l'évaluation d'expressions, permettant d'écrire une expression (j'allais dire lambda ...) sous une forme de complexité quelconque résultant de l'application itérée des règles de la grammaire.

Il faut donc prévoir pour chaque membre gauche des règles de la grammaire la liste complète des membres droits correspondants. On peut charger une fonction spécialisée de faire ce travail de recherche dans la grammaire.

Ensuite vous présentez au départ votre expression sous la forme d'un seule bouton poussoir 'Expression'. Cliquer sur ce bouton devra vous faire apparaître la liste déroulante des définitions possibles de 'Expression'. Vous en choisissez une et aussitôt le bouton est remplacé par un ensemble de boutons et de symboles correspondant à votre choix, et ainsi de suite récursivement.

Donc l'objet traité par l'interface doit être une suite d'objets graphiques d'une librairie spécialisée (par exemple AWT ou SWING pour JAVA), dont certains sont clicables et d'autres non. Il faut donc écrire les méthodes de substitution résultant du clic d'un bouton,ainsi que la méthode d'affichage linéaire d'un tel objet dans une zone reservée de la fenêtre (container).

Il vous faut ensuite prévoir dans deux zones séparées:
Une zone de définition de l'environnement
Un bouton 'EVAL'
Une zone de texte 'Resultat'.

Quand vous cliquez EVAL, si l'environnement est suffisant (toutes les variables affectées) le programme affichera le résultat dans la case spécialisée.

A votre place j'investirai d'abord dans le formalisme BNF et d'une façon générale les comportements liés à des ensembles (généralement récursifs) de règles.
Puis ensuite dans les librairies d'objets graphiques de Java, et éventuellement dans des logiciels permettant de créer des RAD (Javabeans par exemple)

Votre programme, qui je suppose a un but pédagogique, s'écrira ensuite 'tout seul'.

Si vous prenez tout ça par le mauvais bout (traitement de chaînes complexes) vous souffrirez beaucoup et cette souffrance ne sera pas formatrice.

**Spinoza23** · 16/02/2007, 15h35

Finalement je vais me débrouiller autrement... Je vais découper les chaines de caractères en sous chaines... et ensuite remplacer les éléments nécessaire grace a des methodes.... merci pour votre aide a tous !!!

Besoin d'aide pour un Algo

Mathématiques

Discussions similaires

Partager

Partager