Codota Logo
IntegerInterval.allIntegers
Code IndexAdd Codota to your IDE (free)

How to use
allIntegers
method
in
openllet.core.datatypes.types.real.IntegerInterval

Best Java code snippets using openllet.core.datatypes.types.real.IntegerInterval.allIntegers (Showing top 20 results out of 315)

  • Add the Codota plugin to your IDE and get smart completions
private void myMethod () {
DateTime d =
  • Codota Iconnew DateTime()
  • Codota IconDateTimeFormatter formatter;String text;formatter.parseDateTime(text)
  • Codota IconObject instant;new DateTime(instant)
  • Smart code suggestions by Codota
}
origin: Galigator/openllet

/**
 * Private constructor forces use of {@link #getInstance()}
 */
private XSDDecimal()
{
  super(ATermUtils.makeTermAppl(Namespaces.XSD + "decimal"));
  dataRange = new RestrictedRealDatatype(this, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), null);
}
origin: Galigator/openllet

/**
 * Private constructor forces use of {@link #getInstance()}
 */
private XSDDecimal()
{
  super(ATermUtils.makeTermAppl(Namespaces.XSD + "decimal"));
  dataRange = new RestrictedRealDatatype(this, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), null);
}
origin: Galigator/openllet

private OWLRational()
{
  super(ATermUtils.makeTermAppl(Namespaces.OWL + "rational"));
  _dataRange = new RestrictedRealDatatype(this, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
}
origin: Galigator/openllet

private OWLReal()
{
  super(ATermUtils.makeTermAppl(Namespaces.OWL + "real"));
  dataRange = new RestrictedRealDatatype(this, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
}
origin: Galigator/openllet

private OWLReal()
{
  super(ATermUtils.makeTermAppl(Namespaces.OWL + "real"));
  dataRange = new RestrictedRealDatatype(this, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
}
origin: Galigator/openllet

private OWLRational()
{
  super(ATermUtils.makeTermAppl(Namespaces.OWL + "rational"));
  _dataRange = new RestrictedRealDatatype(this, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
}
origin: Galigator/openllet

/**
 * 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()));
}
origin: Galigator/openllet

@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))));
}
origin: Galigator/openllet

@Test
public void maxInclusiveFacetCon1() throws InvalidConstrainingFacetException
{
  RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
  dr = dr.applyConstrainingFacet(MAX_INCLUSIVE.getName(), decimal("3.5"));
  assertTrue(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(decimal("3.4999")));
  assertTrue(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))));
}
origin: Galigator/openllet

@Test
public void maxExclusiveFacetCon1() throws InvalidConstrainingFacetException
{
  RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
  dr = dr.applyConstrainingFacet(MAX_EXCLUSIVE.getName(), decimal("3.5"));
  assertTrue(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(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))));
}
origin: Galigator/openllet

@Test
public void minInclusiveFacetCon1() throws InvalidConstrainingFacetException
{
  RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
  dr = dr.applyConstrainingFacet(MIN_INCLUSIVE.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(decimal("3.4999")));
  assertTrue(dr.contains(decimal("3.5")));
  assertTrue(dr.contains(decimal("3.5001")));
  assertTrue(dr.contains(Long.MAX_VALUE));
  assertTrue(dr.contains(BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.valueOf(0.1))));
}
origin: Galigator/openllet

@Test
public void minExclusiveFacetCon1() throws InvalidConstrainingFacetException
{
  RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
  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(decimal("3.4999")));
  assertFalse(dr.contains(decimal("3.5")));
  assertTrue(dr.contains(decimal("3.5001")));
  assertTrue(dr.contains(Long.MAX_VALUE));
  assertTrue(dr.contains(BigDecimal.valueOf(Long.MAX_VALUE).add(BigDecimal.valueOf(0.1))));
}
origin: Galigator/openllet

@Test
public void maxInclusiveFacetInt1() throws InvalidConstrainingFacetException
{
  RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), null, null);
  dr = dr.applyConstrainingFacet(MAX_INCLUSIVE.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")));
  assertTrue(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))));
}
origin: Galigator/openllet

@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))));
}
origin: Galigator/openllet

/**
 * 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());
}
origin: Galigator/openllet

/**
 * Test that intersecting a full number line with the negation of one that only permits decimals, leaves only rationals
 */
@Test
public void intersectToRationalOnly()
{
  RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
  assertTrue(dr.contains(0));
  assertTrue(dr.contains(decimal("0.33")));
  assertTrue(dr.contains(rational(1, 3)));
  dr = dr.intersect(new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), null), true);
  assertFalse(dr.contains(0));
  assertFalse(dr.contains(decimal("0.33")));
  assertTrue(dr.contains(rational(1, 3)));
}
origin: Galigator/openllet

/**
 * 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());
}
origin: Galigator/openllet

@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));
}
origin: Galigator/openllet

/**
 * Test that an integer is correctly excluded from an infinite continuous interval
 */
@Test
public void excludeConInt1()
{
  RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
  dr = dr.exclude(singleton(1));
  assertFalse(dr.contains(1));
  assertTrue(dr.contains(0));
  assertTrue(dr.contains(2));
  assertTrue(dr.contains(decimal("0.99999")));
  assertTrue(dr.contains(decimal("1.00001")));
  assertFalse(dr.isEmpty());
  assertFalse(dr.isEnumerable());
  assertFalse(dr.isFinite());
}
origin: Galigator/openllet

@Test
public void minMaxIncIncCon1() throws InvalidConstrainingFacetException
{
  RestrictedDatatype<Number> dr = new RestrictedRealDatatype(dt, IntegerInterval.allIntegers(), ContinuousRealInterval.allReals(), ContinuousRealInterval.allReals());
  dr = dr.applyConstrainingFacet(MIN_INCLUSIVE.getName(), decimal("2.5"));
  dr = dr.applyConstrainingFacet(MAX_INCLUSIVE.getName(), decimal("3.5"));
  assertFalse(dr.contains(2));
  assertFalse(dr.contains(decimal("2.4999")));
  assertTrue(dr.contains(decimal("2.5")));
  assertTrue(dr.contains(decimal("2.5001")));
  assertTrue(dr.contains(3));
  assertTrue(dr.contains(decimal("3.4999")));
  assertTrue(dr.contains(decimal("3.5")));
  assertFalse(dr.contains(decimal("3.5001")));
  assertFalse(dr.contains(4));
}
openllet.core.datatypes.types.realIntegerIntervalallIntegers

Popular methods of IntegerInterval

  • <init>
  • contains
  • greater
  • intersection
  • less
  • canUnionWith
  • equals
  • getLower
  • getUpper
  • isFinite
  • remove
  • size
  • remove,
  • size,
  • union,
  • valueIterator

Popular in Java

  • Updating database using SQL prepared statement
  • scheduleAtFixedRate (Timer)
  • getSharedPreferences (Context)
  • runOnUiThread (Activity)
  • Graphics2D (java.awt)
    This Graphics2D class extends the Graphics class to provide more sophisticated control overgraphics
  • BigInteger (java.math)
    Immutable arbitrary-precision integers. All operations behave as if BigIntegers were represented in
  • UnknownHostException (java.net)
    Thrown when a hostname can not be resolved.
  • LinkedHashMap (java.util)
    Hash table and linked list implementation of the Map interface, with predictable iteration order. Th
  • TreeSet (java.util)
    A NavigableSet implementation based on a TreeMap. The elements are ordered using their Comparable, o
  • ConcurrentHashMap (java.util.concurrent)
    A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updat
Codota Logo
  • Products

    Search for Java codeSearch for JavaScript codeEnterprise
  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogCodota Academy Plugin user guide Terms of usePrivacy policyJava Code IndexJavascript Code Index
Get Codota for your IDE now