- reduced the # objects created when a clause is created in order to help reduce the memory footprint.

Author: ctjoreilly

src/aima/logic/fol/Unifier.java

@@ -56,8 +56,8 @@
  */
 public class Unifier {
 	//
-	private SubstVisitor substVisitor = new SubstVisitor();
-	private VariableCollector variableCollector = new VariableCollector();
+	private static SubstVisitor _substVisitor = new SubstVisitor();
+	private static VariableCollector _variableCollector = new VariableCollector();
 
 	public Unifier() {
 
@@ -134,7 +134,7 @@ public Map<Variable, Term> unify(List<? extends FOLNode> x,
 	protected boolean occurCheck(Map<Variable, Term> theta, Variable var,
 			FOLNode x) {
 		if (x instanceof Function) {
-			Set<Variable> vars = variableCollector
+			Set<Variable> vars = _variableCollector
 					.collectAllVariables((Function) x);
 			if (vars.contains(var)) {
 				return true;
@@ -150,7 +150,7 @@ protected boolean occurCheck(Map<Variable, Term> theta, Variable var,
 					if (vars.contains(v)) {
 						// then need to ensure the function this variable
 						// is to be replaced by does not contain var.
-						Set<Variable> indirectvars = variableCollector
+						Set<Variable> indirectvars = _variableCollector
 								.collectAllVariables((Function) t);
 						if (indirectvars.contains(var)) {
 							return true;
@@ -226,7 +226,7 @@ private void cascadeSubstitution(Map<Variable, Term> theta, Variable var,
 		theta.put(var, x);
 		for (Variable v : theta.keySet()) {
 			Term t = theta.get(v);
-			theta.put(v, substVisitor.subst(theta, t));		
+			theta.put(v, _substVisitor.subst(theta, t));		
 		}
 	}
 }

src/aima/logic/fol/kb/data/Clause.java

@@ -46,21 +46,21 @@ public class Clause {
 	//
 	private static StandardizeApartIndexical _saIndexical = StandardizeApartIndexicalFactory
 			.newStandardizeApartIndexical('c');
+	private static Unifier _unifier = new Unifier();
+	private static SubstVisitor _substVisitor = new SubstVisitor();
+	private static VariableCollector _variableCollector = new VariableCollector();
+	private static StandardizeApart _standardizeApart = new StandardizeApart();
+	private static LiteralsSorter _literalSorter = new LiteralsSorter();
 	//
 	private final Set<Literal> literals = new LinkedHashSet<Literal>();
 	private final List<Literal> positiveLiterals = new ArrayList<Literal>();
 	private final List<Literal> negativeLiterals = new ArrayList<Literal>();
 	private boolean immutable = false;
 	private boolean saCheckRequired = true;
 	private String equalityIdentity = "";
-	private Unifier unifier = new Unifier();
-	private SubstVisitor substVisitor = new SubstVisitor();
-	private VariableCollector variableCollector = new VariableCollector();
-	private StandardizeApart standardizeApart = new StandardizeApart();
-	private LiteralsSorter literalSorter = new LiteralsSorter();
 	private Set<Clause> factors = null;
 	private Set<Clause> nonTrivialFactors = null;
-	private String stringRep = "{}";
+	private String stringRep = null;
 	private ProofStep proofStep = null; 
 
 	public Clause() {
@@ -276,7 +276,7 @@ public Set<Clause> binaryResolvents(Clause othC) {
 			for (Literal pl : trPosLits) {
 				for (Literal nl : trNegLits) {
 					Map<Variable, Term> copyRBindings = new LinkedHashMap<Variable, Term>();
-					if (null != unifier.unify(pl.getAtomicSentence(), nl
+					if (null != _unifier.unify(pl.getAtomicSentence(), nl
 							.getAtomicSentence(), copyRBindings)) {
 						copyRPosLits.clear(); 
 						copyRNegLits.clear();
@@ -286,7 +286,7 @@ public Set<Clause> binaryResolvents(Clause othC) {
 								found = true;
 								continue;
 							}
-							copyRPosLits.add(substVisitor.subst(
+							copyRPosLits.add(_substVisitor.subst(
 										copyRBindings, l));
 						}
 						found = false;
@@ -295,11 +295,11 @@ public Set<Clause> binaryResolvents(Clause othC) {
 								found = true;
 								continue;
 							}
-							copyRNegLits.add(substVisitor.subst(
+							copyRNegLits.add(_substVisitor.subst(
 										copyRBindings, l));
 						}
 						// Ensure the resolvents are standardized apart
-						Map<Variable, Term> renameSubstitituon = standardizeApart
+						Map<Variable, Term> renameSubstitituon = _standardizeApart
 								.standardizeApart(copyRPosLits,
 								copyRNegLits, _saIndexical);
 						Clause c = new Clause(copyRPosLits, copyRNegLits);
@@ -321,6 +321,12 @@ public Set<Clause> binaryResolvents(Clause othC) {
 	}
 
 	public String toString() {
+		if (null == stringRep) {
+			List<Literal> sortedLiterals = new ArrayList<Literal>(literals);
+			Collections.sort(sortedLiterals, _literalSorter);
+
+			stringRep = sortedLiterals.toString();
+		}
 		return stringRep;
 	}
 
@@ -352,7 +358,7 @@ private void recalculateIdentity() {
 			// Sort the literals first based on negation, atomic sentence,
 			// constant, function and variable.
 			List<Literal> sortedLiterals = new ArrayList<Literal>(literals);
-			Collections.sort(sortedLiterals, literalSorter);
+			Collections.sort(sortedLiterals, _literalSorter);
 
 			stringRep = sortedLiterals.toString();
 
@@ -362,7 +368,7 @@ private void recalculateIdentity() {
 			// the # of unique variables they contain and
 			// there positions across the clauses
 			ClauseEqualityIdentityConstructor ceic = new ClauseEqualityIdentityConstructor(
-					sortedLiterals, literalSorter);
+					sortedLiterals, _literalSorter);
 
 			equalityIdentity = ceic.getIdentity();
 
@@ -371,6 +377,9 @@ private void recalculateIdentity() {
 			// access lazily.
 			factors = null;
 			nonTrivialFactors = null;
+			// Reset the objects string representation
+			// until it is requested for.
+			stringRep = null;
 		}
 	}
 
@@ -393,31 +402,35 @@ private void calculateFactors(Set<Clause> parentFactors) {
 					Literal litY = lits.get(y);
 
 					theta.clear();
-					Map<Variable, Term> substitution = unifier.unify(litX
+					Map<Variable, Term> substitution = _unifier.unify(litX
 							.getAtomicSentence(), litY.getAtomicSentence(),
 							theta);
 					if (null != substitution) {
 						List<Literal> posLits = new ArrayList<Literal>();
 						List<Literal> negLits = new ArrayList<Literal>();
 						if (i == 0) {
-							posLits.add(substVisitor.subst(substitution, litX));
+							posLits
+									.add(_substVisitor
+											.subst(substitution, litX));
 						} else {
-							negLits.add(substVisitor.subst(substitution, litX));
+							negLits
+									.add(_substVisitor
+											.subst(substitution, litX));
 						}
 						for (Literal pl : positiveLiterals) {
 							if (pl == litX || pl == litY) {
 								continue;
 							}
-							posLits.add(substVisitor.subst(substitution, pl));
+							posLits.add(_substVisitor.subst(substitution, pl));
 						}
 						for (Literal nl : negativeLiterals) {
 							if (nl == litX || nl == litY) {
 								continue;
 							}
-							negLits.add(substVisitor.subst(substitution, nl));
+							negLits.add(_substVisitor.subst(substitution, nl));
 						}
 						// Ensure the non trivial factor is standardized apart
-						standardizeApart.standardizeApart(posLits, negLits,
+						_standardizeApart.standardizeApart(posLits, negLits,
 								_saIndexical);
 						Clause c = new Clause(posLits, negLits);
 						c.setProofStep(new ProofStepClauseFactor(c, this));
@@ -457,17 +470,17 @@ private Clause saIfRequired(Clause othClause) {
 		// then need to standardize apart in
 		// order to work correctly.
 		if (isStandardizedApartCheckRequired() || this == othClause) {
-			Set<Variable> mVariables = variableCollector
+			Set<Variable> mVariables = _variableCollector
 					.collectAllVariables(this);
-			Set<Variable> oVariables = variableCollector
+			Set<Variable> oVariables = _variableCollector
 					.collectAllVariables(othClause);
 
 			Set<Variable> cVariables = new HashSet<Variable>();
 			cVariables.addAll(mVariables);
 			cVariables.addAll(oVariables);
 
 			if (cVariables.size() < (mVariables.size() + oVariables.size())) {
-				othClause = standardizeApart.standardizeApart(othClause,
+				othClause = _standardizeApart.standardizeApart(othClause,
 						_saIndexical);
 			}
 		}