final Datatype<?> pd = rd.getDatatype().getPrimitiveDatatype(); Set<RestrictedDatatype<?>> others = byPrimitive.get(pd); if (others == null) RestrictedDatatype<?> merge = it.next(); while (it.hasNext()) merge = merge.union(it.next()); if (rd.contains(o)) it.remove();
@SuppressWarnings("deprecation") @Override public boolean containsAtLeast(final int n) { int values = n - _values.size(); if (values <= 0) return true; for (final RestrictedDatatype<?> rd : _ranges) { if (rd.containsAtLeast(n)) return true; values -= rd.size(); // FIXME This may crash. } return values <= 0; }
@Override public boolean hasNext() { if (enumIt.hasNext()) return true; if (valueIt == null) if (rangeIt.hasNext()) valueIt = rangeIt.next().valueIterator(); else return false; while (!valueIt.hasNext()) if (rangeIt.hasNext()) valueIt = rangeIt.next().valueIterator(); else return false; return true; }
@Override public T getValue(final ATermAppl literal) throws InvalidLiteralException { final T value = _range.getDatatype().getValue(literal); if (!_range.contains(value)) throw new InvalidLiteralException(_name, literal.getArgument(ATermUtils.LIT_VAL_INDEX).toString()); return value; }
/** * Test that an integer is correctly excluded from an infinite integer interval */ @Test public void excludeIntInt1() { RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null); dr = dr.exclude(singleton(1)); assertFalse(dr.contains(1)); assertTrue(dr.contains(0)); assertTrue(dr.contains(2)); assertFalse(dr.contains(decimal("0.99999"))); assertFalse(dr.contains(decimal("1.00001"))); assertFalse(dr.isEmpty()); assertTrue(dr.isEnumerable()); assertFalse(dr.isFinite()); }
dr1 = dr1.applyConstrainingFacet(MIN_INCLUSIVE.getName(), -10); dr1 = dr1.applyConstrainingFacet(MAX_INCLUSIVE.getName(), -2); dr2 = dr2.applyConstrainingFacet(MIN_INCLUSIVE.getName(), 12); dr2 = dr2.applyConstrainingFacet(MAX_INCLUSIVE.getName(), 13); final RestrictedDatatype<Number> dr = dr1.union(dr2); assertFalse(dr.isEmpty()); assertTrue(dr.isFinite()); assertTrue(dr.isEnumerable()); final Iterator<Number> it = dr.valueIterator(); for (int i = -10; i <= 13; i++) assertFalse(dr.contains(decimal("-10.1"))); assertFalse(dr.contains(decimal("-2.1"))); assertFalse(dr.contains(decimal("0.1"))); assertFalse(dr.contains(decimal("12.5"))); assertFalse(dr.contains(decimal("13.1")));
@Test public void minExclusiveFacetNoI1() throws InvalidConstrainingFacetException { RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals()); dr = dr.intersect(new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null), true); dr = dr.applyConstrainingFacet(MIN_EXCLUSIVE.getName(), decimal("3.5")); assertFalse(dr.contains(BigDecimal.valueOf(Long.MIN_VALUE).subtract(BigDecimal.valueOf(0.1)))); assertFalse(dr.contains(Long.MIN_VALUE)); assertFalse(dr.contains(0)); assertFalse(dr.contains(2)); assertFalse(dr.contains(decimal("3.4999"))); assertFalse(dr.contains(decimal("3.5"))); assertTrue(dr.contains(decimal("3.5001"))); assertFalse(dr.contains(Long.MAX_VALUE)); assertTrue(dr.contains(BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.valueOf(0.1)))); }
@Test public void emptyIntersectionConCon1() throws InvalidConstrainingFacetException { RestrictedDatatype<Number> dr1 = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals()); dr1 = dr1.applyConstrainingFacet(MIN_INCLUSIVE.getName(), decimal("2.5")); dr1 = dr1.applyConstrainingFacet(MAX_INCLUSIVE.getName(), decimal("3.5")); RestrictedDatatype<Number> dr2 = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals()); dr2 = dr2.applyConstrainingFacet(MIN_INCLUSIVE.getName(), decimal("4.5")); dr2 = dr2.applyConstrainingFacet(MAX_INCLUSIVE.getName(), decimal("5.5")); final RestrictedDatatype<Number> dr = dr1.intersect(dr2, false); assertTrue(dr.isEmpty()); assertTrue(dr.isFinite()); assertTrue(dr.isEnumerable()); assertTrue(dr.containsAtLeast(0)); assertFalse(dr.containsAtLeast(1)); }
/** * Test that a continuous interval is empty if upper bound is below lower bound * * @throws InvalidConstrainingFacetException */ @Test public void emptyRangeCon1() throws InvalidConstrainingFacetException { RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals()); dr = dr.applyConstrainingFacet(MAX_INCLUSIVE.getName(), decimal("2.5")); dr = dr.applyConstrainingFacet(MIN_INCLUSIVE.getName(), decimal("3.5")); assertFalse(dr.contains(2)); assertFalse(dr.contains(decimal("2.4999"))); assertFalse(dr.contains(decimal("2.5"))); assertFalse(dr.contains(decimal("2.5001"))); assertFalse(dr.contains(3)); assertFalse(dr.contains(decimal("3.4999"))); assertFalse(dr.contains(decimal("3.5"))); assertFalse(dr.contains(decimal("3.5001"))); assertFalse(dr.contains(4)); assertTrue(dr.isEmpty()); assertTrue(dr.isFinite()); assertTrue(dr.isEnumerable()); assertTrue(dr.containsAtLeast(0)); assertFalse(dr.containsAtLeast(1)); }
@Test public void maxExclusiveFacetInt1() throws InvalidConstrainingFacetException { RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null); dr = dr.applyConstrainingFacet(MAX_EXCLUSIVE.getName(), 3); assertFalse(dr.contains(BigDecimal.valueOf(Long.MIN_VALUE).subtract(BigDecimal.valueOf(0.1)))); assertTrue(dr.contains(Long.MIN_VALUE)); assertTrue(dr.contains(0)); assertTrue(dr.contains(2)); assertFalse(dr.contains(decimal("2.9999"))); assertFalse(dr.contains(3)); assertFalse(dr.contains(decimal("3.0001"))); assertFalse(dr.contains(4)); assertFalse(dr.contains(Long.MAX_VALUE)); assertFalse(dr.contains(BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.valueOf(0.1)))); }
for (final RestrictedDatatype<?> pr : positiveRestrictions) final Datatype<?> dt = pr.getDatatype().getPrimitiveDatatype(); rd = rd.intersect(other, false); if (other.isEmpty()) continue; final Datatype<?> dt = other.getDatatype().getPrimitiveDatatype(); rd = rd.intersect(other, true); for (final Iterator<?> oi = enm.valueIterator(); oi.hasNext();) notOneOf.add(oi.next()); rd = rd.exclude(notOneOf);
/** * Test ascending integer value enumeration for two discontinuous intervals * * @throws InvalidConstrainingFacetException */ @Test public void integerEnumeration2a() throws InvalidConstrainingFacetException { RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null); dr = dr.applyConstrainingFacet(MIN_INCLUSIVE.getName(), -250); dr = dr.applyConstrainingFacet(MAX_INCLUSIVE.getName(), 350); RestrictedDatatype<Number> neg = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null); neg = neg.applyConstrainingFacet(MIN_INCLUSIVE.getName(), -5); neg = neg.applyConstrainingFacet(MAX_INCLUSIVE.getName(), -2); dr = dr.intersect(neg, true); final Iterator<Number> it = dr.valueIterator(); for (int i = -250; i <= 350; i++) { if ((i >= -5) && (i <= -2)) continue; assertEquals(0, OWLRealUtils.compare(i, it.next())); } }
/** * Same test as {@link #integerEnumeration2a()}, but with range constructed using union, not intersection * * @throws InvalidConstrainingFacetException */ @Test public void integerEnumeration2b() throws InvalidConstrainingFacetException { RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null); dr = dr.applyConstrainingFacet(MIN_INCLUSIVE.getName(), -250); dr = dr.applyConstrainingFacet(MAX_EXCLUSIVE.getName(), -5); RestrictedDatatype<Number> b = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null); b = b.applyConstrainingFacet(MIN_EXCLUSIVE.getName(), -2); b = b.applyConstrainingFacet(MAX_INCLUSIVE.getName(), 350); dr = dr.union(b); final Iterator<Number> it = dr.valueIterator(); for (int i = -250; i <= 350; i++) { if ((i >= -5) && (i <= -2)) continue; assertEquals(0, OWLRealUtils.compare(i, it.next())); } }
dr = dr.intersect(new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null), true); assertFalse(dr.contains((byte) 0)); assertFalse(dr.contains(Byte.MIN_VALUE)); assertFalse(dr.contains(Byte.MAX_VALUE)); assertFalse(dr.contains((short) 0)); assertFalse(dr.contains(Short.MIN_VALUE)); assertFalse(dr.contains(Short.MAX_VALUE)); assertFalse(dr.contains(0)); assertFalse(dr.contains(Integer.MIN_VALUE)); assertFalse(dr.contains(Integer.MAX_VALUE)); assertFalse(dr.contains(0l)); assertFalse(dr.contains(Long.MIN_VALUE)); assertFalse(dr.contains(Long.MAX_VALUE)); assertFalse(dr.contains(BigInteger.ZERO)); assertFalse(dr.contains(BigInteger.ONE)); assertFalse(dr.contains(BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.valueOf(Long.MAX_VALUE)))); assertFalse(dr.contains(BigInteger.ZERO.subtract(BigInteger.valueOf(Long.MAX_VALUE).add(BigInteger.valueOf(Long.MAX_VALUE))))); assertFalse(dr.contains(BigDecimal.ZERO)); assertFalse(dr.contains(BigDecimal.ONE)); assertFalse(dr.contains(BigDecimal.TEN)); assertFalse(dr.contains(BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.valueOf(1)))); assertFalse(dr.contains(BigDecimal.valueOf(Long.MIN_VALUE).subtract(BigDecimal.valueOf(2)))); assertFalse(dr.contains(BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.valueOf(1.1))));
/** * Test ascending integer value enumeration for a bound interval * * @throws InvalidConstrainingFacetException */ @Test public void integerEnumeration1() throws InvalidConstrainingFacetException { RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null); dr = dr.applyConstrainingFacet(MIN_INCLUSIVE.getName(), -250); dr = dr.applyConstrainingFacet(MAX_INCLUSIVE.getName(), 350); final Iterator<Number> it = dr.valueIterator(); for (int i = -250; i <= 350; i++) assertEquals(0, OWLRealUtils.compare(i, it.next())); }
@Override public boolean contains(final Object value) { if (_values.contains(value)) return true; for (final RestrictedDatatype<? extends T> rd : _ranges) if (rd.contains(value)) return true; return false; }
dr = dr.applyConstrainingFacet(facet, value);
@Override public ATermAppl getCanonicalRepresentation(final ATermAppl input) throws InvalidLiteralException { return _range.getDatatype().getCanonicalRepresentation(input); }
/** * Test that an irrelevant value can be excluded */ @Test public void excludeIrrelevant1() { final String value = "A String, not a Number"; RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals()); dr = dr.exclude(singleton(value)); assertFalse(dr.contains(value)); assertFalse(dr.isEmpty()); assertFalse(dr.isEnumerable()); assertFalse(dr.isFinite()); }
@Test public void maxExclusiveFacetNoI1() throws InvalidConstrainingFacetException { RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals()); dr = dr.intersect(new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null), true); dr = dr.applyConstrainingFacet(MAX_EXCLUSIVE.getName(), decimal("3.5")); assertTrue(dr.contains(BigDecimal.valueOf(Long.MIN_VALUE).subtract(BigDecimal.valueOf(0.1)))); assertFalse(dr.contains(Long.MIN_VALUE)); assertFalse(dr.contains(0)); assertFalse(dr.contains(2)); assertTrue(dr.contains(decimal("3.4999"))); assertFalse(dr.contains(decimal("3.5"))); assertFalse(dr.contains(decimal("3.5001"))); assertFalse(dr.contains(Long.MAX_VALUE)); assertFalse(dr.contains(BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.valueOf(0.1)))); }