Cleaned up a bit.

- Suspicious indices changed.
- Whitespace usage standardized.
- for replaced by foreach.

Author: RuedigerLunde

aima-core/src/main/java/aima/core/nlp/parsing/CYK.java

@@ -44,29 +44,28 @@
  */
 public class CYK {
 
-	public float[][][] parse( List<String> words, ProbCNFGrammar grammar ) {
+	public float[][][] parse(List<String> words, ProbCNFGrammar grammar) {
 		final int N = length(words);
 		final int M = grammar.vars.size(); 
 		float[][][] P = new float[M][N][N]; // initialised to 0.0
-		for( int i=0; i < N; i++ ) {
+		for (int i=0; i < N; i++) {
 		   //for each rule of form( X -> words<sub>i</sub>[p]) do
 			//   P[X,i,1] <- p
-			for( int j=0; j < grammar.rules.size(); j++ ) {
+			for (int j=0; j < grammar.rules.size(); j++) {
 				Rule r = (Rule) grammar.rules.get(j);
 				if( r.derives(words.get(i))) { 				 	// rule is of form X -> w, where w = words[i]
 					int x = grammar.vars.indexOf(r.lhs.get(0)); // get the index of rule's LHS variable
 					P[x][i][0] = r.PROB; 						// not P[X][i][1] because we use 0-based indexing
 				}
 			}
 		}
-		for( int length=2; length <= N; length++ ) {
-			for( int start=1; start <= N - length + 1; start++ ) {
-				for( int len1=1; len1 <= length -1; len1++ ) { // N.B. the book incorrectly has N-1 instead of length-1
+		for (int length=2; length <= N; length++) {
+			for (int start=1; start <= N - length + 1; start++) {
+				for (int len1=1; len1 <= length -1; len1++) { // N.B. the book incorrectly has N-1 instead of length-1
 					int len2 = length - len1;
 					// for each rule of the form X -> Y Z, where Y,Z are variables of the grammar
-					for( int j=0; j < grammar.rules.size(); j++ ) {
-						Rule r = grammar.rules.get(j);
-						if( r.rhs.size() == 2 ) {
+					for (Rule r : grammar.rules) {
+						if(r.rhs.size() == 2) {
 							// get index of rule's variables X, Y, and Z
 							int x = grammar.vars.indexOf(r.lhs.get(0));
 							int y = grammar.vars.indexOf(r.rhs.get(0));
@@ -87,7 +86,7 @@ public float[][][] parse( List<String> words, ProbCNFGrammar grammar ) {
 	 * @param ls
 	 * @return the length of the list
 	 */
-	public int length( List<String> ls ) {
+	public int length(List<String> ls) {
 		return ls.size();
 	}
 
@@ -97,17 +96,16 @@ public int length( List<String> ls ) {
 	 * @param words
 	 * @param g
 	 */
-	public void printProbTable( float[][][] probTable, List<String> words, ProbUnrestrictedGrammar g ) {
+	public void printProbTable(float[][][] probTable, List<String> words, ProbUnrestrictedGrammar g) {
 		final int N = words.size();
 		final int M = g.vars.size(); // num non-terminals in grammar
 
-		for( int i=0; i < M; i++ ) {
+		for (int i=0; i < M; i++) {
 			System.out.println("Table For : " + g.vars.get(i) + "(" + i + ")");
-			for( int j=0; j < N; j++ ) {
+			for (int j=0; j < N; j++) {
 				System.out.print(j + "| ");
-				for( int k=0; k < N; k++ ) {
+				for (int k=0; k < N; k++)
 					System.out.print(probTable[i][j][k] + " | ");
-				}
 				System.out.println();
 			}
 			System.out.println();
@@ -121,7 +119,7 @@ public void printProbTable( float[][][] probTable, List<String> words, ProbUnres
 	 * @param g
 	 * @return
 	 */
-	public ArrayList<String> getMostProbableDerivation( float[][][] probTable, ProbUnrestrictedGrammar g ) {
+	public ArrayList<String> getMostProbableDerivation(float[][][] probTable, ProbUnrestrictedGrammar g) {
 		// TODO
 		return null;
 	}

aima-core/src/main/java/aima/core/nlp/parsing/Lexicon.java

@@ -18,14 +18,13 @@ public class Lexicon extends HashMap<String,ArrayList<LexWord>> {
 
 	private static final long serialVersionUID = 1L;
 
-	public ArrayList<Rule> getTerminalRules( String partOfSpeech ) {
+	public ArrayList<Rule> getTerminalRules(String partOfSpeech) {
 		final String partOfSpeechUpperCase = partOfSpeech.toUpperCase();
 		final ArrayList<Rule> rules = new ArrayList<>();
 
 		Optional.ofNullable(this.get(partOfSpeechUpperCase)).ifPresent(lexWords -> {
-			for (LexWord word : lexWords) {
+			for (LexWord word : lexWords)
 				rules.add(new Rule(partOfSpeechUpperCase, word.word, word.prob));
-			}
 		});
 
 		return rules;
@@ -35,50 +34,44 @@ public ArrayList<Rule> getAllTerminalRules() {
 		final ArrayList<Rule> allRules = new ArrayList<>();
 		final Set<String> keys = this.keySet();
 
-		for (String key : keys) {
+		for (String key : keys)
 			allRules.addAll( this.getTerminalRules(key));
-		}
 
 		return allRules;
 	}
 
 	public boolean addEntry( String category, String word, float prob ) {
-		if( this.containsKey(category)) {
+		if( this.containsKey(category))
 			this.get(category).add( new LexWord( word, prob ));
-		}
-		else {
-			this.put(category, new ArrayList<>( Arrays.asList(new LexWord(word,prob))));
-		}
+		else
+			this.put(category, new ArrayList<>(Collections.singletonList(new LexWord(word,prob))));
 
 		return true;
 	}
 
-	public boolean addLexWords( String... vargs ) {
+	public boolean addLexWords(String... vargs) {
 		ArrayList<LexWord> lexWords = new ArrayList<>();
 		boolean containsKey = false;
 		// number of arguments must be key (1) + lexWord pairs ( x * 2 )
-		if( vargs.length % 2 != 1 ) {
+		if (vargs.length % 2 != 1)
 			return false;
-		}
 
 		String key = vargs[0].toUpperCase();
-		if( this.containsKey(key)) { containsKey = true; }
+		if (this.containsKey(key)) { containsKey = true; }
 
-		for( int i=1; i < vargs.length; i++ ) {
+		for (int i=1; i < vargs.length; i++) {
 			try {
-				if( containsKey ) {
+				if( containsKey )
 					this.get(key).add( new LexWord( vargs[i], Float.valueOf(vargs[i+1])));
-				}
-				else {
-					lexWords.add( new LexWord( vargs[i], Float.valueOf(vargs[i+1])));	
-				}
+				else
+					lexWords.add( new LexWord( vargs[i], Float.valueOf(vargs[i+1])));
 				i++;
 			} catch( NumberFormatException e ) {
 				System.err.println("Supplied args have incorrect format.");
 				return false;
 			}
 		}
-		if( !containsKey ) { this.put(key, lexWords); }
+		if (!containsKey) { this.put(key, lexWords); }
 		return true;
 
 	}
@@ -88,15 +81,14 @@ public boolean addLexWords( String... vargs ) {
 	 * you can combine lexicons.
 	 * @param lexicon
 	 */
-	public void addLexWords( Lexicon lexicon ) {
+	public void addLexWords(Lexicon lexicon) {
 		for (Map.Entry<String, ArrayList<LexWord>> pair : lexicon.entrySet()) {
 			final String key = pair.getKey();
 			final ArrayList<LexWord> lexWords = pair.getValue();
 
 			if (this.containsKey(key)) {
-				for (LexWord word : lexWords) {
+				for (LexWord word : lexWords)
 					this.get(key).add(word);
-				}
 			} else {
 				this.put(key, lexWords);
 			}

aima-core/src/main/java/aima/core/nlp/parsing/RunCYK.java

@@ -19,7 +19,7 @@ public static void main(String[] args) {
 		System.out.println("Running...");
 		ProbCNFGrammar exampleG = ProbCNFGrammarExamples.buildTrivialGrammar();
 		CYK cyk = new CYK();
-		List<String> words = new ArrayList<String>(Arrays.asList("the","man","liked","a","woman"));
+		List<String> words = new ArrayList<>(Arrays.asList("the","man","liked","a","woman"));
 		float[][][] probTable = cyk.parse(words, exampleG);
 		cyk.printProbTable(probTable, words, exampleG);
 		System.out.println("Done!");

aima-core/src/main/java/aima/core/nlp/parsing/grammars/ProbCNFGrammar.java

@@ -28,7 +28,7 @@ public ProbCNFGrammar() {
 		rules = new ArrayList<Rule>();
 	}
 
-	public ProbCNFGrammar( ProbCNFGrammar grammar ) {
+	public ProbCNFGrammar(ProbCNFGrammar grammar) {
 		type = 4;
 		rules = grammar.rules;
 	}
@@ -38,16 +38,14 @@ public ProbCNFGrammar( ProbCNFGrammar grammar ) {
 	 * both the restrictions of the Context-free grammar, and all rules 
 	 * or in Chomsky-Normal-Form
 	 */
-	public boolean addRules( List<Rule> ruleList ) {
-		for( int i=0; i < ruleList.size(); i++ ) {
-			if( !validRule(ruleList.get(i)) ) {
+	public boolean addRules(List<Rule> ruleList) {
+		for (Rule aRuleList : ruleList) {
+			if (!validRule(aRuleList))
 				return false;
-			}
 		}
-		if( !validateRuleProbabilities(ruleList)) {
+		if (!validateRuleProbabilities(ruleList))
 			return false;
-		}
-		this.rules = ruleList;
+		rules = ruleList;
 		updateVarsAndTerminals();
 		return true;
 	}
@@ -57,10 +55,9 @@ public boolean addRules( List<Rule> ruleList ) {
 	 * both the restrictions of the Context-free grammar, and the rule is
 	 * in Chomsky Normal Form.
 	 */
-	public boolean addRule( Rule r ) {
-		if( !validRule(r) ) {
+	public boolean addRule(Rule r) {
+		if (!validRule(r))
 			return false;
-		}
 		rules.add(r);
 		updateVarsAndTerminals(r);
 		return true;
@@ -80,20 +77,17 @@ public boolean addRule( Rule r ) {
 	 * @return true, if rule is in CNF. false, otherwise
 	 */
 	public boolean validRule( Rule r ){
-		if( !super.validRule(r) ){
+		if (!super.validRule(r))
 			return false;
-		}
 		// 3. rhs is null
-		if( r.rhs == null || r.rhs.size() == 0) { return true; }
+		if (r.rhs == null || r.rhs.size() == 0)
+			return true;
 		// 2. rhs is a terminal (a)
-		else if( r.rhs.size() == 1 && isTerminal(r.rhs.get(0))) {
+		else if (r.rhs.size() == 1 && isTerminal(r.rhs.get(0)))
 			return true;
-		}
 		// 1. rhs is 2 variables (BC)
-		else if( r.rhs.size() == 2 && isVariable(r.rhs.get(0))
-				  && isVariable(r.rhs.get(1))) { 
+		else if (r.rhs.size() == 2 && isVariable(r.rhs.get(0)) && isVariable(r.rhs.get(1)))
 			return true;
-		}
 		// rule is not in one of the 3 CNF forms
 		return false;
 	}

aima-core/src/main/java/aima/core/nlp/parsing/grammars/ProbContextSensitiveGrammar.java

@@ -21,16 +21,14 @@ public ProbContextSensitiveGrammar() {
 	 * both the restrictions of the parent grammar (unrestricted) and
 	 * this grammar's restrictions.
 	 */
-	public boolean addRules( ArrayList<Rule> ruleList ) {
-		for( int i=0; i < ruleList.size(); i++ ) {
-			if( !super.validRule(ruleList.get(i)) ) {
+	public boolean addRules(ArrayList<Rule> ruleList) {
+		for (Rule aRuleList : ruleList) {
+			if (!super.validRule(aRuleList))
 				return false;
-			}
-			if( !validRule(ruleList.get(i)) ) {
+			if (!validRule(aRuleList))
 				return false;
-			}
 		}
-		this.rules = ruleList;
+		rules = ruleList;
 		updateVarsAndTerminals();
 		return true;
 	}
@@ -40,13 +38,12 @@ public boolean addRules( ArrayList<Rule> ruleList ) {
 	 * both the restrictions of the parent grammar (unrestricted) and
 	 * this grammar's restrictions.
 	 */
-	public boolean addRule( Rule r ) {
-		if( !super.validRule(r) ) {
+	public boolean addRule(Rule r) {
+		if (!super.validRule(r))
 			return false;
-		}
-		else if( !validRule(r) ) {
+		else if (!validRule(r))
 			return false;
-		}
+
 		rules.add(r);
 		updateVarsAndTerminals(r);
 		return true;
@@ -58,17 +55,16 @@ else if( !validRule(r) ) {
 	 * and the number of RHS symbols must be equal or greater than the number
 	 * of LHS symbols.
 	 */
-	public boolean validRule( Rule r ){
-		if( !super.validRule(r) ){
+	public boolean validRule(Rule r) {
+		if (!super.validRule(r))
 			return false;
-		}
+
 		// len(rhs) >= len(lhs) must hold in context-sensitive.
-		else if( r.rhs == null ) {
+		else if (r.rhs == null)
 			return false;
-		}
-		else if( r.rhs.size() < r.lhs.size() ) {
+
+		else if (r.rhs.size() < r.lhs.size())
 			return false;
-		}
 
 		return true;
 	}