जावा में बूलियन अभिव्यक्ति पार्सर

Question

क्या कोई जावा पुस्तकालय या तकनीक बुलियन अभिव्यक्ति टुकड़े टुकड़े को पार्स करने के लिए है?

मैं क्या मतलब इस तरह एक अभिव्यक्ति दी गई है:

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

यह दिखाने के लिए जो टोकन 'एफ' मूल्य की वजह से है, तो (शायद की तरह एक अभिव्यक्ति पेड़ में टूट किया जा सकता है इस तरह कुछ):

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

मैं गैर-प्रोग्रामर को बूलियन अभिव्यक्ति मूल्यांकन संवाद करने की कोशिश कर रहा हूं। मैंने Anlr के साथ चारों ओर पोक किया है, लेकिन मैं इसे बहुत कुछ नहीं कर सका (ऐसा लगता है कि यह एक सीखने की वक्र है)।

मैं इसे खुद लिखने का विरोध नहीं कर रहा हूं, लेकिन मैं पहिया को फिर से नहीं खोलूंगा।

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

यहाँ ouput है || (एफ & & टी) = झूठा) = झूठा
(टी & & (एफ || (एफ & & टी) झूठी =) झूठी =) के लिए झूठी

मूल्यांकन अनुक्रम =: (टी & & टी) || (एफ & & टी)
(टी & & टी) सच =
(एफ & & टी) = झूठी
((टी & & टी) = सच || (एफ & & टी) झूठी =) सच =

Answer 2

आप इसे MVEL या JUEL के साथ कर सकते हैं। दोनों अभिव्यक्ति भाषा पुस्तकालय हैं, नीचे दिए गए उदाहरण एमवीईएल का उपयोग कर रहे हैं।

उदाहरण:

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

प्रिंटों: झूठी

आप सचमुच 'टी' और 'एफ' का उपयोग करने के आप यह कर सकते हैं:

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

प्रिंटों: झूठी

Answer 3

BeanShell देखें। इसमें अभिव्यक्ति पार्सिंग है जो जावा-जैसी वाक्यविन्यास स्वीकार करती है।

संपादित करें: जब तक आप वास्तव में सचमुच T && F पार्स करने के लिए, हालांकि आप BeanShell में ऐसा कर सकता है शाब्दिक true और false का उपयोग कर कोशिश कर रहे हैं।

Answer 4

मैंने हाल ही में जावा में एक पुस्तकालय एक साथ रखा है विशेष रूप से बूलियन अभिव्यक्तियों में हेरफेर करने के लिए: 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% तुम क्या कर रहे थे मांगना, लेकिन उम्मीद है कि यह मदद करता है।

Answer 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 tutorial का पालन करें।

सर्वश्रेष्ठ संबंध