Package aima.core.logic.propositional.parsing.ast

Examples of aima.core.logic.propositional.parsing.ast.Sentence

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
  }

  @Test
  public void testSimpleNegativeSymbol() {
    Sentence sentence = (Sentence) parser.parse("(NOT B)");

    Set<Symbol> neg = classifier.getNegativeSymbolsIn(sentence);
    Set<Symbol> pos = classifier.getPositiveSymbolsIn(sentence);

    Set<Symbol> pureNeg = classifier.getPureNegativeSymbolsIn(sentence);
    Set<Symbol> purePos = classifier.getPurePositiveSymbolsIn(sentence);

    Set<Symbol> pure = classifier.getPureSymbolsIn(sentence);
    Set<Symbol> impure = classifier.getImpureSymbolsIn(sentence);

    Sentence b = (Sentence) parser.parse("B");

    Assert.assertEquals(1, neg.size());
    Assert.assertTrue(neg.contains(b));

    Assert.assertEquals(0, pos.size());
View Full Code Here
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
    Assert.assertEquals(0, impure.size());
  }

  @Test
  public void testSimplePositiveSymbol() {
    Sentence sentence = (Sentence) parser.parse("B");
    Set<Symbol> neg = classifier.getNegativeSymbolsIn(sentence);
    Set<Symbol> pos = classifier.getPositiveSymbolsIn(sentence);

    Set<Symbol> pureNeg = classifier.getPureNegativeSymbolsIn(sentence);
    Set<Symbol> purePos = classifier.getPurePositiveSymbolsIn(sentence);

    Set<Symbol> pure = classifier.getPureSymbolsIn(sentence);
    Set<Symbol> impure = classifier.getImpureSymbolsIn(sentence);

    Assert.assertEquals(0, neg.size());

    Assert.assertEquals(1, pos.size());
    Sentence b = (Sentence) parser.parse("B");
    Assert.assertTrue(pos.contains(b));

    Assert.assertEquals(1, purePos.size());
    Assert.assertTrue(purePos.contains(b));
View Full Code Here
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
    Assert.assertEquals(0, impure.size());
  }

  @Test
  public void testSingleSymbolPositiveAndNegative() {
    Sentence sentence = (Sentence) parser.parse("(B AND (NOT B))");
    Set<Symbol> neg = classifier.getNegativeSymbolsIn(sentence);
    Set<Symbol> pos = classifier.getPositiveSymbolsIn(sentence);

    Set<Symbol> pureNeg = classifier.getPureNegativeSymbolsIn(sentence);
    Set<Symbol> purePos = classifier.getPurePositiveSymbolsIn(sentence);

    Set<Symbol> pure = classifier.getPureSymbolsIn(sentence);
    Set<Symbol> impure = classifier.getImpureSymbolsIn(sentence);

    Sentence b = (Sentence) parser.parse("B");

    Assert.assertEquals(1, neg.size());
    Assert.assertTrue(neg.contains(b));

    Assert.assertEquals(1, pos.size());
View Full Code Here
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
  }

  @Test
  public void testAIMA2eExample() {
    // 2nd Edition Pg 221
    Sentence sentence = (Sentence) parser
        .parse("(((A OR (NOT B)) AND ((NOT B) OR (NOT C))) AND (C OR A))");

    Set<Symbol> neg = classifier.getNegativeSymbolsIn(sentence);
    Set<Symbol> pos = classifier.getPositiveSymbolsIn(sentence);

    Set<Symbol> pureNeg = classifier.getPureNegativeSymbolsIn(sentence);
    Set<Symbol> purePos = classifier.getPurePositiveSymbolsIn(sentence);

    Set<Symbol> pure = classifier.getPureSymbolsIn(sentence);
    Set<Symbol> impure = classifier.getImpureSymbolsIn(sentence);

    Sentence a = (Sentence) parser.parse("A");
    Sentence b = (Sentence) parser.parse("B");
    Sentence c = (Sentence) parser.parse("C");

    Assert.assertEquals(2, neg.size());
    Assert.assertTrue(neg.contains(b));
    Assert.assertTrue(neg.contains(c));
View Full Code Here
22
23
24
25
26
27
28
29
30
    transformer = new CNFTransformer();
  }

  @Test
  public void testSymbolTransform() {
    Sentence symbol = (Sentence) parser.parse("A");
    Sentence transformed = transformer.transform(symbol);
    Assert.assertEquals("A", transformed.toString());
  }
View Full Code Here
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
    Assert.assertEquals("A", transformed.toString());
  }

  @Test
  public void testBasicSentenceTransformation() {
    Sentence and = (Sentence) parser.parse("(A AND B)");
    Sentence transformedAnd = transformer.transform(and);
    Assert.assertEquals(and.toString(), transformedAnd.toString());

    Sentence or = (Sentence) parser.parse("(A OR B)");
    Sentence transformedOr = transformer.transform(or);
    Assert.assertEquals(or.toString(), transformedOr.toString());

    Sentence not = (Sentence) parser.parse("(NOT C)");
    Sentence transformedNot = transformer.transform(not);
    Assert.assertEquals(not.toString(), transformedNot.toString());
  }
View Full Code Here
44
45
46
47
48
49
50
51
52
53
    Assert.assertEquals(not.toString(), transformedNot.toString());
  }

  @Test
  public void testImplicationTransformation() {
    Sentence impl = (Sentence) parser.parse("(A => B)");
    Sentence expected = (Sentence) parser.parse("((NOT A) OR B)");
    Sentence transformedImpl = transformer.transform(impl);
    Assert.assertEquals(expected.toString(), transformedImpl.toString());
  }
View Full Code Here
52
53
54
55
56
57
58
59
60
61
62
    Assert.assertEquals(expected.toString(), transformedImpl.toString());
  }

  @Test
  public void testBiConditionalTransformation() {
    Sentence bic = (Sentence) parser.parse("(A <=> B)");
    Sentence expected = (Sentence) parser
        .parse("(((NOT A) OR B)  AND ((NOT B) OR A)) ");
    Sentence transformedBic = transformer.transform(bic);
    Assert.assertEquals(expected.toString(), transformedBic.toString());
  }
View Full Code Here
61
62
63
64
65
66
67
68
69
70
    Assert.assertEquals(expected.toString(), transformedBic.toString());
  }

  @Test
  public void testTwoSuccessiveNotsTransformation() {
    Sentence twoNots = (Sentence) parser.parse("(NOT (NOT A))");
    Sentence expected = (Sentence) parser.parse("A");
    Sentence transformed = transformer.transform(twoNots);
    Assert.assertEquals(expected.toString(), transformed.toString());
  }
View Full Code Here
69
70
71
72
73
74
75
76
77
78
    Assert.assertEquals(expected.toString(), transformed.toString());
  }

  @Test
  public void testThreeSuccessiveNotsTransformation() {
    Sentence threeNots = (Sentence) parser.parse("(NOT (NOT (NOT A)))");
    Sentence expected = (Sentence) parser.parse("(NOT A)");
    Sentence transformed = transformer.transform(threeNots);
    Assert.assertEquals(expected.toString(), transformed.toString());
  }
View Full Code Here
TOP

Related Classes of aima.core.logic.propositional.parsing.ast.Sentence

  • aima.core.logic.propositional.algorithms.DPLL
  • aima.core.logic.propositional.algorithms.KnowledgeBase
  • aima.core.logic.propositional.algorithms.LogicUtils
  • aima.core.logic.propositional.algorithms.PLFCEntails
  • aima.core.logic.propositional.algorithms.PLResolution
  • aima.core.logic.propositional.algorithms.TTEntails
  • aima.core.logic.propositional.algorithms.WalkSAT
  • aima.core.logic.propositional.parsing.AbstractPLVisitor
  • aima.core.logic.propositional.parsing.PEParser
  • aima.core.logic.propositional.visitors.CNFTransformer
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.