data-interval-0.6.0: Interval arithmetic for both open and closed intervals

Portability non-portable (ScopedTypeVariables, DeriveDataTypeable) provisional masahiro.sakai@gmail.com Safe-Inferred

Data.Interval

Description

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).

Synopsis

# Interval type

data Interval r Source

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 Source

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

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 rSource

whole real number line (-∞, ∞)

empty :: Num r => Interval rSource

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

singleton set [x,x]

# Query

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

Is the interval empty?

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

Is the element in the interval?

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

Is the element not in the interval?

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

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

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

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

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

Lower bound of the interval

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

Upper bound of the interval

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

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)Source

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 -> rSource

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

# Comparison

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 rSource

intersection of two intervals

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

intersection of a list of intervals.

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

convex hull of two intervals

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

convex hull of a list of intervals.

# Operations

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

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

`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`)