Meilleur et le plus court chemin pour évaluer des expressions mathématiques

Il existe de nombreux algorithmes pour évaluer des expressions, par exemple:

  1. Par Descente Récursive
  2. Shunting-yard algorithme
  3. La notation polonaise inversée

Est-il possible d'évaluer une expression mathématique à l'aide de C# .net la réflexion ou l'autre moderne .net de la technologie?

  • J'ai posé une question similaire a tout à l'arrière. Vous pouvez regarder quelques unes de ces réponses: stackoverflow.com/questions/234217/...
  • Avez-vous trouvé un moyen de relier les variables utilisées dans le reste de la "statique/pré-compilé" code?
InformationsquelleAutor Arsen Mkrtchyan | 2009-09-17
  1. 19

    Suite à la réponse de Thomas, il est possible d'accéder à l' (obsolète) JScript bibliothèques directement à partir de C#, ce qui signifie que vous pouvez utiliser l'équivalent de JScript du eval fonction.

    using Microsoft.JScript;        //needs a reference to Microsoft.JScript.dll
using Microsoft.JScript.Vsa;    //needs a reference to Microsoft.Vsa.dll

//...

string expr = "7 + (5 * 4)";
Console.WriteLine(JScriptEval(expr));    //displays 27

//...

public static double JScriptEval(string expr)
{
    //error checking etc removed for brevity
    return double.Parse(Eval.JScriptEvaluate(expr, _engine).ToString());
}

private static readonly VsaEngine _engine = VsaEngine.CreateEngine();
    • Dommage qu'il ne supporte pas l'accent circonflexe ^ pour l'exponentiation.
    InformationsquelleAutor LukeH
  2. 13

    C'est certainement possible. Le CodeSnippetCompileUnit classe ne fondamentalement, c'.
    Je vous ai écrit quelques exemples d'utilisation du code. Vous aurez besoin d'inclure ces espaces de noms:

    • Système.CodeDom.Compilateur;
    • Système.CodeDom;
    • Microsoft.CSharp;
    • Système.La réflexion;

    Voici le code:

    string source = @"
class MyType
{
    public static int Evaluate(<!parameters!>)
    {
        return <!expression!>;
    }
}
";

string parameters = "int a, int b, int c";
string expression = "a + b * c";

string finalSource = source.Replace("<!parameters!>", parameters).Replace("<!expression!>", expression);

CodeSnippetCompileUnit compileUnit = new CodeSnippetCompileUnit(finalSource);
CodeDomProvider provider = new CSharpCodeProvider();

CompilerParameters parameters = new CompilerParameters();

CompilerResults results = provider.CompileAssemblyFromDom(parameters, compileUnit);

Type type = results.CompiledAssembly.GetType("MyType");
MethodInfo method = type.GetMethod("Evaluate");

//The first parameter is the instance to invoke the method on. Because our Evaluate method is static, we pass null.
int result = (int)method.Invoke(null, new object[] { 4, -3, 2 });

    Remplacer "paramètres" et "l'expression" par quoi que ce soit, et vous avez vous-même une expression générale de l'évaluateur.

    Si vous obtenez une erreur FileNotFoundException dans les résultats.CompiledAssembly, puis l'extrait réussi à compiler.

    Vous pouvez également jeter un oeil à ce Système.CodeDom.CodeSnippetExpression classe. Il est utilisé pour plus spécifiquement la lecture des expressions, mais une expression en elle-même ne peut pas être compilé, vous devez utiliser plus CodeDom de construire un travail de classe et de méthode autour d'elle. Ceci est utile si vous voulez être en mesure de manipuler par programmation de ce genre de classe que vous générez. CodeSnippetCompileUnit est agréable de générer un ensemble de la classe ouvrière à la fois (et la plus simple pour un exemple), mais à manipuler que vous avez à faire qui dérange les manipulations de chaînes.

    • la meilleure solution.
    • Pour l'enregistrement, la performance de cette solution par rapport à l'aide ncalc est ÉNORME, je l'ai testé pour un grapher et certains multi fonctions de la variable a pris plus de 500 à ploted, avec ce qu'il m'a fallu moins de 5s ploting plus de 400 000 points. Excellente solution!
    InformationsquelleAutor Joren
  3. 3

    Bien que l'utilisation du compilateur services est une solution simple et efficace, elle pose de sérieux problèmes de sécurité si l'expression est entré par l'utilisateur, car il pourrait exécuter presque rien.

    Il y a une autre solution très simple qui est beaucoup plus sécurisé : profiter de la JScript Eval fonction. Il vous suffit de suivre ces étapes :

    Créer un fichier nommé js JsMath.js :

    class JsMath
{
    static function Eval(expression : String) : double
    {
        return eval(expression);
    };
}

    Compiler dans une bibliothèque de classe :

    jsc /t:library JsMath.js

    De référence de la JsMath bibliothèque dans votre projet C#, et de l'utiliser comme ça :

    double result = JsMath.Eval(expression);
    • Il est en fait possible d'accéder à la eval fonction directement à partir de C#, et sans l'intermédiaire JScript étape de compilation. Voir ma réponse pour plus de détails.
    • Pour éviter les problèmes de sécurité à l'aide du compilateur services-je utiliser ANTL de pré analyser l'utilisateur d'expression et d'éviter tout bizarre d'entrée. Si vous êtes à la recherche de la performance le eval() fonction peut ne pas fonctionner.
    InformationsquelleAutor Thomas Levesque
  4. 3

    Pour moi, Vici.Analyseur fonctionne très bien: découvrez-le ici , c'est le plus flexible analyseur d'expression que j'ai trouvé jusqu'à présent.

    (nous l'avons utilisé pour créer des " lisible par l'homme d'affaires des règles, avec des données fournies par une base de données SQL server)

    Exemples sont disponibles et il y a un très bon soutien par le développeur (consultez le site web du forum).

    • A l'air très intéressant.
    • Le lien est mort.
    InformationsquelleAutor Roel
  5. 3

    ncalc est le meilleur. vous pouvez le trouver dans codeplex également en pépite.

    NCalc est une des expressions mathématiques évaluateur dans .NET. NCalc peut analyser n'importe quelle expression et d'évaluer le résultat, y compris en statique ou en dynamique des paramètres et des fonctions personnalisées.

    InformationsquelleAutor Jalali Shakib
  6. 1

    Je pense que c'est le meilleur moyen de tous. Petar Repac réponse est incroyable.
    À l'aide de l'expression, de l'argument de l'objet DataColumn résout incroyablement et facilement le sujet:

    static double Evaluate(string expression)
{
    var loDataTable = new DataTable();
    var loDataColumn = new DataColumn("Eval", typeof(double), expression);
    loDataTable.Columns.Add(loDataColumn);
    loDataTable.Rows.Add(0);
    return (double)(loDataTable.Rows[0]["Eval"]);
}
    InformationsquelleAutor Pablo Guerra