/** * This supposed to be the central place where the reasoner gets its * configuration options * * @param config */ public synchronized void setConfigurationOptions( ReasonerConfiguration config) { this.workerNo_ = config.getParameterAsInt( ReasonerConfiguration.NUM_OF_WORKING_THREADS); setAllowIncrementalMode(config.getParameterAsBoolean( ReasonerConfiguration.INCREMENTAL_MODE_ALLOWED)); }
/** * This supposed to be the central place where the reasoner gets its * configuration options * * @param config */ public synchronized void setConfigurationOptions( ReasonerConfiguration config) { this.workerNo_ = config.getParameterAsInt( ReasonerConfiguration.NUM_OF_WORKING_THREADS); setAllowIncrementalMode(config.getParameterAsBoolean( ReasonerConfiguration.INCREMENTAL_MODE_ALLOWED)); }
/** * This supposed to be the central place where the reasoner gets its * configuration options * * @param config */ public synchronized void setConfigurationOptions( ReasonerConfiguration config) { this.workerNo_ = config.getParameterAsInt( ReasonerConfiguration.NUM_OF_WORKING_THREADS); setAllowIncrementalMode(config.getParameterAsBoolean( ReasonerConfiguration.INCREMENTAL_MODE_ALLOWED)); }
@Override public Reasoner createReasoner(Iterable<ElkAxiom> axioms) { Reasoner reasoner = TestReasonerUtils.createTestReasoner( new TestChangesLoader(axioms, IncrementalChangeType.ADD)); reasoner.setAllowIncrementalMode(false); return reasoner; }
@Override public void initIncremental() throws Exception { standardReasoner_ = TestReasonerUtils.createTestReasoner( new TestChangesLoader(allAxioms_, IncrementalChangeType.ADD)); standardReasoner_.setAllowIncrementalMode(false); final ReasonerConfiguration config = ReasonerConfiguration .getConfiguration(); config.setParameters(additionalConfigIncremental()); incrementalReasoner_ = TestReasonerUtils.createTestReasoner( new TestChangesLoader(allAxioms_, IncrementalChangeType.ADD), config); incrementalReasoner_.setAllowIncrementalMode(true); }
@Override public void initWithInterrupts() throws Exception { standardReasoner_ = TestReasonerUtils.createTestReasoner( new TestChangesLoader(allAxioms_, IncrementalChangeType.ADD)); standardReasoner_.setAllowIncrementalMode(false); final ReasonerConfiguration config = ReasonerConfiguration .getConfiguration(); config.setParameters(additionalConfigWithInterrupts()); final Random random = new Random(RandomSeedProvider.VALUE); incrementalReasoner_ = TestReasonerUtils.createTestReasoner( getManifest().getInput().getUrl().openStream(), new TestReasonerInterrupter(new RandomInterruptMonitor(random, getInterruptionChance(), getInterruptionIntervalNanos())), config); incrementalReasoner_.setAllowIncrementalMode(true); }
reasoner.setAllowIncrementalMode(false); reasoner.setAllowIncrementalMode(true);
@Test public void randomWalk() throws Exception { // axioms that can change OnOffVector<ElkAxiom> changingAxioms = new OnOffVector<ElkAxiom>(128); // other axioms that do not change List<ElkAxiom> staticAxioms = new ArrayList<ElkAxiom>(); Reasoner incrementalReasoner; long seed = RandomSeedProvider.VALUE; LOGGER_.info("Initial load of test axioms"); InputStream stream = manifest.getInput().getUrl().openStream(); AxiomLoader fileLoader = new Owl2StreamLoader.Factory( new Owl2FunctionalStyleParserFactory(), stream).getAxiomLoader(DummyInterruptMonitor.INSTANCE); TestAxiomLoader trackingLoader = getAxiomTrackingLoader(fileLoader, changingAxioms, staticAxioms); incrementalReasoner = TestReasonerUtils.createTestReasoner( trackingLoader); incrementalReasoner.setAllowIncrementalMode(true); try { // incrementalReasoner.loadAxioms(); // let the runner run.. getRandomWalkRunner(MAX_ROUNDS, ITERATIONS).run( incrementalReasoner, changingAxioms, staticAxioms, seed); } catch (Exception e) { throw new ElkRuntimeException("Seed " + seed, e); } finally { stream.close(); assertTrue(incrementalReasoner.shutdown()); } }
@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)); }
@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 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))); }
reasoner.setAllowIncrementalMode(false); reasoner.setAllowIncrementalMode(true); TestChangesLoader changeLoader = new TestChangesLoader(); reasoner.registerAxiomLoader(new TestAxiomLoaderFactory(changeLoader));
Reasoner reasoner = TestReasonerUtils.createTestReasoner(loader); reasoner.setAllowIncrementalMode(false); assertTrue(taxonomy.getNode(B).getAllInstanceNodes().size() == 1); reasoner.setAllowIncrementalMode(true); TestChangesLoader changeLoader = new TestChangesLoader(); reasoner.registerAxiomLoader(new TestAxiomLoaderFactory(changeLoader));
reasoner.setAllowIncrementalMode(false); reasoner.setAllowIncrementalMode(true);
Reasoner reasoner = TestReasonerUtils.createTestReasoner(loader); reasoner.setAllowIncrementalMode(false); assertTrue(taxonomy.getNode(B).getAllInstanceNodes().size() == 1); reasoner.setAllowIncrementalMode(true);
reasoner.setAllowIncrementalMode(false); reasoner.setAllowIncrementalMode(true); TestChangesLoader changeLoader = new TestChangesLoader(); reasoner.registerAxiomLoader(new TestAxiomLoaderFactory(changeLoader));
Reasoner reasoner = TestReasonerUtils.createTestReasoner(loader); reasoner.setAllowIncrementalMode(false); reasoner.setAllowIncrementalMode(true);
Reasoner reasoner = TestReasonerUtils.createTestReasoner(loader); reasoner.setAllowIncrementalMode(false); reasoner.setAllowIncrementalMode(true);
@Test public void testAddingFreshTrivialProperty() throws Exception { final ElkObject.Factory factory = new ElkObjectEntityRecyclingFactory(); final ElkClass a = factory .getClass(new ElkFullIri("http://example.org/A")); final ElkClass b = factory .getClass(new ElkFullIri("http://example.org/B")); final ElkClass c = factory .getClass(new ElkFullIri("http://example.org/C")); final ElkClass d = factory .getClass(new ElkFullIri("http://example.org/D")); final ElkObjectProperty r = factory .getObjectProperty(new ElkFullIri("http://example.org/R")); final Set<ElkAxiom> initial = new HashSet<ElkAxiom>(); initial.add(factory.getSubClassOfAxiom(b, c)); final Reasoner reasoner = TestReasonerUtils.loadAndClassify(initial); reasoner.setAllowIncrementalMode(true); final TestChangesLoader loader = new TestChangesLoader(); loader.add(factory.getSubClassOfAxiom(a, factory.getObjectSomeValuesFrom(r, b))); loader.add(factory .getSubClassOfAxiom(factory.getObjectSomeValuesFrom(r, c), d)); reasoner.registerAxiomLoader(new TestAxiomLoaderFactory(loader)); TracingTestUtils.checkTracingCompleteness(a, d, reasoner); }
Reasoner reasoner = TestReasonerUtils.createTestReasoner(loader); reasoner.setAllowIncrementalMode(false); .contains(taxonomy.getNode(D))); reasoner.setAllowIncrementalMode(true); TestChangesLoader changeLoader = new TestChangesLoader(); reasoner.registerAxiomLoader(new TestAxiomLoaderFactory(changeLoader));