Intérpreter un calcul arithmétique

Version imprimable

21/12/2007, 10h26
oyigit

Intérpreter un calcul arithmétique

Bonjour,

J'ai besoin d'intérpreter une fonction arithmétique que je reçois sous forme de chaine de caractère.

ex :

J'ai : "((178/14)*45+(14/2)*(11/4))".
Il faudrait que je puisse récupérer le résultat de cette chaîne de caractère.

Y'a t'il un moyen efficace de réaliser le calcul ? De quel façon procéder ?
21/12/2007, 10h28
theMonz31

salut

tu compiles l'expression à la volée par exemple :)

Cherches des discussions sur la compilation dynamique ici :)

The Monz, Toulouse
21/12/2007, 10h41
dahtah

Par récursivité :
voilà un exemple tout fait.
21/12/2007, 10h42
ced600

Cela me rapelle une calculatrice polonaise que j'avais fait à l'école. :D

Ce que tu doit faire est simple :
Lecture un à un des caractère, et regroupement des type de caractère dans différentes piles.

Commençont avec un exemple simple :
4 + 2 * 3

Tu lit caractère par caractere et tu met les chiffre dans une pile et les opérateurs dans une autre. Au passage convertis tes chiffres en int.

Tu obtiens deux pile :

pile1 pile2
3 *
2 +
4 rien :D

Bah la reste plus qu'à dépiler :
Tu dépile 3 et 2, puis *. Tu testes le caractère et tu détermines que c'est *, alors tu peux faire 3*2.
Tu empile le résultat dans ta pile 1 et on a :

pile1 pile2
6 +
4 rien :D

Tu recommence l'opération jusqu'à ce que ta pile 2 soit vide et tu affiche le résultat finale.

Après te reste plus qu'à gérer les parenthèses, le plus dure.

Moi je les empiler avec les chiffres. Puis le les dépiler et n'en faisait pas grand chose, mais lorsque je tomber sur un séquence de dépilement chiffre, opérateur, parenthèse ouvrante, je savais que je devais d'abord calculer la suite avant de faire l'opération.
Tu peux utiliser la récursivité pour le faire en envoyant une partie des deux piles jusqu'à la parenthèse fermante :D
En même temps utilise un compteur que tu incrémente lorsque tu rencontre les parenthèse ouvrante, et décremente lorsque c'est une fermante.
Cela te permettra de vérifier si le gars s'est tromper sur le nombre de parenthèses :D
21/12/2007, 10h42
oyigit

Ok, c'est une idée que j'avait en tête, mais que je souhaitais justement éviter.
Désolé de ne pas l'avoir préciser avant.
Connaîtriez-vous un autre moyen de procéder ?
21/12/2007, 10h44
oyigit

L'idée des piles me semble la plus convaincante pour mon problème... Je vais regarder ça de plus près... Merci

La compilation à la volée est la solution de loin la plus simples.

voici un bout de code qui calcul ce genre d'expression :

Code:

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
 
 public double ComputeMathFormula(string formula)
 {
     double result = double.NaN;
     CodeCompileUnit unit = prepareCompileUnit( formula );
     Assembly dynamicAssembly = compileCode( unit, "CSharp" );
     if (dynamicAssembly != null)
     {
          object formulaComputer = dynamicAssembly.CreateInstance( "DynGen.Compute.formulaComputing", true );
           MethodInfo computeFormula = formulaComputer.GetType().GetMethod( "computeFormula" );
            result = (double)computeFormula.Invoke( formulaComputer, null );
      }    
     return result;
  }
 private Assembly compileCode( CodeCompileUnit compileunit, string language )
 {
     CompilerParameters compilerParameters = new CompilerParameters();
     compilerParameters.ReferencedAssemblies.Add( "System.dll" );
     compilerParameters.GenerateExecutable = false;
     compilerParameters.GenerateInMemory = true;
     compilerParameters.IncludeDebugInformation = false;
     compilerParameters.WarningLevel = 1;
      // compile.
     CodeDomProvider provider = CodeDomProvider.CreateProvider( language );
     CompilerResults compilerResults = provider.CompileAssemblyFromDom( compilerParameters, compileunit );
 
     // Return assembly if compilation OK - otherwise return null
     return (compilerResults.Errors.Count == 0) ? compilerResults.CompiledAssembly : null;
}
 
 
private CodeCompileUnit prepareCompileUnit( string formulaString )
{
     CodeNamespace compute = new CodeNamespace( "DynGen.Compute" );
     compute.Imports.Add( new CodeNamespaceImport( "System" ) );           
     CodeCompileUnit compileUnit = new CodeCompileUnit();
     compileUnit.Namespaces.Add( compute );
     CodeTypeDeclaration formulaComputing = new CodeTypeDeclaration( "formulaComputing" );
     compute.Types.Add( formulaComputing );
     CodeMemberMethod computeFormulaCode = new CodeMemberMethod();
     computeFormulaCode.Attributes = MemberAttributes.Public;
     computeFormulaCode.Name = "computeFormula";
     computeFormulaCode.ReturnType = new CodeTypeReference( typeof( double ) );
     CodeSnippetExpression formula = new CodeSnippetExpression( formulaString );
     CodeMethodReturnStatement computeFormulaReturnStatement = new CodeMethodReturnStatement( formula );
     computeFormulaCode.Statements.Add( computeFormulaReturnStatement );
 
     formulaComputing.Members.Add( computeFormulaCode );
     return compileUnit;
}

Ca peut manger aussi quelque chose comme
(Math.Cos(10.2) * Math.Sin(Math.PI/2))

Mais il faut préfixer les fonctions par "Math."
Tu peux éviter cela en parsant la chaine, bien sur.

21/12/2007, 11h53
ced600

Heu....
Ton code est loin d'être simple lorsque l'on ne connait pas les classes qu'il utilise (mon cas :D )

Autrement ma version avec les piles et loin d'être simple. Je me suis amuser à déterminer la routine à respecter pour la gestion des parenthèses dans la pile et c pas simple.
Limite il faut splitter avec ( et ) pour simplifier les choses. Et encore...

Pourtant ma calculatrice polonaise en ADA marchais, j'ai du oublier un truc dans le raisonnement.
Si je me souviens bien la polonaise marche ainsi :
2 (3 4) 5 *+/
Donc pour passer de 2*(3+4)/5 à 2 (3 4) 5 *+/ me parait connecte. Mais après je ne retrouve plus le bon moyen pour gérer les parenthèses !!!
21/12/2007, 12h00
Bluedeep

Citation:

Envoyé par ced600

Heu....
Ton code est loin d'être simple lorsque l'on ne connait pas les classes qu'il utilise (mon cas :D )

Peut être mais il est capable de "bouffer" n'importe quelle expression de calcul, pourvu qu'elle utilise la syntaxe C# (ou VB, il suffit de changer un paramètre - accessoirement, ça supporte aussi les syntaxes javascript).

Il lui manque un parser pour reconnaitre les fonctions mathématiques sans avoir à les invoquer dans la classe Math explicitement (tu peux utiliser les méthodes statique de la classe Math, mais il faut écrire Math.Cos par exemple : une amélioration consisterait à chercher les mots pour voir si ils correspondent à une méthode de la classe Math, afin d'avoir une syntaxe plus transparente - moins ".Net" quoi).

Citation:

Autrement ma version avec les piles et loin d'être simple.

Je pense que c'est même nettement plus compliqué que ma solution (qui est la plus simple que j'ai trouvée), mais c'est vrai que la notation polonaise inversée c'est sympa (les premières calculettes HP implémentant cela sont sorties en 73 - de mémoire).
21/12/2007, 12h11
ced600

Citation:

Peut être mais il est capable de "bouffer" n'importe quelle expression de calcul, pourvu qu'elle utilise la syntaxe C# (ou VB, il suffit de changer un paramètre - accessoirement, ça supporte aussi les syntaxes javascript).

Il est vrai qu'avec ma méthode cela serait un peu galère :mrgreen:
04/06/2008, 09h31
sunwave

code

Bonjour,

j'ai besoin de mettre en place cela pour mon boulot mais ce n'était pas prévu dans la charge.

J'ai juste besoin en C# de pouvoir connaitre le résultat d'un string avec des +, -, /, *, (, ) et - unaire style : "-4*(5+6+9)/18"

Le code fourni est intéressant mais il manque le parsing.

Il doit bien avoir du code qui a été développé déjà pour cela et qui a été testé par d'autres utilisateurs.

Si vous pouviez m'orienter. ;)
04/06/2008, 13h21
ZaaN

tu peux generer un lexer/parser C# (basé sur une grammaire) super vite avec ANTLR par exemple.