ComparableInterval (patrius 4.3 API)

java.lang.Object
- fr.cnes.sirius.patrius.math.interval.GenericInterval<T>
- - fr.cnes.sirius.patrius.math.interval.ComparableInterval<T>

Type Parameters:

T - the nature of ending points

All Implemented Interfaces:

Serializable, Comparable<ComparableInterval<T>>

Direct Known Subclasses:

AbsoluteDateInterval
```
public class ComparableInterval<T extends Comparable<T>>
extends GenericInterval<T>
implements Comparable<ComparableInterval<T>>
```
Class describing an interval of Comparable data.
This class is copy of ComparableInterval. It adds the methods mergeTo(ComparableInterval), getIntersectionWith(ComparableInterval) and extendTo(Comparable), as well as an additional constructor.

The upper and lower boundaries have to be Comparable, so that the correct order can be checked. This class can be extended and GenericInterval.toString() may be overridden.

The generic class must implement java.lang.Comparable
It is HIGHLY recommended this class be immutable!

Since:

3.0

Version:

$Id: ComparableInterval.java 18083 2017-10-02 16:54:39Z bignon $

Author:

Pierre Cardoso

See Also:

Serialized Form

Use sample :

For instance, an interval of Doubles ]1.0,2.0[ is created this way :
Interval interval = new Interval(IntervalEndpointType.OPEN, 1.0, 2.0, IntervalEndpointType.OPEN);

Concurrency :

matches the concurrency of the parameter type : using an immutable type is HIGHLY recommended

Constructor Summary

Constructors
Constructor and Description
`ComparableInterval(IntervalEndpointType lowerEndpointIn, T lowerDataIn, T upperDataIn, IntervalEndpointType upperEndpointIn)` Constructor.
`ComparableInterval(T lowerData, T upperData)` Builds a new `ComparableInterval` with closed endpoints.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`compareLowerEndTo(ComparableInterval<T> interval)` Compares the lower end point with the lower end point of the given interval.
`int`	`compareTo(ComparableInterval<T> interval)` Compares this interval with the specified interval.
`int`	`compareUpperEndTo(ComparableInterval<T> interval)` Compares the upper end point with the upper end point of the given interval.
`boolean`	`contains(Comparable<T> cmp)` Returns true if the provided value belongs to the interval.
`boolean`	`equals(Object interval)` Checks if the instance represents the same `ComparableInterval` as another instance.
`ComparableInterval<T>`	`extendTo(T value)` Returns the interval after extending it so that it includes (closed endpoint) or is connected (open endpoint) to the specified value.
`ComparableInterval<T>`	`getIntersectionWith(ComparableInterval<T> interval)` Returns the intersection with another interval.
`int`	`hashCode()`
`boolean`	`includes(ComparableInterval<T> interval)` Returns true if this interval includes the other.
`boolean`	`isConnectedTo(ComparableInterval<T> interval)` Returns true when this interval's lower end-point connects with another interval's upper end-point.
`ComparableInterval<T>`	`mergeTo(ComparableInterval<T> interval)` Returns this interval merged with another interval (if they can be merged).
`boolean`	`overlaps(ComparableInterval<T> interval)` Returns true if the two intervals overlap.

Methods inherited from class fr.cnes.sirius.patrius.math.interval.GenericInterval
getLowerData, getLowerEndpoint, getUpperData, getUpperEndpoint, toString

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - ComparableInterval
```
public ComparableInterval(T lowerData,
                          T upperData)
```
    Builds a new ComparableInterval with closed endpoints.
    The input parameters must not be null. The lower and upper endpoints must also be properly ordered. Otherwise a MathIllegalArgumentException is thrown.
    
    Parameters:
    
    lowerData - the lower end data value
    
    upperData - the upper end data value
    
    Throws:
    
    MathIllegalArgumentException - when the interval is invalid (unchecked exception)
    
    Since:
    
    4.2
  - ComparableInterval
```
public ComparableInterval(IntervalEndpointType lowerEndpointIn,
                          T lowerDataIn,
                          T upperDataIn,
                          IntervalEndpointType upperEndpointIn)
```
    Constructor.
    The input parameters have to be not null.
    The lower and upper endpoints also have to be properly ordered.
    Otherwise a MathIllegalArgumentException is thrown.
    
    Parameters:
    
    lowerDataIn - lower end data value
    
    upperDataIn - upper end data value
    
    lowerEndpointIn - lower end point state
    
    upperEndpointIn - upper end point state
    
    Throws:
    
    MathIllegalArgumentException - when the interval is invalid (unchecked exception)
    
    Since:
    
    1.0
- Method Detail
  - contains
```
public final boolean contains(Comparable<T> cmp)
```
    Returns true if the provided value belongs to the interval.
    
    Parameters:
    
    cmp - the tested value
    
    Returns:
    
    true if the value belongs to the interval
  - overlaps
```
public final boolean overlaps(ComparableInterval<T> interval)
```
    Returns true if the two intervals overlap.
    The intervals [l1 ; u1] and [l2 ; u2] overlap if u1>=l2 AND l1<=u2. If one of the end-points is open, the comparison is strict.
    
    Parameters:
    
    interval - the other interval
    
    Returns:
    
    true if the two intervals overlap
  - includes
```
public final boolean includes(ComparableInterval<T> interval)
```
    Returns true if this interval includes the other.
    The interval [l1; u1] includes the interval [l2; u2] if l1<=l2 and u1>=u2. If the end-point of the including interval is open and the end-point of the included interval is closed, the comparison is strict.
    
    Parameters:
    
    interval - the interval tested for inclusion
    
    Returns:
    
    true if the provided interval is included
  - isConnectedTo
```
public final boolean isConnectedTo(ComparableInterval<T> interval)
```
    Returns true when this interval's lower end-point connects with another interval's upper end-point.
    Two end-points connects if their values are identical and their end-points have different types (one is open and the other is closed).
    
    Parameters:
    
    interval - the interval tested for connection
    
    Returns:
    
    true if the provided interval is connected by its upper point
  - mergeTo
```
public ComparableInterval<T> mergeTo(ComparableInterval<T> interval)
```
    Returns this interval merged with another interval (if they can be merged).
    To be merged, the two intervals must overlap or be connected. If that is not the case, the method returns null.
    
    Parameters:
    
    interval - the other interval
    
    Returns:
    
    the merged interval or null if the intervals do not overlap and are not connected
  - getIntersectionWith
```
public ComparableInterval<T> getIntersectionWith(ComparableInterval<T> interval)
```
    Returns the intersection with another interval.
    If the intervals do not overlap, the method returns null.
    
    Parameters:
    
    interval - the other interval
    
    Returns:
    
    the intersection between the two intervals or null if the intervals do not overlap
  - extendTo
```
public ComparableInterval<T> extendTo(T value)
```
    Returns the interval after extending it so that it includes (closed endpoint) or is connected (open endpoint) to the specified value.
    
    Parameters:
    
    value - the target value
    
    Returns:
    
    the extended interval
  - compareLowerEndTo
```
public final int compareLowerEndTo(ComparableInterval<T> interval)
```
    Compares the lower end point with the lower end point of the given interval.
    It returns a negative integer if the lower end point is inferior than the lower end point of the given interval, zero if they are equal, or a positive integer if is it superior. The method also compares the lower end point type of the two intervals.
    
    Parameters:
    
    interval - the interval tested for lower end point comparison
    
    Returns:
    
    a negative integer, zero, or a positive integer
  - compareUpperEndTo
```
public final int compareUpperEndTo(ComparableInterval<T> interval)
```
    Compares the upper end point with the upper end point of the given interval.
    It returns a negative integer if the upper end point is inferior than the upper end point of the given interval, zero if they are equal, or a positive integer if is it superior. The method also compares the upper end point type of the two intervals.
    
    Parameters:
    
    interval - the interval tested for upper end point comparison
    
    Returns:
    
    a negative integer, zero, or a positive integer
  - compareTo
```
public int compareTo(ComparableInterval<T> interval)
```
    Compares this interval with the specified interval. It returns a negative integer, zero, or a positive integer.
    - it checks the lower data and returns a negative (positive) integer if its lower data is inferior (superior) than the lower data of the input interval;
    - if the lower data are identical, it checks the lower end points and it returns a negative integer if its lower end point is closed while the lower end point of the input interval is open (and vice-versa);
    - if the lower data and end points are identical, it checks the upper data and it returns a negative (positive) integer if its upper data is inferior (superior) than the upper data of the input interval;
    - if the upper data are identical, it checks the upper end points and it returns a negative integer if its upper end point is open while the upper end point of the input interval is closed (and vice-versa);
    - if both upper/lower data and end points are identical, it returns zero.
    Specified by:
    
    compareTo in interface Comparable<ComparableInterval<T extends Comparable<T>>>
    
    Parameters:
    
    interval - the time interval to be compared.
    
    Returns:
    
    a negative integer, zero, or a positive integer
    
    Throws:
    
    ClassCastException - if the specified object's type prevents it from being compared to this object.
  - equals
```
public boolean equals(Object interval)
```
    Checks if the instance represents the same ComparableInterval as another instance.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    interval - other interval
    
    Returns:
    
    true if the instance and the other are equals
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object

Class ComparableInterval<T extends Comparable<T>>

Constructor Summary

Method Summary

Methods inherited from class fr.cnes.sirius.patrius.math.interval.GenericInterval

Methods inherited from class java.lang.Object

Constructor Detail

ComparableInterval

ComparableInterval

Method Detail

contains

overlaps

includes

isConnectedTo

mergeTo

getIntersectionWith

extendTo

compareLowerEndTo

compareUpperEndTo

compareTo

equals

hashCode