Méthode d'évaluation d'expressions mathématiques en Java

Il y a aussi exp4j, un évaluateur d'expression basé sur Dijkstra's Shunting Yard. Il est librement disponible et redistribuable sous le Apache License 2.0, seulement environ 25KB en taille et assez facile à utiliser:

Calculable calc = new ExpressionBuilder("3 * sin(y) - 2 / (x - 2)")
        .withVariable("x", varX)
        .withVariable("y", varY)
        .build()
double result1=calc.calculate();

Lors de l'utilisation d'une version d'API plus récente comme 0.4.8:

Expression calc = new ExpressionBuilder("3 * sin(y) - 2 / (x - 2)")
    .variable("x", x)
    .variable("y", y)
    .build();
double result1 = calc.evaluate();

, Il existe également une facilité d'utilisation des fonctions personnalisées dans exp4j.

Cela dépend de la complexité des expressions que vous souhaitez évaluer, mais pour les expressions simples, java a un moteur javascript qui fonctionne plutôt bien:

import javax.script.*;
public class EvalScript {
public static void main(String[] args) throws Exception {
    // create a script engine manager
    ScriptEngineManager factory = new ScriptEngineManager();
    // create a JavaScript engine
    ScriptEngine engine = factory.getEngineByName("JavaScript");
    // evaluate JavaScript code from String
    Object obj = engine.eval("1+2");
    System.out.println( obj );
    }
}

Pour étendre la liste, je viens d'en terminer une aussi:

Https://github.com/uklimaschewski/EvalEx

EvalEx est un évaluateur d'expression pratique pour Java, qui permet d'évaluer des expressions mathématiques et booléennes simples.

Principales caractéristiques:

• Utilise BigDecimal pour le calcul et le résultat
• Implémentation de classe unique, très compacte
• Aucune dépendance aux bibliothèques externes
• Précision et arrondi mode peut être ensemble
• Prend en charge les variables
• Opérateurs booléens et mathématiques standard
• Fonctions mathématiques et booléennes de base standard
• Des fonctions et des opérateurs personnalisés peuvent être ajoutés à l'exécution

Exemples:

BigDecimal result = null;

Expression expression = new Expression("1+1/3");
result = expression.eval():
expression.setPrecision(2);
result = expression.eval():

result = new Expression("(3.4 + -4.1)/2").eval();

result = new Expression("SQRT(a^2 + b^2").with("a","2.4").and("b","9.253").eval();

BigDecimal a = new BigDecimal("2.4");
BigDecimal b = new BigDecimal("9.235");
result = new Expression("SQRT(a^2 + b^2").with("a",a).and("b",b).eval();

result = new Expression("2.4/PI").setPrecision(128).setRoundingMode(RoundingMode.UP).eval();

result = new Expression("random() > 0.5").eval();

result = new Expression("not(x<7 || sqrt(max(x,9)) <= 3))").with("x","22.9").eval();

Nice mathématiques analyseur contenant large mathématiques collection - mXparser - s'il vous plaît voir les exemples:

Exemple 1:

import org.mariuszgromada.math.mxparser.*;
...
...
Argument x = new Argument("x = pi");
Expression e = new Expression("sin(x + pi)/2 + 1", x);
mXparser.consolePrintln("Res 1: " + e.getExpressionString() + " = " + e.calculate());
x.setArgumentValue(2);
mXparser.consolePrintln("Res 2: " + e.getExpressionString() + " = " + e.calculate());

Résultat:

[mXparser-v.4.0.0] Res 1: sin(x + pi)/2 + 1 = 1.0
[mXparser-v.4.0.0] Res 2: sin(x + pi)/2 + 1 = 0.545351286587159

Exemple 2:

import org.mariuszgromada.math.mxparser.*;
...
...
Function f = new Function("f(x) = sin(x + pi)/2 + 1");
Expression e = new Expression("f(pi)", f);
mXparser.consolePrintln("Res: " + e.getExpressionString() + " = " + e.calculate());

Résultat:

[mXparser-v.4.0.0] Res: f(pi) = 1.0

Pour une meilleure compréhension, veuillez suivre mXparser tutoriel et mXparser mathématiques collection.

Meilleures salutations

J'ai un évaluateur de mathématiques de petite taille mais très capable qui est complètement non encombré.

Caractéristiques principales

• mathématiques de Base des opérateurs, avec déduite de priorité (+ - * × / ÷ % ^).
• Priorité explicite avec parenthèse.
• Multiplication implicite des sous-expressions entre crochets.
• Droite correcte-associativité des exponentielles (opérateur de puissance).
• Prise en charge directe des nombres hexadécimaux préfixé par 0x.
• Constantes et variables.
• Fonctions extensibles.
• Opérateurs extensibles.
• Minuscule empreinte de 20 Ko.

Voici un exemple simple qui calcule la colonne du milieu de la sous-section d'un affichage de texte (biaisé à gauche).

MathEval            math=new MathEval();

math.setVariable("Top",    5);
math.setVariable("Left",  20);
math.setVariable("Bottom",15);
math.setVariable("Right", 60);

System.out.println("Middle: "+math.evaluate("floor((Right+1-Left)/2)"));                        // 20

En ajoutant une autre option à la liste, j'ai écrit Jep Java qui a gagné beaucoup de popularité en tant que projet open source sur sourceforge .

Il prend en charge toutes les tâches courantes de base de l'analyse d'expression. Mais il ajoute également beaucoup d'extensibilité si vous souhaitez le personnaliser. Beaucoup d'utilisateurs ont fait l'éloge de la bibliothèque pour être particulièrement bien écrit et facile à utiliser. Voir les commentaires sourceforge!

Voici un exemple simple avec une seule variable:

import com.singularsys.jep.Jep;

Jep jep = new Jep();
jep.addVariable("x", 10);
jep.parse("x+1");
Object result = jep.evaluate();
System.out.println("x + 1 = " + result);

Cette volonté imprimer "x + 1 = 11". Vous pouvez modifier la valeur des variables et évaluer à nouveau rapidement l'expression.

Plus tard, j'ai également rendu la bibliothèque disponible avec une licence commerciale sur le site Web Singular Systems.

J'ai déjà posté une réponse similaire ici. Je voulais juste dire que j'ai travaillé sur une petite bibliothèque qui prend en charge l'évaluation des expressions mathématiques, booléennes et string. Voici un petit exemple :

String expression = "EXP(var)";
ExpressionEvaluator evaluator = new ExpressionEvaluator();
evaluator.putVariable(new Variable("var", VariableType.NUMBER, new BigDecimal(20)));

System.out.println("Value of exp(var) : " + evaluator.evaluate(expression).getValue());

Si vous êtes intéressé, il est disponible ici.