From 39b60d4225f5efa4e0287a2c6ce69d90391c69db Mon Sep 17 00:00:00 2001 From: RncLsn Date: Fri, 3 Jul 2015 19:09:31 +0100 Subject: Many little changes. --- src/uk/ac/ox/cs/pagoda/rules/Program.java | 7 +- .../LimitedSkolemisationApproximator.java | 4 +- src/uk/ac/ox/cs/pagoda/rules/clauses/Clause.java | 100 +++++++++++++++++++++ .../ac/ox/cs/pagoda/rules/clauses/Conjunction.java | 4 + src/uk/ac/ox/cs/pagoda/rules/clauses/DLClause.java | 12 +++ 5 files changed, 122 insertions(+), 5 deletions(-) create mode 100644 src/uk/ac/ox/cs/pagoda/rules/clauses/Clause.java create mode 100644 src/uk/ac/ox/cs/pagoda/rules/clauses/Conjunction.java create mode 100644 src/uk/ac/ox/cs/pagoda/rules/clauses/DLClause.java (limited to 'src/uk/ac/ox/cs/pagoda/rules') diff --git a/src/uk/ac/ox/cs/pagoda/rules/Program.java b/src/uk/ac/ox/cs/pagoda/rules/Program.java index 85000e3..a0edf85 100644 --- a/src/uk/ac/ox/cs/pagoda/rules/Program.java +++ b/src/uk/ac/ox/cs/pagoda/rules/Program.java @@ -316,9 +316,10 @@ protected PredicateDependency dependencyGraph; private Atom getAtom(OWLObjectPropertyExpression exp, Variable x, Variable y) { if(exp instanceof OWLObjectProperty) return Atom.create(AtomicRole.create(((OWLObjectProperty) exp).toStringID()), x, y); - OWLObjectInverseOf inverseOf; - if(exp instanceof OWLObjectInverseOf && (inverseOf = - (OWLObjectInverseOf) exp).getInverse() instanceof OWLObjectProperty) + // TODO fixed, test it + OWLObjectPropertyExpression inverseOf; + if(exp instanceof OWLObjectInverseOf && (inverseOf = ( + (OWLObjectInverseOf) exp).getInverse()) instanceof OWLObjectProperty) return Atom.create(AtomicRole.create(((OWLObjectProperty) inverseOf).toStringID()), x, y); return null; } 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 dfe1e59..d694b61 100644 --- a/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java +++ b/src/uk/ac/ox/cs/pagoda/rules/approximators/LimitedSkolemisationApproximator.java @@ -64,14 +64,14 @@ public class LimitedSkolemisationApproximator implements TupleDependentApproxima private Collection overApprox(DLClause clause, DLClause originalClause, Collection> violationTuples) { ArrayList result = new ArrayList<>(); - for(Tuple violationTuple : violationTuples) + for(Tuple violationTuple : violationTuples) { if(getMaxDepth(violationTuple) < maxTermDepth) { result.addAll(getGroundSkolemisation(clause, originalClause, violationTuple)); Utility.logDebug("Approximating maximal individual by a constant in rule:" + originalClause); } else result.addAll(alternativeApproximator.convert(clause, originalClause, null)); - + } return result; } diff --git a/src/uk/ac/ox/cs/pagoda/rules/clauses/Clause.java b/src/uk/ac/ox/cs/pagoda/rules/clauses/Clause.java new file mode 100644 index 0000000..2adb66b --- /dev/null +++ b/src/uk/ac/ox/cs/pagoda/rules/clauses/Clause.java @@ -0,0 +1,100 @@ +package uk.ac.ox.cs.pagoda.rules.clauses; + +public class Clause { + +// public static final String IF = ":-"; +// public static final String OR = "|"; +// public static final String AND = ","; +// +// protected final List> head; +// protected final List body; +// +// protected Clause(Atom[] headAtoms, Atom[] bodyAtoms) { +// this.head = Collections.singletonList(Arrays.asList(headAtoms)); +// this.body= Arrays.asList(bodyAtoms); +// } +// +// protected Clause(String s) { +// this.headAtoms = null; +// this.bodyAtoms = null; +// } +// +// public int getHeadLength() { +// return headAtoms.length; +// } +// +// public Atom getHeadAtom(int atomIndex) { +// return headAtoms[atomIndex]; +// } +// +// public Atom[] getHeadAtoms() { +// return headAtoms.clone(); +// } +// +// public int getBodyLength() { +// return bodyAtoms.length; +// } +// +// public Atom getBodyAtom(int atomIndex) { +// return bodyAtoms[atomIndex]; +// } +// +// public Atom[] getBodyAtoms() { +// return bodyAtoms.clone(); +// } +// +// public String toString(Prefixes prefixes) { +// StringBuilder buffer = new StringBuilder(); +// for(int headIndex = 0; headIndex < headAtoms.length; headIndex++) { +// if(headIndex != 0) +// buffer.append(" ").append(OR).append(" "); +// buffer.append(headAtoms[headIndex].toString(prefixes)); +// } +// buffer.append(" ").append(IF).append(" "); +// for(int bodyIndex = 0; bodyIndex < bodyAtoms.length; bodyIndex++) { +// if(bodyIndex != 0) +// buffer.append(AND).append(" "); +// buffer.append(bodyAtoms[bodyIndex].toString(prefixes)); +// } +// return buffer.toString(); +// } +// +// public String toString() { +// return toString(Prefixes.STANDARD_PREFIXES); +// } +// +// protected static InterningManager s_interningManager = new InterningManager() { +// protected boolean equal(Clause object1, Clause object2) { +// if(object1.head.length != object2.headAtoms.length +// || object1.bodyAtoms.length != object2.bodyAtoms.length) +// return false; +// for(int index = object1.headAtoms.length - 1; index >= 0; --index) +// if(object1.headAtoms[index] != object2.headAtoms[index]) +// return false; +// for(int index = object1.bodyAtoms.length - 1; index >= 0; --index) +// if(object1.bodyAtoms[index] != object2.bodyAtoms[index]) +// return false; +// return true; +// } +// +// protected int getHashCode(Clause object) { +// int hashCode = 0; +// for(int index = object.bodyAtoms.length - 1; index >= 0; --index) +// hashCode += object.bodyAtoms[index].hashCode(); +// for(int index = object.headAtoms.length - 1; index >= 0; --index) +// hashCode += object.headAtoms[index].hashCode(); +// return hashCode; +// } +// }; +// +// /** +// * Creates a clause from a string. +// * +// * @param s +// * @return +// */ +// public static Clause create(String s) { +// return s_interningManager.intern(new Clause(s)); +// } + +} diff --git a/src/uk/ac/ox/cs/pagoda/rules/clauses/Conjunction.java b/src/uk/ac/ox/cs/pagoda/rules/clauses/Conjunction.java new file mode 100644 index 0000000..91bb3e7 --- /dev/null +++ b/src/uk/ac/ox/cs/pagoda/rules/clauses/Conjunction.java @@ -0,0 +1,4 @@ +package uk.ac.ox.cs.pagoda.rules.clauses; + +public class Conjunction { +} diff --git a/src/uk/ac/ox/cs/pagoda/rules/clauses/DLClause.java b/src/uk/ac/ox/cs/pagoda/rules/clauses/DLClause.java new file mode 100644 index 0000000..7394be0 --- /dev/null +++ b/src/uk/ac/ox/cs/pagoda/rules/clauses/DLClause.java @@ -0,0 +1,12 @@ +package uk.ac.ox.cs.pagoda.rules.clauses; + +public class DLClause extends Clause { + +// private DLClause(Atom[] headAtoms, Atom[] bodyAtoms) { +// super(headAtoms, bodyAtoms); +// } +// +// public static DLClause create(Atom[] headAtoms, Atom[] bodyAtoms) { +// return s_interningManager.intern(new DLClause(headAtoms, bodyAtoms)); +// } +} -- cgit v1.2.3