Existe-t-il des bibliothèques ou des techniques Java permettant d'analyser des expressions booléennes au coup par coup?
Ce que je veux dire est donné une expression comme celle-ci:
T && ( F || ( F && T ) )
Il pourrait être décomposé en un arbre d'expression pour montrer quel jeton a causé la valeur 'F', comme ceci ( peut-être quelque chose comme ceci):
T && <- rhs false
( F || <- rhs false
( F && T ) <- eval, false
)
J'essaie de communiquer des évaluations d'expressions booléennes à des non-programmeurs. J'ai fouillé avec Anlr, mais je ne pouvais pas le faire faire beaucoup (il semble avoir un peu de courbe d'apprentissage).
Je ne suis pas opposé à l'écrire moi-même, mais je préfère ne pas réinventer la roue.
J'ai codé ceci en utilisant Javaluator .
Ce n’est pas exactement le résultat que vous recherchez, mais je pense que cela pourrait être un point de départ.
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 ();
}
}
Voici la sortie:
Séquence d'évaluation pour: T && (F || (F && T))
(F && T) = false
(F || (F && T) = false) = false
(T && (F || (F && T) = false) = false) = falseSéquence d'évaluation pour: (T && T) || (F && T)
(T && T) = true
(F && T) = false
((T && T) = true || (F && T) = false) = true
Vous pouvez le faire avec MVEL ou JUEL . Les deux sont des bibliothèques de langage d'expression, les exemples ci-dessous utilisent MVEL.
Exemple:
System.out.println(MVEL.eval("true && ( false || ( false && true ) )"));
Impressions: False
Si vous voulez littéralement utiliser 'T' et 'F', vous pouvez le faire:
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));
Impressions: False
J'ai récemment mis sur pied une bibliothèque Java spécialement conçue pour manipuler les expressions booléennes: jbool_expressions .
Il inclut un outil qui analyse également les expressions hors entrée de chaîne:
Expression<String> expr = ExprParser.parse("( ( (! C) | C) & A & B)")
Vous pouvez également faire une simplification assez simple:
Expression<String> simplified = RuleSet.simplify(expr);
System.out.println(expr);
donne
(A & B)
Si vous souhaitez parcourir l’affectation, vous pouvez attribuer des valeurs une par une. Pour l'exemple ici,
Expression<String> halfAssigned = RuleSet.assign(simplified, Collections.singletonMap("A", true));
System.out.println(halfAssigned);
spectacles
B
et vous pouvez le résoudre en assignant B.
Expression<String> resolved = RuleSet.assign(halfAssigned, Collections.singletonMap("B", true));
System.out.println(resolved);
spectacles
true
Pas à 100% ce que vous demandiez, mais espérons que cela vous aidera.
Découvrez BeanShell . Son analyse d’expression accepte une syntaxe semblable à celle de Java.
EDIT: À moins que vous n'essayiez d'analyser T && F
littéralement, bien que vous puissiez le faire dans BeanShell en utilisant les littéraux true
et false
.
mXparser gère les opérateurs booléens - veuillez trouver quelques exemples
Exemple 1:
import org.mariuszgromada.math.mxparser.*;
...
...
Expression e = new Expression("1 && (0 || (0 && 1))");
System.out.println(e.getExpressionString() + " = " + e.calculate());
Résultat 1:
1 && (0 || (0 && 1)) = 0.0
Exemple 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());
Résultat 2:
T && (F || (F && T)) = 0.0
Pour plus de détails, veuillez suivre tutoriel mXparser .
Meilleures salutations