Refine search
public void visit(OWLDifferentIndividualsAxiom axiom) { for (OWLIndividual ind : axiom.getIndividuals()) { if (!ind.isAnonymous()) { getAxiomsForLHS(ind.asOWLNamedIndividual()).add(axiom); indexAxiomsByRHSEntities(ind, axiom); } } }
@Override public void visit(OWLDifferentIndividualsAxiom axiom) { axiom.individuals().forEach(ind -> { if (!ind.isAnonymous()) { getAxiomsForLHS(ind.asOWLNamedIndividual()).add(axiom); indexAxiomsByRHSEntities(ind, axiom); } }); }
@Override public Object visit(OWLDifferentIndividualsAxiom axiom) { return visitAxiom(axiom, () -> df.getOWLDifferentIndividualsAxiom(t(axiom.individuals()), t(axiom .annotations()))); }
@Override public void visit(OWLDifferentIndividualsAxiom axiom) { hashCode = primes[7]; hashCode = hashCode * MULT + axiom.getIndividuals().hashCode(); hashCode = hashCode * MULT + axiom.getAnnotations().hashCode(); }
/** * Builder initialized from an existing object. * * @param expected the existing object * @param df data factory */ public BuilderDifferentIndividuals(OWLDifferentIndividualsAxiom expected, OWLDataFactory df) { this(df); withItems(expected.individuals()).withAnnotations(expected.annotations()); }
@Override public NodeSet<OWLNamedIndividual> getDifferentIndividuals(OWLNamedIndividual ind) { ensurePrepared(); Set<OWLNamedIndividual> inds = new HashSet<>(); Set<OWLDifferentIndividualsAxiom> processed = new HashSet<>(); List<OWLNamedIndividual> stack = new LinkedList<>(); stack.add(ind); while (!stack.isEmpty()) { OWLNamedIndividual currentInd = stack.remove(0); Stream<OWLDifferentIndividualsAxiom> axioms = Imports.INCLUDED.stream(getRootOntology()) .flatMap(o -> o .differentIndividualAxioms(currentInd)).filter(processed::add); axioms.forEach(ax -> ax.individuals().filter(i -> i.isOWLNamedIndividual()).map(i -> i .asOWLNamedIndividual()).forEach(i -> { if (inds.add(i)) { stack.add(i); } })); } if (inds.isEmpty()) { inds.add(ind); } return new OWLNamedIndividualNodeSet( asUnorderedSet(inds.stream().map(this::getSameIndividuals))); }
if (!isFiltered(AxiomType.CLASS_ASSERTION)) { SectionMap<Object, OWLAxiom> expressions = new SectionMap<>(); filtersort(o.classAssertionAxioms(individual)).forEach(ax -> { expressions.put(ax.getClassExpression(), ax); axioms.add(ax); .of(o.objectPropertyAssertionAxioms(individual), o .negativeObjectPropertyAssertionAxioms(individual), o.dataPropertyAssertionAxioms(individual), o .negativeDataPropertyAssertionAxioms(individual)).flatMap(x -> x).sorted(ooc) .collect(toList()); if (!assertions.isEmpty()) { Collection<OWLDifferentIndividualsAxiom> nary = sortedCollection(); filtersort(o.differentIndividualAxioms(individual)).forEach(ax -> { if (ax.individuals().count() == 2) { add(inds, ax.individuals()); axioms.add(ax); } else { if (renderExtensions) { nary.forEach( ax -> writeSection(DIFFERENT_INDIVIDUALS, ax.individuals().iterator(), ", ", false));
.flatMap(o -> o.getClassAssertionAxioms(selectedClass).stream()) .map(OWLClassAssertionAxiom::getIndividual) .filter(i -> !i.isAnonymous()) .map(OWLIndividual::asOWLNamedIndividual) .collect(toSet()); .getAxioms(AxiomType.DIFFERENT_INDIVIDUALS) .stream() .filter(ax -> individuals.containsAll(ax.getIndividuals())) .map(ax -> new RemoveAxiom(activeOntology, ax)) .collect(toList()); OWLDifferentIndividualsAxiom ax = getOWLDataFactory().getOWLDifferentIndividualsAxiom(individuals); allChanges.add(new AddAxiom(activeOntology, ax)); getOWLModelManager().applyChanges(allChanges);
public boolean dia(@NonNull List<@NonNull SWRLBuiltInArgument> arguments) throws SWRLBuiltInException { checkNumberOfArgumentsEqualTo(2, arguments.size()); Set<OWLDifferentIndividualsAxiom> axioms = getBuiltInBridge().getOWLOntology() .getAxioms(AxiomType.DIFFERENT_INDIVIDUALS, Imports.INCLUDED).stream().flatMap(a -> a.asPairwiseAxioms().stream()) .collect(Collectors.toSet()); if (axioms.isEmpty()) return false; else { Map<@NonNull Integer, @NonNull OWLObject> inputArgumentValues = getInputArgumentValues(arguments, SWRLBuiltInArgumentType.NAMED_INDIVIDUAL, SWRLBuiltInArgumentType.NAMED_INDIVIDUAL); Map<@NonNull Integer, @NonNull SWRLMultiValueVariableBuiltInArgument> outputMultiValueArguments = createOutputMultiValueArguments( arguments); for (OWLDifferentIndividualsAxiom axiom : axioms) { OWLNamedIndividual candidateValue1 = axiom.getIndividualsAsList().get(0).asOWLNamedIndividual(); OWLNamedIndividual candidateValue2 = axiom.getIndividualsAsList().get(1).asOWLNamedIndividual(); if (!noBoundArgumentsMismatch(inputArgumentValues, candidateValue1, candidateValue2)) { if (outputMultiValueArguments.isEmpty()) return true; // We have a match and there are no unbound arguments - return immediately else { // We have a match so update any unbound arguments with the matched values if (outputMultiValueArguments.containsKey(0)) outputMultiValueArguments.get(0).addArgument(createNamedIndividualBuiltInArgument(candidateValue1)); if (outputMultiValueArguments.containsKey(1)) outputMultiValueArguments.get(1).addArgument(createNamedIndividualBuiltInArgument(candidateValue2)); } } } return processResultMultiValueArguments(arguments, outputMultiValueArguments); } }
@Override public List<Lint> match(final OWLOntology ontology) { final long totalEstimatedMemory = ontology// .axioms(AxiomType.DIFFERENT_INDIVIDUALS)// .map(axiom -> estimateMemoryConcumption(axiom.individuals().count()))// .reduce((sum, cost) -> sum + cost)// .orElse(0L); final List<Lint> allLints = new ArrayList<>(); if (totalEstimatedMemory > estimateMemoryConcumption(_maxAllowed)) { final Lint lint = new Lint(this, ontology); lint.setSeverity(new Severity(totalEstimatedMemory)); allLints.add(lint); } return allLints; }
writeNewLine(); writeOntologyHeader(); o.annotationPropertiesInSignature().sorted(ooc).forEach(this::write); o.datatypesInSignature().sorted(ooc).forEach(this::write); o.objectPropertiesInSignature().sorted(ooc).forEach(prop -> { write(prop); OWLObjectPropertyExpression invProp = prop.getInverseProperty(); o.axioms(AxiomType.DIFFERENT_INDIVIDUALS).sorted(ooc) .forEach(ax -> writeMoreThanTwo(ax, ax.individuals(), DIFFERENT_INDIVIDUALS)); o.axioms(AxiomType.SWRL_RULE).sorted(ooc)
@Override public Set<OWLAxiom> visit(OWLDifferentIndividualsAxiom axiom) { Set<OWLIndividual> renamed = asSet(axiom.individuals().map(ind -> assignName(ind))); return Collections.<OWLAxiom>singleton(dataFactory.getOWLDifferentIndividualsAxiom(renamed)); }
@Override public void visit(OWLDifferentIndividualsAxiom axiom) { axiom.individuals() .forEach(ind -> differentIndividualsAxiomsByIndividual.put(ind, axiom)); }
@Override public OWLClassExpression visit(OWLDifferentIndividualsAxiom axiom) { Set<OWLClassExpression> nominals = new HashSet<>(); axiom.individuals().forEach(ind -> nominals.add(oneOf(ind))); return factory.getOWLObjectIntersectionOf(nominals); }
@Override public void visit(OWLDifferentIndividualsAxiom axiom) { process(axiom); axiom.individuals().forEach(a -> a.accept(this)); }
@Override public void visit(final OWLDifferentIndividualsAxiom axiom) { _isEntailed = true; for (final OWLIndividual ind : asList(axiom.individuals())) if (ind.isAnonymous()) { deferAxiom(axiom); return; } final OWLIndividual[] list = axiom.individuals().toArray(OWLIndividual[]::new); for (int i = 0; i < list.length - 1; i++) { final OWLIndividual head = list[i]; for (int j = i + 1; j < list.length; j++) { final OWLIndividual next = list[j]; if (!_kb.isDifferentFrom(_reasoner.term(head), _reasoner.term(next))) { _isEntailed = false; return; } } } }
@Override public void visit(OWLDifferentIndividualsAxiom axiom) { for (Iterator<OWLIndividual> it = axiom.individuals().iterator(); it.hasNext(); ) { writeOpenBrace(); it.next().accept(this); writeCloseBrace(); if (it.hasNext()) { writeSpace(); write(NOT_EQUIV); writeSpace(); } } }
writeOntologyHeader(ontology); for (OWLAnnotationProperty prop : ontology.getAnnotationPropertiesInSignature()) { write(prop); for (OWLDatatype datatype : ontology.getDatatypesInSignature()) { write(datatype); for (OWLObjectProperty prop : ontology.getObjectPropertiesInSignature()) { write(prop); OWLObjectPropertyExpression invProp = prop.getInverseProperty(); for (OWLDifferentIndividualsAxiom ax : ontology.getAxioms(AxiomType.DIFFERENT_INDIVIDUALS)) { if (ax.getIndividuals().size() > 2) { Map<Object, Set<OWLAnnotation>> map = new HashMap<Object, Set<OWLAnnotation>>(); map.put(ax.getIndividuals(), ax.getAnnotations()); writeSection(DIFFERENT_INDIVIDUALS, map, ",", false, ontology);
public Boolean visit(OWLDifferentIndividualsAxiom axiom) { // see OWL 2 Syntax, Sec 11.2 // No axiom in Ax of the following form contains anonymous individuals: // SameIndividual, DifferentIndividuals, NegativeObjectPropertyAssertion, and NegativeDataPropertyAssertion. ArrayList<OWLIndividual> list=new ArrayList<OWLIndividual>(axiom.getIndividuals()); for (OWLIndividual i : list) { if (i.isAnonymous()) { throw new IllegalArgumentException("OWLDifferentIndividualsAxiom axioms are not allowed to be used "+"with anonymous individuals (see OWL 2 Syntax Sec 11.2) but the axiom "+axiom+" cotains an anonymous individual. "); } } for (int i=0;i<list.size()-1;i++) { OWLNamedIndividual head=list.get(i).asOWLNamedIndividual(); for (int j=i+1;j<list.size();j++) { OWLNamedIndividual next=list.get(j).asOWLNamedIndividual(); if (!reasoner.hasType(head,factory.getOWLObjectComplementOf(factory.getOWLObjectOneOf(next)),false)) return Boolean.FALSE; } } return Boolean.TRUE; } public Boolean visit(OWLSameIndividualAxiom axiom) {
@Override public void visit(OWLDifferentIndividualsAxiom axiom) { Set<OWLIndividual> renamedIndividuals = new HashSet<>(); if(normalizeABoxAxioms){ renamedIndividuals.add(df.getOWLNamedIndividual(IRI.create("http://dl-learner.org/pattern/a"))); renamedIndividuals.add(df.getOWLNamedIndividual(IRI.create("http://dl-learner.org/pattern/b"))); } else { for(OWLIndividual ind : axiom.getIndividuals()){ renamedIndividuals.add(expressionRenamer.rename(ind)); } } renamedAxiom = df.getOWLDifferentIndividualsAxiom(renamedIndividuals); }