boolean-expression-parser in java

Gibt es irgendwelche java-Bibliotheken und Verfahren zur Analyse von booleschen Ausdrücken Stückwerk?

Was ich meine ist mit einem Ausdruck wie diesem:

T && ( F || ( F && T ) )

Könnte es gebrochen werden nach unten in einen Ausdruck-Baum um zu zeigen, welche token geführt, dass die 'F' - Wert so (vielleicht sowas in der Art):

T &&               <- rhs false
    ( F ||         <- rhs false
        ( F && T ) <- eval, false
    )

Ich versuche zu kommunizieren Boolesche-Ausdruck-Auswertungen für nicht-Programmierer. Ich stocherte mit Anlr, aber ich konnte es nicht, viel zu tun (es scheint ein bisschen eine Lernkurve).

Habe ich nichts dagegen, es zu schreiben, mich selbst, aber ich möchte lieber nicht das Rad neu erfinden.

InformationsquelleAutor der Frage javamonkey79 | 2012-08-30

Habe ich codiert diese mit Javaluator.

Es ist nicht genau die Ausgabe, die du suchst, aber ich denke, es könnte ein Startpunkt.

package test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import net.astesana.javaluator.*;

public class TreeBooleanEvaluator extends AbstractEvaluator<String> {
  /** The logical AND operator.*/
  final static Operator AND = new Operator("&&", 2, Operator.Associativity.LEFT, 2);
  /** The logical OR operator.*/
  final static Operator OR = new Operator("||", 2, Operator.Associativity.LEFT, 1);

  private static final Parameters PARAMETERS;

  static {
    //Create the evaluator's parameters
    PARAMETERS = new Parameters();
    //Add the supported operators
    PARAMETERS.add(AND);
    PARAMETERS.add(OR);
    //Add the parentheses
    PARAMETERS.addExpressionBracket(BracketPair.PARENTHESES);
  }

  public TreeBooleanEvaluator() {
    super(PARAMETERS);
  }

  @Override
  protected String toValue(String literal, Object evaluationContext) {
    return literal;
  }

  private boolean getValue(String literal) {
    if ("T".equals(literal) || literal.endsWith("=true")) return true;
    else if ("F".equals(literal) || literal.endsWith("=false")) return false;
    throw new IllegalArgumentException("Unknown literal : "+literal);
  }

  @Override
  protected String evaluate(Operator operator, Iterator<String> operands,
      Object evaluationContext) {
    List<String> tree = (List<String>) evaluationContext;
    String o1 = operands.next();
    String o2 = operands.next();
    Boolean result;
    if (operator == OR) {
      result = getValue(o1) || getValue(o2);
    } else if (operator == AND) {
      result = getValue(o1) && getValue(o2);
    } else {
      throw new IllegalArgumentException();
    }
    String eval = "("+o1+" "+operator.getSymbol()+" "+o2+")="+result;
    tree.add(eval);
    return eval;
  }

  public static void main(String[] args) {
    TreeBooleanEvaluator evaluator = new TreeBooleanEvaluator();
    doIt(evaluator, "T && ( F || ( F && T ) )");
    doIt(evaluator, "(T && T) || ( F && T )");
  }

  private static void doIt(TreeBooleanEvaluator evaluator, String expression) {
    List<String> sequence = new ArrayList<String>();
    evaluator.evaluate(expression, sequence);
    System.out.println ("Evaluation sequence for :"+expression);
    for (String string : sequence) {
      System.out.println (string);
    }
    System.out.println ();
  }
}

Hier ist die Ausgabe:

Ablauf einer Prüfung für :T && F || ( F && T ) )

(F && T)=false

(F || (F && T)=false)=false

(T && F || (F && T)=false)=false)=false

Evaluierung der Sequenz :(T && T) || ( F && T )

(T && T)=true

(F && T)=false

((T && T)=true || (F && T)=false)=true

InformationsquelleAutor der Antwort Jean-Marc Astesana

Man könnte dies mit MVEL oder JUEL. Beide sind Ausdruck, Sprache, Bibliotheken, Beispiele unter Verwendung von MVEL.

Beispiel:

System.out.println(MVEL.eval("true && ( false || ( false && true ) )"));

Prints:
falsche

Wenn Sie buchstäblich verwenden möchten 'T' und 'F' können Sie dies tun:

Map<String, Object> context = new java.util.HashMap<String, Object>();
context.put("T", true);
context.put("F", false);
System.out.println(MVEL.eval("T && ( F || ( F && T ) )", context));

Prints:
falsche

InformationsquelleAutor der Antwort Dev

5

Habe ich vor kurzem zusammen eine Bibliothek in Java, die speziell zum manipulieren von booleschen Ausdrücken: jbool_expressions.

Enthält es ein tool zu analysieren, Ausdrücke aus der string-input:
```
Expression<String> expr = ExprParser.parse("( ( (! C) | C) & A & B)")
```
Können Sie auch tun, einige relativ einfache Vereinfachung:
```
Expression<String> simplified = RuleSet.simplify(expr);
System.out.println(expr);
```
gibt
```
(A & B)
```
Wenn Sie wollte, Schritt durch die Zuordnung könnte dann Werte zuweisen. Für das Beispiel hier,
```
Expression<String> halfAssigned = RuleSet.assign(simplified, Collections.singletonMap("A", true));
System.out.println(halfAssigned);
```
zeigt
```
B
```
und Sie konnte es lösen durch die Zuordnung von B.
```
Expression<String> resolved = RuleSet.assign(halfAssigned, Collections.singletonMap("B", true));
System.out.println(resolved);
```
zeigt
```
true
```
Nicht 100% das, was Sie forderten, aber hoffe es hilft.

InformationsquelleAutor der Antwort bpodgursky
1

Check-out BeanShell. Es hat Ausdruck analysieren, akzeptiert Java-ähnlichen syntax.

EDIT:es sei denn, Sie versuchen tatsächlich zu analysieren T && F wörtlich, obwohl man könnte dies in BeanShell die Verwendung der Literale true und false.

InformationsquelleAutor der Antwort Brian

mXparser Griffe Boolesche Operatoren - finden Sie einige Beispiele

Beispiel 1:

import org.mariuszgromada.math.mxparser.*;
...
...
Expression e = new Expression("1 && (0 || (0 && 1))");
System.out.println(e.getExpressionString() + " = " + e.calculate());

Ergebnis 1:

1 && (0 || (0 && 1)) = 0.0

Beispiel 2:

import org.mariuszgromada.math.mxparser.*;
...
...
Constant T = new Constant("T = 1");
Constant F = new Constant("F = 0");
Expression e = new Expression("T && (F || (F && T))", T, F);
System.out.println(e.getExpressionString() + " = " + e.calculate());

Ergebnis 2:

T && (F || (F && T)) = 0.0