From 7a68441a541b12b22587fb53072193e1130049ff Mon Sep 17 00:00:00 2001 From: RncLsn Date: Tue, 19 May 2015 19:06:04 +0100 Subject: Deleted unused classes. --- .../LimitedSkolemisationApproximator.java | 9 ++- .../rules/approximators/SkolemTermsManager.java | 77 +++++++++++----------- 2 files changed, 43 insertions(+), 43 deletions(-) (limited to 'src/uk/ac/ox/cs/pagoda/rules') diff --git a/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java index 20ae53b..3f1ed7e 100644 --- a/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java +++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java @@ -1,13 +1,14 @@ package uk.ac.ox.cs.pagoda.rules.approximators; import org.semanticweb.HermiT.model.*; -import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID; import uk.ac.ox.cs.pagoda.multistage.MultiStageUpperProgram; import uk.ac.ox.cs.pagoda.rules.ExistConstantApproximator; import uk.ac.ox.cs.pagoda.util.tuples.Tuple; import uk.ac.ox.cs.pagoda.util.tuples.TupleBuilder; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; /** * Approximates existential rules through a limited form of Skolemisation. @@ -24,7 +25,6 @@ public class LimitedSkolemisationApproximator implements TupleDependentApproxima private final int maxTermDepth; private final TupleDependentApproximator alternativeApproximator; private final SkolemTermsManager skolemTermsManager; - private Map mapIndividualsToDepth; public LimitedSkolemisationApproximator(int maxTermDepth) { this(maxTermDepth, new ExistConstantApproximator()); @@ -33,7 +33,6 @@ public class LimitedSkolemisationApproximator implements TupleDependentApproxima public LimitedSkolemisationApproximator(int maxTermDepth, TupleDependentApproximator alternativeApproximator) { this.maxTermDepth = maxTermDepth; this.alternativeApproximator = alternativeApproximator; - this.mapIndividualsToDepth = new HashMap<>(); this.skolemTermsManager = SkolemTermsManager.getInstance(); } @@ -144,7 +143,7 @@ public class LimitedSkolemisationApproximator implements TupleDependentApproxima public int getMaxDepth(Tuple violationTuple) { int maxDepth = 0; for (Individual individual : violationTuple) - maxDepth = Integer.max(maxDepth, skolemTermsManager.getDepth(individual)); + maxDepth = Integer.max(maxDepth, skolemTermsManager.getDepthOf(individual)); return maxDepth; } diff --git a/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java b/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java index 0c12a27..368c014 100644 --- a/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java +++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/SkolemTermsManager.java @@ -12,38 +12,56 @@ import java.util.Map; */ public class SkolemTermsManager { - public static final String skolemisedIndividualPrefix = Namespace.PAGODA_ANONY + "individual"; + public static final String SKOLEMISED_INDIVIDUAL_PREFIX = Namespace.PAGODA_ANONY + "individual"; private static SkolemTermsManager skolemTermsManager; - private int individualCounter = 0; - private Map termNumber = new HashMap<>(); - private Map mapIndividualToDepth = new HashMap<>(); + private int termsCounter = 0; + private Map mapClauseToId = new HashMap<>(); + private Map mapTermToDepth = new HashMap<>(); private int dependenciesCounter = 0; - // replace with hashcode. in case of collision you get only a different upper bound model. - // or, better, use perfect hashing (i.e. devise an ad-hoc hash function without collisions) + // TODO replace with hashcode. in case of collision you get only a different upper bound model. + // TODO you can use a cash. private Map, Integer> mapDependencyToId = new HashMap<>(); + private SkolemTermsManager() { + } + + public static int indexOfSkolemisedIndividual(Atom atom) { + Term t; + for(int index = 0; index < atom.getArity(); ++index) { + t = atom.getArgument(index); + if(t instanceof Individual && ((Individual) t).getIRI().contains(SKOLEMISED_INDIVIDUAL_PREFIX)) + return index; + } + return -1; + } + + public static SkolemTermsManager getInstance() { + if(skolemTermsManager == null) skolemTermsManager = new SkolemTermsManager(); + return skolemTermsManager; + } + /** * Get a fresh Individual, unique for the clause, the offset and the dependency. * */ public Individual getFreshIndividual(DLClause originalClause, int offset, Tuple dependency) { - if (!termNumber.containsKey(originalClause)) { - termNumber.put(originalClause, individualCounter); - individualCounter += noOfExistential(originalClause); + if(!mapClauseToId.containsKey(originalClause)) { + mapClauseToId.put(originalClause, termsCounter); + termsCounter += noOfExistential(originalClause); } if (!mapDependencyToId.containsKey(dependency)) { mapDependencyToId.put(dependency, dependenciesCounter++); } - String termId = termNumber.get(originalClause) + offset + "_" + mapDependencyToId(dependency); - Individual newIndividual = Individual.create(skolemisedIndividualPrefix + termId); + String termId = mapClauseToId.get(originalClause) + offset + "_" + mapDependencyToId(dependency); + Individual newIndividual = Individual.create(SKOLEMISED_INDIVIDUAL_PREFIX + termId); int depth = 0; for (Individual individual : dependency) depth = Integer.max(depth, mapIndividualToDepth(individual)); - mapIndividualToDepth.put(newIndividual, depth); + mapTermToDepth.put(newIndividual, depth); return newIndividual; } @@ -52,14 +70,14 @@ public class SkolemTermsManager { * Get a fresh Individual, unique for the clause and the offset. * */ public Individual getFreshIndividual(DLClause originalClause, int offset) { - if (!termNumber.containsKey(originalClause)) { - termNumber.put(originalClause, individualCounter); - individualCounter += noOfExistential(originalClause); + if(!mapClauseToId.containsKey(originalClause)) { + mapClauseToId.put(originalClause, termsCounter); + termsCounter += noOfExistential(originalClause); } - String termId = "" + termNumber.get(originalClause) + offset; - Individual newIndividual = Individual.create(skolemisedIndividualPrefix + termId); - mapIndividualToDepth.put(newIndividual, 0); + String termId = "" + mapClauseToId.get(originalClause) + offset; + Individual newIndividual = Individual.create(SKOLEMISED_INDIVIDUAL_PREFIX + termId); + mapTermToDepth.put(newIndividual, 0); return newIndividual; } @@ -69,7 +87,7 @@ public class SkolemTermsManager { *

* The term must have been generated by this manager. * */ - public int getDepth(Individual individual) { + public int getDepthOf(Individual individual) { return mapIndividualToDepth(individual); } @@ -77,24 +95,7 @@ public class SkolemTermsManager { * Get the number of individuals generated by this manager. * */ public int getNumberOfSkolemisedIndividual() { - return mapIndividualToDepth.keySet().size(); - } - - public static int indexOfSkolemisedIndividual(Atom atom) { - Term t; - for (int index = 0; index < atom.getArity(); ++index) { - t = atom.getArgument(index); - if (t instanceof Individual && ((Individual) t).getIRI().contains(skolemisedIndividualPrefix)) return index; - } - return -1; - } - - private SkolemTermsManager() { - } - - public static SkolemTermsManager getInstance() { - if (skolemTermsManager == null) skolemTermsManager = new SkolemTermsManager(); - return skolemTermsManager; + return mapTermToDepth.keySet().size(); } private int mapDependencyToId(Tuple dependency) { @@ -103,7 +104,7 @@ public class SkolemTermsManager { } private int mapIndividualToDepth(Individual dependency) { - if (mapIndividualToDepth.containsKey(dependency)) return mapIndividualToDepth.get(dependency); + if(mapTermToDepth.containsKey(dependency)) return mapTermToDepth.get(dependency); else return 0; } -- cgit v1.2.3