From 7a68441a541b12b22587fb53072193e1130049ff Mon Sep 17 00:00:00 2001 From: RncLsn Date: Tue, 19 May 2015 19:06:04 +0100 Subject: Deleted unused classes. --- .../tracking/TrackingRuleEncoderDisjVar1.java | 247 ++++++++++----------- 1 file changed, 123 insertions(+), 124 deletions(-) (limited to 'src/uk/ac/ox/cs/pagoda/tracking') diff --git a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java index 2143b03..d96c747 100644 --- a/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java +++ b/src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderDisjVar1.java @@ -17,95 +17,98 @@ import java.util.Set; public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap { + private Set disjunctiveRules = new HashSet(); + private Variable X = Variable.create("X"), Y = Variable.create("Y"); + private String bottomTrackingProgram = null; + public TrackingRuleEncoderDisjVar1(UpperDatalogProgram program, BasicQueryEngine store) { super(program, store); } - private Set disjunctiveRules = new HashSet(); - @Override public boolean encodingRules() { if (super.encodingRules()) { processDisjunctiveRules(); - return true; + return true; } - return false; + return false; } @Override protected void encodingRule(DLClause clause) { if (currentQuery.isBottom()) { // super.encodingRule(clause); - encodingBottomQueryClause(clause); - return ; + encodingBottomQueryClause(clause); + return; } - + DLClause original = program.getCorrespondingClause(clause); if (original.getHeadLength() <= 1) { super.encodingRule(clause); - } + } else { if (!DLClauseHelper.hasSubsetBodyAtoms(clause, original)) super.encodingRule(clause); addDisjunctiveRule(original); } - + } - private void processDisjunctiveRules() { for (DLClause clause: disjunctiveRules) encodingDisjunctiveRule(clause); } - + private Atom getAuxiliaryAtom(Atom headAtom) { - DLPredicate p = headAtom.getDLPredicate(); + DLPredicate p = headAtom.getDLPredicate(); if (p instanceof AtLeast || p instanceof AtLeast) { - return Atom.create(generateAuxiliaryRule((AtLeast) p, true), headAtom.getArgument(0)); + return Atom.create(generateAuxiliaryRule((AtLeast) p, true), headAtom.getArgument(0)); } - if (p instanceof AtomicConcept) - return Atom.create(generateAuxiliaryRule((AtomicConcept) p), headAtom.getArgument(0)); - if (p instanceof AtomicRole) + if(p instanceof AtomicConcept) + return Atom.create(generateAuxiliaryRule((AtomicConcept) p), headAtom.getArgument(0)); + if(p instanceof AtomicRole) return Atom.create(generateAuxiliaryRule((AtomicRole) p), headAtom.getArgument(0), headAtom.getArgument(1)); - if (p instanceof Equality || p instanceof AnnotatedEquality) - return Atom.create(generateAuxiliaryRule(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); - if (p instanceof Inequality) - return Atom.create(generateAuxiliaryRule((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1)); + if(p instanceof Equality || p instanceof AnnotatedEquality) + return Atom.create(generateAuxiliaryRule(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); + if(p instanceof Inequality) + return Atom.create(generateAuxiliaryRule((Inequality) p), headAtom.getArgument(0), headAtom.getArgument(1)); return null; } private Atom getTrackingAtom(Atom headAtom) { - DLPredicate p = headAtom.getDLPredicate(); + DLPredicate p = headAtom.getDLPredicate(); if (p instanceof AtLeast) { - p = Normalisation.toAtLeastConcept((AtLeast) p); - return Atom.create(getTrackingDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom.getArgument(0)); + p = Normalisation.toAtLeastConcept((AtLeast) p); + return Atom.create(getTrackingDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom + .getArgument(0)); } - if (p instanceof AtomicConcept) + if(p instanceof AtomicConcept) return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0)); - if (p instanceof AtomicRole) + if(p instanceof AtomicRole) return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1)); - if (p instanceof Equality || p instanceof AnnotatedEquality) - return Atom.create(getTrackingDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); - if (p instanceof Inequality) + if(p instanceof Equality || p instanceof AnnotatedEquality) + return Atom.create(getTrackingDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); + if(p instanceof Inequality) return Atom.create(getTrackingDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1)); return null; } private Atom getGapAtom(Atom headAtom) { - DLPredicate p = headAtom.getDLPredicate(); + DLPredicate p = headAtom.getDLPredicate(); if (p instanceof AtLeast) { - p = Normalisation.toAtLeastConcept((AtLeast) p); - return Atom.create(getGapDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom.getArgument(0)); + p = Normalisation.toAtLeastConcept((AtLeast) p); + return Atom.create(getGapDLPredicate(AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p))), headAtom + .getArgument(0)); } - if (p instanceof AtomicConcept) + if(p instanceof AtomicConcept) return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0)); - if (p instanceof AtomicRole) + if(p instanceof AtomicRole) return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1)); - if (p instanceof Equality || p instanceof AnnotatedEquality) - return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); - if (p instanceof Inequality) + if(p instanceof Equality || p instanceof AnnotatedEquality) + return Atom.create(getGapDLPredicate(Equality.INSTANCE), headAtom.getArgument(0), headAtom.getArgument(1)); + if(p instanceof Inequality) return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0), headAtom.getArgument(1)); if (p instanceof DatatypeRestriction) return Atom.create(getGapDLPredicate(p), headAtom.getArgument(0)); @@ -115,71 +118,71 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap { private void encodingDisjunctiveRule(DLClause clause) { int headLength = clause.getHeadLength(); - + Atom[] auxAtoms = new Atom[headLength]; for (int i = 0; i < headLength; ++i) auxAtoms[i] = getAuxiliaryAtom(clause.getHeadAtom(i)); - + Atom[] trackingAtoms = new Atom[headLength]; for (int i = 0; i < headLength; ++i) trackingAtoms[i] = getTrackingAtom(clause.getHeadAtom(i)); - + Atom[] gapAtoms = new Atom[headLength]; for (int i = 0; i < headLength; ++i) gapAtoms[i] = getGapAtom(clause.getHeadAtom(i)); - + Atom[] bodyAtoms = clause.getBodyAtoms(); - + LinkedList newHeadAtoms = new LinkedList(); - DLPredicate selected = AtomicConcept.create(getSelectedPredicate()); + DLPredicate selected = AtomicConcept.create(getSelectedPredicate()); newHeadAtoms.add(Atom.create(selected, getIndividual4GeneralRule(clause))); - + for (Atom atom: bodyAtoms) { Atom newAtom = Atom.create( - getTrackingDLPredicate(atom.getDLPredicate()), + getTrackingDLPredicate(atom.getDLPredicate()), DLClauseHelper.getArguments(atom)); newHeadAtoms.add(newAtom); } DLClause newClause; - int index; + int index; for (int j = 0; j < headLength; ++j) { Atom[] newBodyAtoms = new Atom[headLength * 2 + bodyAtoms.length]; - index = 0; + index = 0; for (int i = 0; i < headLength; ++i, ++index) - newBodyAtoms[index] = gapAtoms[i]; + newBodyAtoms[index] = gapAtoms[i]; for (int i = 0; i < headLength; ++i, ++index) if (i != j) newBodyAtoms[index] = auxAtoms[i]; - else - newBodyAtoms[index] = trackingAtoms[i]; - + else + newBodyAtoms[index] = trackingAtoms[i]; + for (int i = 0; i < bodyAtoms.length; ++i, ++index) - newBodyAtoms[index] = bodyAtoms[i]; - + newBodyAtoms[index] = bodyAtoms[i]; + for (Atom atom: newHeadAtoms) { - newClause = DLClause.create(new Atom[] {atom}, newBodyAtoms); + newClause = DLClause.create(new Atom[]{atom}, newBodyAtoms); addTrackingClause(newClause); } } } private void addTrackingClause(DLClause clause) { - trackingClauses.add(clause); + trackingClauses.add(clause); } private void addDisjunctiveRule(DLClause clause) { disjunctiveRules.add(clause); } - + private DLPredicate getAuxPredicate(DLPredicate p) { if (p instanceof AtLeastConcept) { StringBuilder builder = new StringBuilder( Normalisation.getAuxiliaryConcept4Disjunct((AtLeastConcept) p)); - builder.append("_AUXa").append(currentQuery.getQueryID()); - return AtomicConcept.create(builder.toString()); + builder.append("_AUXa").append(currentQuery.getQueryID()); + return AtomicConcept.create(builder.toString()); } - + return getDLPredicate(p, "_AUXa" + currentQuery.getQueryID()); } @@ -188,120 +191,118 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap { } private DLPredicate generateAuxiliaryRule(AtLeast p1, boolean withAux) { - AtLeastConcept p = Normalisation.toAtLeastConcept(p1); - - int num = p.getNumber(); - Variable[] Ys = new Variable[num]; + AtLeastConcept p = Normalisation.toAtLeastConcept(p1); + + int num = p.getNumber(); + Variable[] Ys = new Variable[num]; if (num > 1) - for (int i = 0; i < num; ++i) + for(int i = 0; i < num; ++i) Ys[i] = Variable.create("Y" + (i + 1)); - else - Ys[0] = Y; - - Collection expandedAtom = new LinkedList(); - Collection representativeAtom = new LinkedList(); + else + Ys[0] = Y; + + Collection expandedAtom = new LinkedList(); + Collection representativeAtom = new LinkedList(); if (p.getOnRole() instanceof AtomicRole) { - AtomicRole r = (AtomicRole) p.getOnRole(); - for (int i = 0; i < num; ++i) + AtomicRole r = (AtomicRole) p.getOnRole(); + for(int i = 0; i < num; ++i) expandedAtom.add(Atom.create(r, X, Ys[i])); - representativeAtom.add(Atom.create(r, X, Ys[0])); + representativeAtom.add(Atom.create(r, X, Ys[0])); } else { - AtomicRole r = ((InverseRole) p.getOnRole()).getInverseOf(); - for (int i = 0; i < num; ++i) + AtomicRole r = ((InverseRole) p.getOnRole()).getInverseOf(); + for(int i = 0; i < num; ++i) expandedAtom.add(Atom.create(r, Ys[i], X)); - representativeAtom.add(Atom.create(r, Ys[0], X)); + representativeAtom.add(Atom.create(r, Ys[0], X)); } - + if (num > 1) { - representativeAtom.add(Atom.create(Inequality.INSTANCE, Ys[0], Ys[1])); + representativeAtom.add(Atom.create(Inequality.INSTANCE, Ys[0], Ys[1])); } for (int i = 0; i < num; ++i) for (int j = i + 1; j < num; ++j) - expandedAtom.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j])); - + expandedAtom.add(Atom.create(Inequality.INSTANCE, Ys[i], Ys[j])); + if (!p.getToConcept().equals(AtomicConcept.THING)) { - AtomicConcept c; - if (p.getToConcept() instanceof AtomicConcept) + AtomicConcept c; + if(p.getToConcept() instanceof AtomicConcept) c = (AtomicConcept) p.getToConcept(); else { c = OverApproxExist.getNegationConcept(((AtomicNegationConcept) p.getToConcept()).getNegatedAtomicConcept()); } for (int i = 0; i < num; ++i) - expandedAtom.add(Atom.create(c, Ys[i])); + expandedAtom.add(Atom.create(c, Ys[i])); representativeAtom.add(Atom.create(c, Ys[0])); } AtomicConcept ac = AtomicConcept.create(Normalisation.getAuxiliaryConcept4Disjunct(p)); - DLPredicate trackingPredicate = getTrackingDLPredicate(ac); - DLPredicate gapPredicate = getGapDLPredicate(ac); + DLPredicate trackingPredicate = getTrackingDLPredicate(ac); + DLPredicate gapPredicate = getGapDLPredicate(ac); DLPredicate auxPredicate = withAux ? getAuxPredicate(p) : null; - + for (Atom atom: representativeAtom) { - Atom[] bodyAtoms = new Atom[expandedAtom.size() + 1]; + Atom[] bodyAtoms = new Atom[expandedAtom.size() + 1]; if (atom.getArity() == 1) bodyAtoms[0] = Atom.create(getTrackingDLPredicate(atom.getDLPredicate()), atom.getArgument(0)); - else + else bodyAtoms[0] = Atom.create(getTrackingDLPredicate(atom.getDLPredicate()), atom.getArgument(0), atom.getArgument(1)); - int i = 0; + int i = 0; for (Atom bodyAtom: expandedAtom) - bodyAtoms[++i] = bodyAtom; + bodyAtoms[++i] = bodyAtom; addTrackingClause(DLClause.create(new Atom[] {Atom.create(trackingPredicate, X)}, bodyAtoms)); - - bodyAtoms = new Atom[expandedAtom.size() + 1]; + + bodyAtoms = new Atom[expandedAtom.size() + 1]; if (atom.getArity() == 1) bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0)); - else + else bodyAtoms[0] = Atom.create(getGapDLPredicate(atom.getDLPredicate()), atom.getArgument(0), atom.getArgument(1)); - i = 0; + i = 0; for (Atom bodyAtom: expandedAtom) - bodyAtoms[++i] = bodyAtom; + bodyAtoms[++i] = bodyAtom; addTrackingClause(DLClause.create(new Atom[] {Atom.create(gapPredicate, X)}, bodyAtoms)); - + if (withAux) { - bodyAtoms = new Atom[expandedAtom.size() + 1]; + bodyAtoms = new Atom[expandedAtom.size() + 1]; bodyAtoms[0] = getAuxiliaryAtom(atom); - i = 0; + i = 0; for (Atom bodyAtom: expandedAtom) - bodyAtoms[++i] = bodyAtom; + bodyAtoms[++i] = bodyAtom; addTrackingClause(DLClause.create(new Atom[] {Atom.create(auxPredicate, X)}, bodyAtoms)); } } - + return withAux ? auxPredicate : trackingPredicate; } private DLPredicate generateAuxiliaryRule(AtomicRole p) { - if (currentQuery.isBottom()) + if(currentQuery.isBottom()) return getTrackingDLPredicate(p); - - DLPredicate ret = getAuxPredicate(p); + + DLPredicate ret = getAuxPredicate(p); Atom[] headAtom = new Atom[] {Atom.create(ret, X, Y)}; addTrackingClause( - DLClause.create(headAtom, new Atom[] {Atom.create(getTrackingDLPredicate(p), X, Y)})); + DLClause.create(headAtom, new Atom[]{Atom.create(getTrackingDLPredicate(p), X, Y)})); addTrackingClause( - DLClause.create(headAtom, new Atom[] {Atom.create(getTrackingBottomDLPredicate(p), X, Y)})); - - return ret; + DLClause.create(headAtom, new Atom[]{Atom.create(getTrackingBottomDLPredicate(p), X, Y)})); + + return ret; } - - private Variable X = Variable.create("X"), Y = Variable.create("Y"); private DLPredicate generateAuxiliaryRule(AtomicConcept p) { if (currentQuery.isBottom()) - return getTrackingDLPredicate(p); - - DLPredicate ret = getAuxPredicate(p); - Atom[] headAtom = new Atom[] {Atom.create(ret, X)}; + return getTrackingDLPredicate(p); + + DLPredicate ret = getAuxPredicate(p); + Atom[] headAtom = new Atom[]{Atom.create(ret, X)}; addTrackingClause( - DLClause.create(headAtom, - new Atom[] { Atom.create(getTrackingDLPredicate(p), X)})); + DLClause.create(headAtom, + new Atom[]{Atom.create(getTrackingDLPredicate(p), X)})); addTrackingClause( - DLClause.create(headAtom, + DLClause.create(headAtom, new Atom[] { Atom.create(getTrackingBottomDLPredicate(p), X)})); - - return ret; + + return ret; } private DLPredicate generateAuxiliaryRule(Equality instance) { @@ -309,20 +310,18 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap { } private DLPredicate generateAuxiliaryRule(Inequality instance) { - return generateAuxiliaryRule(AtomicRole.create(Namespace.INEQUALITY)); + return generateAuxiliaryRule(AtomicRole.create(Namespace.INEQUALITY)); } - + @Override public String getTrackingProgram() { StringBuilder sb = getTrackingProgramBody(); if (currentQuery.isBottom()) - sb.append(getBottomTrackingProgram()); - sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText()); - return sb.toString(); + sb.append(getBottomTrackingProgram()); + sb.insert(0, MyPrefixes.PAGOdAPrefixes.prefixesText()); + return sb.toString(); } - private String bottomTrackingProgram = null; - private String getBottomTrackingProgram() { if (bottomTrackingProgram != null) return bottomTrackingProgram.replace("_tn", getTrackingPredicate("")); @@ -350,7 +349,7 @@ public class TrackingRuleEncoderDisjVar1 extends TrackingRuleEncoderWithGap { // for (Atom tAtom: clause.getHeadAtoms()) { // for (int i = 0; i < tAtom.getArity(); ++i) // if ((t = tAtom.getArgument(i)) instanceof Individual) -// if (((Individual) t).getIRI().startsWith(OverApproxExist.skolemisedIndividualPrefix)) +// if (((Individual) t).getIRI().startsWith(OverApproxExist.SKOLEMISED_INDIVIDUAL_PREFIX)) // clause = program.getCorrespondingClause(clause); // } -- cgit v1.2.3