Fix typos

Author: Maarten

README.md

@@ -26,24 +26,14 @@ For example:
 
 This library allows you to do these things [efficiently](https://github.com/digitalheir/probabilistic-earley-parser-javascript#runtime-complexity), as long as you can describe the rules as a [Context-free Grammar](https://en.wikipedia.org/wiki/Context-free_grammar) (CFG).
 
-The innovation of this library with respect to the many other parsing libraries is that this one allows the production rules in your grammar to have a probability attached to them. That is: it parses [Stochastic Context-free Grammars](https://en.wikipedia.org/wiki/Stochastic_context-free_grammar). This allows us to make better choices in case of ambiguous sentences: we can order them by probability.
+The innovation of this library with respect to the many other parsing libraries is that this one allows the production rules in your grammar to have a probability attached to them. That is: it parses [Stochastic Context-free Grammars](https://en.wikipedia.org/wiki/Stochastic_context-free_grammar). This allows us to make better choices in case of ambiguous sentences: we can order them by probability. Furthermore, this parser does not limit token types to strings.
 
-The parser seems to work correctly and efficiently, but is still < v1.0 because I have not added as much utility functions and tests as I would like.
+The parser seems to work correctly and efficiently, but is still < v1.0 because I still
+want some extra utility functions and tests.
 
 For a theoretical grounding of this work, refer to [*Stolcke, An Efficient Probabilistic Context-Free
            Parsing Algorithm that Computes Prefix
            Probabilities*](http://www.aclweb.org/anthology/J95-2002).
-  
-## Motivation
-I made this library because I could not find an existing Java 
-implementation of the Probabilistic Earley Parser. 
-
-I have made a stochastic CYK parser before, but I wanted something
-more top down that makes it easier to intervene in the parsing process,
-for instance when an unexpected token is encountered.
- 
-Furthermore, I needed a efficient parser that does not limit token types 
-to strings.
 
 ## Usage
 You can use this project as a library in your Java application or as a standalone command-line app.
@@ -118,8 +108,8 @@ public class Example {
     // Note that tokens can be of multiple terminal types (homographs: "bank" as a noun or "bank" as a verb)
     private static final Terminal transitiveVerb = (StringTerminal) token -> token.obj.matches("(hit|chased)");
     // Some utility terminal types are pre-defined:
-    private static final Terminal the = new CaseInsenstiveStringTerminal("the");
-    private static final Terminal a = new CaseInsenstiveStringTerminal("a");
+    private static final Terminal the = new CaseInsensitiveStringTerminal("the");
+    private static final Terminal a = new CaseInsensitiveStringTerminal("a");
     private static final Terminal man = new ExactStringTerminal("man");
     private static final Terminal stick = new ExactStringTerminal("stick");
     private static final Terminal with = new ExactStringTerminal("with");
@@ -194,7 +184,7 @@ new ParseCallbacks.Builder()
 ```
 
 ## Some notes on implementation
-The probability of a parse is defined as the product of the probalities all the applied rules. Usually,
+The probability of a parse is defined as the product of the probabilities all the applied rules. Usually,
 we define probability as a number between 0 and 1 inclusive, and use common algebraic notions of addition and
 multiplication.
 

src/main/java/org/leibnizcenter/cfg/algebra/semiring/Semiring.java

@@ -14,7 +14,7 @@
 @SuppressWarnings("unused")
 public interface Semiring<T> {
 //    @Deprecated
-//    static boolean isRighSemiring(Semiring semiring) {
+//    static boolean isRightSemiring(Semiring semiring) {
 //        return isRightSemiring(semiring);
 //    }
 //

src/main/java/org/leibnizcenter/cfg/algebra/semiring/dbl/ExpressionSemiring.java

@@ -14,17 +14,17 @@ public abstract class ExpressionSemiring implements DblSemiring {
 
     public final Atom ZERO_EXPRESSION = new Atom(zero());
 
-    public Resolvable times(Resolvable x, Resolvable y, Resolvable z) {
-        if (isMultiplicativeIdentity(x)) return times(y, z);
-        else if (isMultiplicativeIdentity(y)) return times(x, z);
-        else if (isMultiplicativeIdentity(z)) return times(x, y);
-        return new Times(x, y, z);
+    public Resolvable times(Resolvable r1, Resolvable r2, Resolvable r3) {
+        if (isMultiplicativeIdentity(r1)) return times(r2, r3);
+        else if (isMultiplicativeIdentity(r2)) return times(r1, r3);
+        else if (isMultiplicativeIdentity(r3)) return times(r1, r2);
+        return new Times(r1, r2, r3);
     }
 
-    private Resolvable times(Resolvable x, Resolvable y) {
-        if (isMultiplicativeIdentity(x)) return y;
-        else if (isMultiplicativeIdentity(y)) return x;
-        return new Times(x, y);
+    private Resolvable times(Resolvable r1, Resolvable r2) {
+        if (isMultiplicativeIdentity(r1)) return r2;
+        else if (isMultiplicativeIdentity(r2)) return r1;
+        return new Times(r1, r2);
     }
 
     private boolean isMultiplicativeIdentity(Resolvable r) {
@@ -35,13 +35,14 @@ private boolean isAdditiveIdentity(Resolvable x) {
         return x instanceof Atom && ((Atom) x).value == this.zero();
     }
 
-    public Resolvable plus(Resolvable x, Resolvable y) {
-        if (isAdditiveIdentity(x)) return y;
-        else if (isAdditiveIdentity(y)) return x;
-        else return new Plus(x, y);
+    public Resolvable plus(Resolvable r1, Resolvable r2) {
+        if (isAdditiveIdentity(r1)) return r2;
+        else if (isAdditiveIdentity(r2)) return r1;
+        else return new Plus(r1, r2);
     }
 
 
+    @SuppressWarnings("WeakerAccess")
     public final class Plus extends Resolvable {
         private final Resolvable right;
         private final Resolvable left;
@@ -67,6 +68,7 @@ public String toString() {
     }
 
 
+    @SuppressWarnings("WeakerAccess")
     public final class Times extends Resolvable {
         private final Resolvable right;
         private final Resolvable left;
@@ -102,11 +104,8 @@ public boolean equals(Object o) {
 
             Times times = (Times) o;
 
-            if (!right.equals(times.right)) return false;
-            if (!left.equals(times.left)) return false;
-            if (right2 != null ? !right2.equals(times.right2) : times.right2 != null) return false;
+            return right.equals(times.right) && left.equals(times.left) && (right2 != null ? right2.equals(times.right2) : times.right2 == null);
 
-            return true;
         }
 
         @Override

src/main/java/org/leibnizcenter/cfg/category/Category.java

@@ -9,7 +9,7 @@
 
 /**
  * A category in a grammar, also known as a type.
- * Categories are the atomic subparts that make up
+ * Categories are the atomic sub-parts that make up
  * {@link Rule grammar rules}.
  * <p>
  * Categories can either be <em>terminal</em> or <em>non-terminal</em>. A

src/main/java/org/leibnizcenter/cfg/category/terminal/stringterminal/CaseInsenstiveStringTerminal.java renamed to src/main/java/org/leibnizcenter/cfg/category/terminal/stringterminal/CaseInsensitiveStringTerminal.java

@@ -9,16 +9,17 @@
  * <p>
  * Created by maarten on 11-6-16.
  */
-public class CaseInsenstiveStringTerminal implements StringTerminal {
+public class CaseInsensitiveStringTerminal implements StringTerminal {
     public final String string;
+    @SuppressWarnings("WeakerAccess")
     public final Locale locale;
 
-    public CaseInsenstiveStringTerminal(String s) {
+    public CaseInsensitiveStringTerminal(String s) {
         this.locale = Locale.ROOT;
         this.string = s.toLowerCase(locale);
     }
 
-    public CaseInsenstiveStringTerminal(String s, Locale locale) {
+    public CaseInsensitiveStringTerminal(String s, Locale locale) {
         this.locale = locale;
         this.string = s.toLowerCase(locale);
     }
@@ -33,7 +34,7 @@ public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
 
-        CaseInsenstiveStringTerminal that = (CaseInsenstiveStringTerminal) o;
+        CaseInsensitiveStringTerminal that = (CaseInsensitiveStringTerminal) o;
 
         if (!string.equals(that.string)) return false;
         if (!locale.equals(that.locale)) return false;

src/main/java/org/leibnizcenter/cfg/earleyparser/CommandLine.java

@@ -16,6 +16,7 @@
 import java.util.stream.Stream;
 
 /**
+ * Interface for runnable jar
  * Created by maarten on 27-1-17.
  */
 public class CommandLine {
@@ -34,19 +35,19 @@ public class CommandLine {
      */
     public static void main(String[] args) {
         HandleArguments handleArguments = new HandleArguments(args).invoke();
-        ParseTreeWithScore parse = Parser.getViterbiParseWithScore(
-                handleArguments.getGoal(),
-                handleArguments.getGrammar(),
-                Stream.of(handleArguments.getTokens()).map(Token::of).collect(Collectors.toList())
-        );
+        ParseTreeWithScore parse = new Parser<>(handleArguments.getGrammar())
+                .getViterbiParseWithScore(
+                        handleArguments.getGoal(),
+                        Stream.of(handleArguments.getTokens()).map(Token::of).collect(Collectors.toList())
+                );
 
         System.out.println(parse.score.semiring.toProbability(parse.score.getScore()));
         System.out.println(parse.parseTree);
     }
 
 
     private static class HandleArguments {
-        private String[] args;
+        final private String[] args;
         private String[] tokens;
         private Grammar<String> grammar;
         private NonTerminal goal;

src/main/java/org/leibnizcenter/cfg/earleyparser/Complete.java

@@ -130,7 +130,7 @@ private void completeNoViterbi(final int position,
                 /* */
         Collection<State> newCompletedStates = null;
         for (Delta delta : deltas) {
-            //todo these plus operation may be parallelized a little?
+            //todo these plus operation may be parallellized a little?
             addForwardScores.plus(delta.state, delta.addForward);
             addInnerScores.plus(delta.state, delta.addInner);
 

src/main/java/org/leibnizcenter/cfg/earleyparser/DeferredStateScoreComputations.java

@@ -38,7 +38,7 @@ public void plus(State s, Resolvable addValue) {
         this.states.put(s, current);
     }
 
-    public Complete.Delta addForward(Complete.Delta delta) {
+    Complete.Delta addForward(Complete.Delta delta) {
         plus(delta.state, delta.addForward);
         return delta;
     }

src/main/java/org/leibnizcenter/cfg/earleyparser/ParseTree.java

@@ -96,9 +96,11 @@ public String toString() {
     }
 
     private void toString(StringBuilder sb, String prefix, boolean isTail) {
-        sb.append(prefix + (isTail ? "└── " : "├── ") + (
-                category.toString() + ((this instanceof Token) ? (" (" + ((Token) this).token + ")") : "")
-        ) + "\n");
+        sb.append(prefix)
+                .append(isTail ? "└── " : "├── ")
+                .append(category.toString())
+                .append((this instanceof Token) ? (" (" + ((Token) this).token + ")") : "")
+                .append("\n");
         if (children != null) {
             for (int i = 0; i < children.size() - 1; i++) {
                 children.get(i).toString(sb, prefix + (isTail ? "    " : "│   "), false);

src/main/java/org/leibnizcenter/cfg/earleyparser/Parser.java

@@ -40,7 +40,7 @@ public Parser(Grammar<T> grammar) {
      * @param goal    Goal category, typically S for Sentence
      * @param grammar Grammar to apply to tokens
      * @param tokens  list of tokens to parse
-     * @return Probability that given string of tokens mathces gven non-terminal with given grammar
+     * @return Probability that given string of tokens mathces given non-terminal with given grammar
      */
     @Deprecated
     public static <T> double recognize(NonTerminal goal,
@@ -55,7 +55,7 @@ public static <T> double recognize(NonTerminal goal,
      * @param goal    Goal category, typically S for Sentence
      * @param grammar Grammar to apply to tokens
      * @param tokens  list of tokens to parse
-     * @return Probability that given string of tokens mathces gven non-terminal with given grammar
+     * @return Probability that given string of tokens mathces given non-terminal with given grammar
      */
     @Deprecated
     public static <T> double recognize(NonTerminal goal,
@@ -207,7 +207,7 @@ public static ParseTree getViterbiParse(State state, Chart chart) {
      *
      * @param goal   Goal category, typically S for Sentence
      * @param tokens list of tokens to parse
-     * @return Probability that given string of tokens mathces gven non-terminal with given grammar
+     * @return Probability that given string of tokens mathces given non-terminal with given grammar
      */
     public double recognize(NonTerminal goal, Iterable<Token<T>> tokens) {
         return recognize(goal, tokens, null);
@@ -218,7 +218,7 @@ public double recognize(NonTerminal goal, Iterable<Token<T>> tokens) {
      *
      * @param goal   Goal category, typically S for Sentence
      * @param tokens list of tokens to parse
-     * @return Probability that given string of tokens mathces gven non-terminal with given grammar
+     * @return Probability that given string of tokens mathces given non-terminal with given grammar
      */
     public double recognize(NonTerminal goal,
                             Iterable<Token<T>> tokens,
@@ -318,8 +318,8 @@ public ChartWithInputPosition<T> parseAndCountTokens(NonTerminal S,
         int i = 0;
 
         final Complete<T> complete = new Complete<>(chart.stateSets, true);
-        final Scan<T> scan = new Scan<T>(chart.stateSets);
-        final Predict<T> predict = new Predict<T>(chart.stateSets);
+        final Scan<T> scan = new Scan<>(chart.stateSets);
+        final Predict<T> predict = new Predict<>(chart.stateSets);
 
         for (TokenWithCategories<T> token : TokenWithCategories.from(tokens, grammar)) {
             predict.predict(callbacks, chart, i, token);