Discussion :

[oyigit]

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 ?

[theMonz31]

salut

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

Cherches des discussions sur la compilation dynamique ici

The Monz, Toulouse

[dahtah]

Par récursivité :
voilà un exemple tout fait.

[ced600]

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

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

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

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
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

[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 ?

[oyigit]

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

[Bluedeep]

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 :

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
 
 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.

[ced600]

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

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 !!!

[Bluedeep]

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

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).

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).

[ced600]

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

[sunwave]

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.

[ZaaN]

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