Логический выражающий парсер в java

Существуют ли какие-либо java-библиотеки или методы для разбора булевых выражений по частям?

То, что я имею в виду, дается выражение вроде этого:

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

Его можно разбить на дерево выражений, чтобы показать, какой токен вызвал значение "F", например (возможно, что-то вроде этого):

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

Я пытаюсь передать оценки булевых выражений не-программистам. Я ткнулся с Анлром, но я не мог заставить его делать многое (похоже, у него немного кривая обучения).

Я не против писать сам, но лучше не изобретать велосипед.

Ответ 1

Я закодировал это, используя Javaluator.
Это не тот результат, который вы ищете, но я думаю, что это может быть отправной точкой.

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

Вот вывод:

Последовательность оценки для: T && (F || (F & T))
(F && T) = false (F || (F && T) = false) = false (T && (F || (F & T) = false) = false) = false

Последовательность оценки для: (T & T) || (F & T)
(T & T) = истинное значение (F && T) = false ((T & T) = true || (F && T) = false) = true

Ответ 2

Вы можете сделать это с помощью MVEL или JUEL. Обе библиотеки языка выражений, примеры ниже используют MVEL.

Пример:

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

Печать: ложь

Если вы буквально хотите использовать "T" и "F", вы можете сделать это:

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

Печать: ложь

Ответ 3

Недавно я собрал библиотеку в Java для управления булевыми выражениями: jbool_expressions.

Он включает в себя инструмент, который также анализирует выражения из строкового ввода:

Expression<String> expr = ExprParser.parse("( ( (! C) | C) & A & B)")

Вы также можете сделать довольно простое упрощение:

Expression<String> simplified = RuleSet.simplify(expr);
System.out.println(expr);

дает

(A & B)

Если вы хотите выполнить задание, вы можете назначать значения один за другим. Для примера здесь

Expression<String> halfAssigned = RuleSet.assign(simplified, Collections.singletonMap("A", true));
System.out.println(halfAssigned);

показывает

и вы можете решить его, назначив B.

Expression<String> resolved = RuleSet.assign(halfAssigned, Collections.singletonMap("B", true));
System.out.println(resolved);

показывает

true

Не 100% того, что вы просили, но надеюсь, что это поможет.

Ответ 4

Отъезд BeanShell. Он имеет синтаксический анализ выражений, который принимает синтаксис, подобный Java.

РЕДАКТИРОВАТЬ: Если вы не пытаетесь фактически разобрать T && F буквально, хотя вы можете сделать это в BeanShell, используя литералы true и false.

Ответ 5

mXparser обрабатывает логические операторы - пожалуйста, найдите несколько примеров

Пример 1:

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

Результат 1:

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

Пример 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());

Результат 2:

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

Подробнее см. учебник mXparser.

С наилучшими пожеланиями