matematicas - arbol de expresiones aritmeticas java

Método para evaluar expresiones matemáticas en Java

Question

En uno de mis proyectos, quiero agregar una función que el usuario puede proporcionar en una fórmula, por ejemplo

sin (x + pi)/2 + 1

que utilizo en mi aplicación Java

/**
 * The formula provided by the user
 */
private String formula; // = "sin (x + pi)/2 + 1"

/*
 * Evaluates the formula and computes the result by using the
 * given value for x
 */
public double calc(double x) {
    Formula f = new Formula(formula);
    f.setVar("x", x);
    return f.calc();
    // or something similar
}

¿Cómo puedo evaluar expresiones matemáticas?

Answer 1

Añadiendo otra opción a la lista, escribí Jep Java que ganó mucha popularidad como proyecto de código abierto en sourceforge .

Es compatible con todas las tareas básicas comunes de análisis de expresiones. Pero también agrega mucha extensión si desea personalizarlo. Muchos usuarios elogiaron a la biblioteca por estar especialmente bien escrita y ser fácil de usar. ¡Mira las reseñas de sourceforge!

Aquí hay un ejemplo simple con una sola 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);

Esto imprimirá "x + 1 = 11". Puede cambiar el valor de las variables y evaluar rápidamente la expresión nuevamente.

Más tarde también hice disponible la biblioteca con una licencia comercial en el sitio web de Singular Systems .

Answer 2

Buen analizador matemático que contiene una amplia colección matemática - mXparser - vea los ejemplos:

Ejemplo 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());

Resultado:

[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

Ejemplo 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());

Resultado:

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

Para una mejor comprensión, siga el tutorial mXparser y la colección matemática mXparser .

Atentamente

Answer 3

Depende de qué tan complejas son las expresiones que desea evaluar, pero para las más simples, java tiene un motor de JavaScript que funciona bastante 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 );
    }
}

Answer 4

Para extender la lista, simplemente he terminado una, también:

https://github.com/uklimaschewski/EvalEx

EvalEx es un útil evaluador de expresiones para Java, que permite evaluar expresiones matemáticas y booleanas simples.

Características principales:

• Utiliza BigDecimal para el cálculo y el resultado
• Implementación de clase única, muy compacta
• Sin dependencias a bibliotecas externas
• Se puede configurar el modo de precisión y redondeo
• Soporta variables
• Operadores booleanos y matemáticos estándar
• Funciones matemáticas y booleanas básicas estándar
• Se pueden agregar funciones y operadores personalizados en tiempo de ejecución

Ejemplos:

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();

Answer 5

También hay exp4j , un evaluador de expresiones basado en Dijkstra''s Shunting Yard . Está disponible y redistribuible de forma gratuita bajo Apache License 2.0 , de solo 25KB de tamaño y bastante fácil de usar:

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

Al usar una versión de API más nueva como 0.4.8 :

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

También hay una instalación para usar funciones personalizadas en exp4j .

Answer 6

Tengo un pequeño evaluador de matemáticas pero muy capaz que está completamente libre de cargas.

Características principales

• Operadores matemáticos básicos, con precedencia inferida ( + - * × / ÷ % ^ ).
• Precedencia explícita con paréntesis.
• Multiplicación implícita de subexpresiones entre corchetes.
• Corrija la asociatividad a la derecha de exponenciales (operador de potencia).
• Soporte directo para números hexadecimales con el prefijo 0x .
• Constantes y variables
• Funciones extensibles.
• Operadores extensibles
• Diminuta huella de 20 KiB.

Aquí hay un ejemplo simple que calcula la columna central de la subsección de una pantalla de texto (sesgada a la izquierda).

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

Answer 7

Ya he publicado una respuesta similar here . Solo quería decir que he trabajado en una pequeña biblioteca que admite la evaluación matemática, booleana y de expresión de cadenas. Aquí hay un pequeño ejemplo:

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 estás interesado, está disponible here .