@Override public Taxonomy<ElkClass> getTaxonomy(final String resource) throws ElkException { final Reasoner reasoner = TestReasonerUtils.createTestReasoner( getClass().getClassLoader().getResourceAsStream(resource), 1); return reasoner.getTaxonomy(); } @Override
/** * Helper method to get a {@link TaxonomyNode} from the taxonomy. * * @param elkClass * an {@link ElkClass} for which to find a {@link TaxonomyNode} * @return the {@link TaxonomyNode} for the given {@link ElkClass} * */ protected TaxonomyNode<ElkClass> getTaxonomyNode(ElkClass elkClass) throws ElkException { final Taxonomy<ElkClass> taxonomy = getTaxonomy(); final TaxonomyNode<ElkClass> node = taxonomy.getNode(elkClass); if (node != null) return node; // else if (allowFreshEntities) return new FreshTaxonomyNode<ElkClass>(elkClass, taxonomy); // else throw new ElkFreshEntitiesException(elkClass); }
/** * Helper method to get a {@link TaxonomyNode} from the taxonomy. * * @param elkClass * an {@link ElkClass} for which to find a {@link TaxonomyNode} * @return the {@link TaxonomyNode} for the given {@link ElkClass} * */ protected TaxonomyNode<ElkClass> getTaxonomyNode(ElkClass elkClass) throws ElkException { final Taxonomy<ElkClass> taxonomy = getTaxonomy(); final TaxonomyNode<ElkClass> node = taxonomy.getNode(elkClass); if (node != null) return node; // else if (allowFreshEntities) return new FreshTaxonomyNode<ElkClass>(elkClass, taxonomy); // else throw new ElkFreshEntitiesException(elkClass); }
/** * Helper method to get a {@link TaxonomyNode} from the taxonomy. * * @param elkClass * an {@link ElkClass} for which to find a {@link TaxonomyNode} * @return the {@link TaxonomyNode} for the given {@link ElkClass} * */ protected TaxonomyNode<ElkClass> getTaxonomyNode(ElkClass elkClass) throws ElkException { final Taxonomy<ElkClass> taxonomy = getTaxonomy(); final TaxonomyNode<ElkClass> node = taxonomy.getNode(elkClass); if (node != null) return node; // else if (allowFreshEntities) return new FreshTaxonomyNode<ElkClass>(elkClass, taxonomy); // else throw new ElkFreshEntitiesException(elkClass); }
public static Reasoner loadAndClassify(Set<? extends ElkAxiom> ontology) throws Exception { TestChangesLoader initialLoader = new TestChangesLoader(); Reasoner reasoner = TestReasonerUtils.createTestReasoner(initialLoader); for (ElkAxiom axiom : ontology) { initialLoader.add(axiom); } try { reasoner.getTaxonomy(); } catch (ElkInconsistentOntologyException e) { // shit happens } return reasoner; }
@Override public void precomputeInferences(InferenceType... inferenceTypes) throws ReasonerInterruptedException, TimeOutException, InconsistentOntologyException { LOGGER_.trace("precomputeInferences(InferenceType...)"); checkInterrupted(); // we use the main progress monitor only here this.reasoner_.setProgressMonitor(this.mainProgressMonitor_); try { for (InferenceType inferenceType : inferenceTypes) { if (inferenceType.equals(InferenceType.CLASS_HIERARCHY)) reasoner_.getTaxonomy(); else if (inferenceType.equals(InferenceType.CLASS_ASSERTIONS)) reasoner_.getInstanceTaxonomy(); else if (inferenceType .equals(InferenceType.OBJECT_PROPERTY_HIERARCHY)) { reasoner_.getObjectPropertyTaxonomy(); } } } catch (ElkUnsupportedReasoningTaskException e) { throw unsupportedOwlApiMethod( "precomputeInferences(inferenceTypes)", e.getMessage()); } catch (ElkException e) { throw elkConverter_.convert(e); } catch (ElkRuntimeException e) { throw elkConverter_.convert(e); } finally { this.reasoner_.setProgressMonitor(this.secondaryProgressMonitor_); } }
@Override public void precomputeInferences(InferenceType... inferenceTypes) throws ReasonerInterruptedException, TimeOutException, InconsistentOntologyException { LOGGER_.trace("precomputeInferences(InferenceType...)"); checkInterrupted(); // we use the main progress monitor only here this.reasoner_.setProgressMonitor(this.mainProgressMonitor_); try { for (InferenceType inferenceType : inferenceTypes) { if (inferenceType.equals(InferenceType.CLASS_HIERARCHY)) reasoner_.getTaxonomy(); else if (inferenceType.equals(InferenceType.CLASS_ASSERTIONS)) reasoner_.getInstanceTaxonomy(); else if (inferenceType .equals(InferenceType.OBJECT_PROPERTY_HIERARCHY)) { reasoner_.getObjectPropertyTaxonomy(); } } } catch (ElkUnsupportedReasoningTaskException e) { throw unsupportedOwlApiMethod( "precomputeInferences(inferenceTypes)", e.getMessage()); } catch (ElkException e) { throw elkConverter_.convert(e); } catch (ElkRuntimeException e) { throw elkConverter_.convert(e); } finally { this.reasoner_.setProgressMonitor(this.secondaryProgressMonitor_); } }
@Override public void precomputeInferences(InferenceType... inferenceTypes) throws ReasonerInterruptedException, TimeOutException, InconsistentOntologyException { LOGGER_.trace("precomputeInferences(InferenceType...)"); checkInterrupted(); // we use the main progress monitor only here this.reasoner_.setProgressMonitor(this.mainProgressMonitor_); try { for (InferenceType inferenceType : inferenceTypes) { if (inferenceType.equals(InferenceType.CLASS_HIERARCHY)) reasoner_.getTaxonomy(); else if (inferenceType.equals(InferenceType.CLASS_ASSERTIONS)) reasoner_.getInstanceTaxonomy(); else if (inferenceType .equals(InferenceType.OBJECT_PROPERTY_HIERARCHY)) { reasoner_.getObjectPropertyTaxonomy(); } } } catch (ElkUnsupportedReasoningTaskException e) { throw unsupportedOwlApiMethod( "precomputeInferences(inferenceTypes)", e.getMessage()); } catch (ElkException e) { throw elkConverter_.convert(e); } catch (ElkRuntimeException e) { throw elkConverter_.convert(e); } finally { this.reasoner_.setProgressMonitor(this.secondaryProgressMonitor_); } }
Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy();
@Test public void testEquivalences() throws ElkException { TestChangesLoader loader = new TestChangesLoader(); Reasoner reasoner = TestReasonerUtils.createTestReasoner(loader, 1); reasoner.setAllowIncrementalMode(false); ElkClass x = createElkClass("X"); ElkClass y = createElkClass("Y"); ElkAxiom axXsubY = objectFactory.getSubClassOfAxiom(x, y); ElkAxiom axYsubX = objectFactory.getSubClassOfAxiom(y, x); loader.add(axXsubY); LOGGER_.trace("********************* Initial taxonomy computation *********************"); Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); // node for X = [X] assertEquals(1, taxonomy.getNode(x).size()); reasoner.setAllowIncrementalMode(true); TestChangesLoader changeLoader = new TestChangesLoader(); reasoner.registerAxiomLoader(new TestAxiomLoaderFactory(changeLoader)); LOGGER_.trace("********* Taxonomy re-computation after incremental additions **********"); changeLoader.add(axYsubX); taxonomy = reasoner.getTaxonomy(); // node for X = [X,Y] assertEquals(2, taxonomy.getNode(y).size()); }
@Test public void testNewClassUnsatisfiable() throws ElkException { TestChangesLoader loader = new TestChangesLoader(); Reasoner reasoner = TestReasonerUtils.createTestReasoner(loader); reasoner.setAllowIncrementalMode(false); ElkClass a = createElkClass("A"); ElkClass b = createElkClass("B"); loader.add(objectFactory.getSubClassOfAxiom(a, b)); LOGGER_.trace("********************* Initial taxonomy computation *********************"); Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); assertTrue(taxonomy.getNode(a).getDirectSuperNodes() .contains(taxonomy.getNode(b))); reasoner.setAllowIncrementalMode(true); TestChangesLoader changeLoader = new TestChangesLoader(); reasoner.registerAxiomLoader(new TestAxiomLoaderFactory(changeLoader)); ElkClass c = createElkClass("C"); ElkClass d = createElkClass("D"); changeLoader.add( objectFactory.getDisjointClassesAxiom(Arrays.asList(c, d, c))); LOGGER_.trace("********** Taxonomy re-computation after incremental change ************"); taxonomy = reasoner.getTaxonomy(); assertSame(taxonomy.getBottomNode(), taxonomy.getNode(c)); assertNotSame(taxonomy.getBottomNode(), taxonomy.getNode(d)); }
Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy();
reasoner.getTaxonomy(); reasoner.getTaxonomy(); reasoner.getTaxonomy();
@Test public void testPropositionalAdditions() throws ElkException { TestChangesLoader loader = new TestChangesLoader(); Reasoner reasoner = TestReasonerUtils.createTestReasoner(loader); reasoner.setAllowIncrementalMode(false); ElkClass a = createElkClass("A"); ElkClass b = createElkClass("B"); ElkClass c = createElkClass("C"); ElkClass d = createElkClass("D"); loader.add(objectFactory.getSubClassOfAxiom(a, c)) .add(objectFactory.getSubClassOfAxiom(c, d)); LOGGER_.trace("********************* Initial taxonomy computation *********************"); Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); reasoner.setAllowIncrementalMode(true); TestChangesLoader changeLoader = new TestChangesLoader(); reasoner.registerAxiomLoader(new TestAxiomLoaderFactory(changeLoader)); changeLoader.add(objectFactory.getSubClassOfAxiom(a, b)) .add(objectFactory.getSubClassOfAxiom(b, d)); LOGGER_.trace("********* Taxonomy re-computation after incremental additions **********"); taxonomy = reasoner.getTaxonomy(); assertTrue(taxonomy.getNode(a).getDirectSuperNodes() .contains(taxonomy.getNode(c))); assertTrue(taxonomy.getNode(a).getDirectSuperNodes() .contains(taxonomy.getNode(b))); }
Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy();
Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy();
reasoner.getTaxonomy();
Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy();
Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy();
Taxonomy<ElkClass> taxonomy = reasoner.getTaxonomy(); taxonomy = reasoner.getTaxonomy();