Data.Interval

Interval datatype and interval arithmetic.

Unlike the intervals package (http://hackage.haskell.org/package/intervals), this module provides both open and closed intervals and is intended to be used with Rational.

For the purpose of abstract interpretation, it might be convenient to use Lattice instance. See also lattices package (http://hackage.haskell.org/package/lattices).

Interval type

data Interval r

Interval

Instances

Typeable1 Interval

Eq r => Eq (Interval r)

(Real r, Fractional r) => Fractional (Interval r)

(Num r, Ord r, Data r) => Data (Interval r)

(Num r, Ord r) => Num (Interval r)

(Num r, Ord r, Read r) => Read (Interval r)

(Num r, Ord r, Show r) => Show (Interval r)

NFData r => NFData (Interval r)

Hashable r => Hashable (Interval r)

(Num r, Ord r) => JoinSemiLattice (Interval r)

(Num r, Ord r) => MeetSemiLattice (Interval r)

(Num r, Ord r) => Lattice (Interval r)

(Num r, Ord r) => BoundedJoinSemiLattice (Interval r)

(Num r, Ord r) => BoundedMeetSemiLattice (Interval r)

(Num r, Ord r) => BoundedLattice (Interval r)

data EndPoint r

Endpoints of intervals

Constructors

NegInf

negative infinity (-∞)

Finite !r

finite value

PosInf

positive infinity (+∞)

Instances

Functor EndPoint

Typeable1 EndPoint

Bounded (EndPoint r)

Eq r => Eq (EndPoint r)

Data r => Data (EndPoint r)

Ord r => Ord (EndPoint r)

Read r => Read (EndPoint r)

Show r => Show (EndPoint r)

NFData r => NFData (EndPoint r)

Hashable r => Hashable (EndPoint r)

Construction

interval

Arguments

:: (Ord r, Num r)

=> (EndPoint r, Bool)

lower bound and whether it is included

-> (EndPoint r, Bool)

upper bound and whether it is included

-> Interval r

smart constructor for Interval

(<=..<=)

Arguments

:: (Ord r, Num r)

=> EndPoint r

lower bound l

-> EndPoint r

upper bound u

-> Interval r

closed interval [l,u]

(<..<=)

Arguments

:: (Ord r, Num r)

=> EndPoint r

lower bound l

-> EndPoint r

upper bound u

-> Interval r

left-open right-closed interval (l,u]

(<=..<)

Arguments

:: (Ord r, Num r)

=> EndPoint r

lower bound l

-> EndPoint r

upper bound u

-> Interval r

left-closed right-open interval [l, u)

(<..<)

Arguments

:: (Ord r, Num r)

=> EndPoint r

lower bound l

-> EndPoint r

upper bound u

-> Interval r

open interval (l, u)

whole :: (Num r, Ord r) => Interval r

whole real number line (-∞, ∞)

empty :: Num r => Interval r

empty (contradicting) interval

singleton :: (Num r, Ord r) => r -> Interval r

singleton set [x,x]

Query

null :: Ord r => Interval r -> Bool

Is the interval empty?

member :: Ord r => r -> Interval r -> Bool

Is the element in the interval?

notMember :: Ord r => r -> Interval r -> Bool

Is the element not in the interval?

isSubsetOf :: Ord r => Interval r -> Interval r -> Bool

Is this a subset? (i1 isSubsetOf i2) tells whether i1 is a subset of i2.

isProperSubsetOf :: Ord r => Interval r -> Interval r -> Bool

Is this a proper subset? (ie. a subset but not equal).

lowerBound :: Num r => Interval r -> EndPoint r

Lower bound of the interval

upperBound :: Num r => Interval r -> EndPoint r

Upper bound of the interval

lowerBound' :: Num r => Interval r -> (EndPoint r, Bool)

Lower bound of the interval and whether it is included in the interval. The result is convenient to use as an argument for interval.

upperBound' :: Num r => Interval r -> (EndPoint r, Bool)

Upper bound of the interval and whether it is included in the interval. The result is convenient to use as an argument for interval.

width :: (Num r, Ord r) => Interval r -> r

Width of a interval. Width of an unbounded interval is undefined.

Comparison

(<!) :: Real r => Interval r -> Interval r -> Bool

For all x in X, y in Y. x < y

(<=!) :: Real r => Interval r -> Interval r -> Bool

For all x in X, y in Y. x <= y

(==!) :: Real r => Interval r -> Interval r -> Bool

For all x in X, y in Y. x == y

(>=!) :: Real r => Interval r -> Interval r -> Bool

For all x in X, y in Y. x >= y

(>!) :: Real r => Interval r -> Interval r -> Bool

For all x in X, y in Y. x > y

(<?) :: Real r => Interval r -> Interval r -> Bool

Does there exist an x in X, y in Y such that x < y?

(<=?) :: Real r => Interval r -> Interval r -> Bool

Does there exist an x in X, y in Y such that x <= y?

(==?) :: Real r => Interval r -> Interval r -> Bool

Does there exist an x in X, y in Y such that x == y?

(>=?) :: Real r => Interval r -> Interval r -> Bool

Does there exist an x in X, y in Y such that x >= y?

(>?) :: Real r => Interval r -> Interval r -> Bool

Does there exist an x in X, y in Y such that x > y?

Combine

intersection :: forall r. (Ord r, Num r) => Interval r -> Interval r -> Interval r

intersection of two intervals

intersections :: (Ord r, Num r) => [Interval r] -> Interval r

intersection of a list of intervals.

hull :: forall r. (Ord r, Num r) => Interval r -> Interval r -> Interval r

convex hull of two intervals

hulls :: (Ord r, Num r) => [Interval r] -> Interval r

convex hull of a list of intervals.

Operations

pickup :: (Real r, Fractional r) => Interval r -> Maybe r

pick up an element from the interval if the interval is not empty.

simplestRationalWithin :: RealFrac r => Interval r -> Maybe Rational

simplestRationalWithin returns the simplest rational number within the interval. A rational number y is said to be simpler than another y' if

• abs (numerator y) <= abs (numerator y'), and
• denominator y <= denominator y'.

(see also approxRational)