intervals-0.7.1: Interval Arithmetic

Copyright | (c) Edward Kmett 2010-2014
License | BSD3
Maintainer | ekmett@gmail.com
Stability | experimental
Portability | DeriveDataTypeable
Safe Haskell | Safe
Language | Haskell98

Numeric.Interval

Description

Interval arithmetic

Synopsis

- data Interval a
- (...) :: Ord a => a -> a -> Interval a
- (+/-) :: (Num a, Ord a) => a -> a -> Interval a
- interval :: Ord a => a -> a -> Maybe (Interval a)
- whole :: Fractional a => Interval a
- empty :: Ord a => Interval a
- null :: Interval a -> Bool
- singleton :: a -> Interval a
- elem :: Ord a => a -> Interval a -> Bool
- notElem :: Ord a => a -> Interval a -> Bool
- inf :: Interval a -> a
- sup :: Interval a -> a
- singular :: Ord a => Interval a -> Bool
- width :: Num a => Interval a -> a
- midpoint :: Fractional a => Interval a -> a
- intersection :: Ord a => Interval a -> Interval a -> Interval a
- hull :: Ord a => Interval a -> Interval a -> Interval a
- bisect :: Fractional a => Interval a -> (Interval a, Interval a)
- bisectIntegral :: Integral a => Interval a -> (Interval a, Interval a)
- magnitude :: (Num a, Ord a) => Interval a -> a
- mignitude :: (Num a, Ord a) => Interval a -> a
- distance :: (Num a, Ord a) => Interval a -> Interval a -> a
- inflate :: (Num a, Ord a) => a -> Interval a -> Interval a
- deflate :: (Fractional a, Ord a) => a -> Interval a -> Interval a
- scale :: (Fractional a, Ord a) => a -> Interval a -> Interval a
- symmetric :: (Num a, Ord a) => a -> Interval a
- contains :: Ord a => Interval a -> Interval a -> Bool
- isSubsetOf :: Ord a => Interval a -> Interval a -> Bool
- certainly :: Ord a => (forall b. Ord b => b -> b -> Bool) -> Interval a -> Interval a -> Bool
- (<!) :: Ord a => Interval a -> Interval a -> Bool
- (<=!) :: Ord a => Interval a -> Interval a -> Bool
- (==!) :: Eq a => Interval a -> Interval a -> Bool
- (>=!) :: Ord a => Interval a -> Interval a -> Bool
- (>!) :: Ord a => Interval a -> Interval a -> Bool
- possibly :: Ord a => (forall b. Ord b => b -> b -> Bool) -> Interval a -> Interval a -> Bool
- (<?) :: Ord a => Interval a -> Interval a -> Bool
- (<=?) :: Ord a => Interval a -> Interval a -> Bool
- (==?) :: Ord a => Interval a -> Interval a -> Bool
- (>=?) :: Ord a => Interval a -> Interval a -> Bool
- (>?) :: Ord a => Interval a -> Interval a -> Bool
- idouble :: Interval Double -> Interval Double
- ifloat :: Interval Float -> Interval Float

# Documentation

data Interval a Source

Instances

Foldable Interval Source |
Generic1 Interval Source |
Eq a => Eq (Interval a) Source |
(RealFloat a, Ord a) => Floating (Interval a) Source |
(Fractional a, Ord a) => Fractional (Interval a) Source |
Data a => Data (Interval a) Source |
(Num a, Ord a) => Num (Interval a) Source |
Ord a => Ord (Interval a) Source |
Real a => Real (Interval a) Source | `realToFrac` will use the midpoint
RealFloat a => RealFloat (Interval a) Source | We have to play some semantic games to make these methods make sense. Most compute with the midpoint of the interval.
RealFrac a => RealFrac (Interval a) Source |
Show a => Show (Interval a) Source |
Generic (Interval a) Source |
type Rep1 Interval Source |
type Rep (Interval a) Source |

(...) :: Ord a => a -> a -> Interval a infix 3 Source

(+/-) :: (Num a, Ord a) => a -> a -> Interval a infixl 6 Source

interval :: Ord a => a -> a -> Maybe (Interval a) Source

whole :: Fractional a => Interval a Source

The whole real number line

    >>> whole
    -Infinity ... Infinity

empty :: Ord a => Interval a Source

An empty interval

    >>> empty
    Empty

null :: Interval a -> Bool Source

Check if an interval is empty

    >>> null (1 ... 5)
    False

    >>> null (1 ... 1)
    False

    >>> null empty
    True

singleton :: a -> Interval a Source

A singleton point

    >>> singleton 1
    1 ... 1

elem :: Ord a => a -> Interval a -> Bool Source

Determine if a point is in the interval.

    >>> elem 3.2 (1.0 ... 5.0)
    True

    >>> elem 5 (1.0 ... 5.0)
    True

    >>> elem 1 (1.0 ... 5.0)
    True

    >>> elem 8 (1.0 ... 5.0)
    False

    >>> elem 5 empty
    False

notElem :: Ord a => a -> Interval a -> Bool Source

Determine if a point is not included in the interval

    >>> notElem 8 (1.0 ... 5.0)
    True

    >>> notElem 1.4 (1.0 ... 5.0)
    False

And of course, nothing is a member of the empty interval.

    >>> notElem 5 empty
    True

inf :: Interval a -> a Source

The infimum (lower bound) of an interval

    >>> inf (1.0 ... 20.0)
    1.0

    >>> inf empty
    *** Exception: empty interval

sup :: Interval a -> a Source

The supremum (upper bound) of an interval

    >>> sup (1.0 ... 20.0)
    20.0

    >>> sup empty
    *** Exception: empty interval

singular :: Ord a => Interval a -> Bool Source

Is the interval a singleton point? N.B. This is fairly fragile and likely will not hold after even a few operations that only involve singletons

    >>> singular (singleton 1)
    True

    >>> singular (1.0 ... 20.0)
    False

width :: Num a => Interval a -> a Source

Calculate the width of an interval.

    >>> width (1 ... 20)
    19

    >>> width (singleton 1)
    0

    >>> width empty
    0

midpoint :: Fractional a => Interval a -> a Source

Nearest point to the midpoint of the interval.

    >>> midpoint (10.0 ... 20.0)
    15.0

    >>> midpoint (singleton 5.0)
    5.0

    >>> midpoint empty
    *** Exception: empty interval

intersection :: Ord a => Interval a -> Interval a -> Interval a Source

Calculate the intersection of two intervals.

    >>> intersection (1 ... 10 :: Interval Double) (5 ... 15 :: Interval Double)
    5.0 ... 10.0

hull :: Ord a => Interval a -> Interval a -> Interval a Source

Calculate the convex hull of two intervals

    >>> hull (0 ... 10 :: Interval Double) (5 ... 15 :: Interval Double)
    0.0 ... 15.0

    >>> hull (15 ... 85 :: Interval Double) (0 ... 10 :: Interval Double)
    0.0 ... 85.0

bisect :: Fractional a => Interval a -> (Interval a, Interval a) Source

Bisect an interval at its midpoint.

    >>> bisect (10.0 ... 20.0)
    (10.0 ... 15.0,15.0 ... 20.0)

    >>> bisect (singleton 5.0)
    (5.0 ... 5.0,5.0 ... 5.0)

    >>> bisect Empty
    (Empty,Empty)

bisectIntegral :: Integral a => Interval a -> (Interval a, Interval a) Source

magnitude :: (Num a, Ord a) => Interval a -> a Source

Magnitude

    >>> magnitude (1 ... 20)
    20

    >>> magnitude (-20 ... 10)
    20

    >>> magnitude (singleton 5)
    5

throws `EmptyInterval` if the interval is empty.

    >>> magnitude empty
    *** Exception: empty interval

mignitude :: (Num a, Ord a) => Interval a -> a Source

"mignitude"

    >>> mignitude (1 ... 20)
    1

    >>> mignitude (-20 ... 10)
    0

    >>> mignitude (singleton 5)
    5

throws `EmptyInterval` if the interval is empty.

    >>> mignitude empty
    *** Exception: empty interval

distance :: (Num a, Ord a) => Interval a -> Interval a -> a Source

Hausdorff distance between intervals.

    >>> distance (1 ... 7) (6 ... 10)
    0

    >>> distance (1 ... 7) (15 ... 24)
    8

    >>> distance (1 ... 7) (-10 ... -2)
    3

    >>> distance Empty (1 ... 1)
    *** Exception: empty interval

inflate :: (Num a, Ord a) => a -> Interval a -> Interval a Source

Inflate an interval by enlarging it at both ends.

    >>> inflate 3 (-1 ... 7)
    -4 ... 10

    >>> inflate (-2) (0 ... 4)
    -2 ... 6

    >>> inflate 1 empty
    Empty

deflate :: (Fractional a, Ord a) => a -> Interval a -> Interval a Source

Deflate an interval by shrinking it from both ends.

    >>> deflate 3.0 (-4.0 ... 10.0)
    -1.0 ... 7.0

    >>> deflate 2.0 (-1.0 ... 1.0)
    Empty

    >>> deflate 1.0 empty
    Empty

scale :: (Fractional a, Ord a) => a -> Interval a -> Interval a Source

Scale an interval about its midpoint.

    >>> scale 1.1 (-6.0 ... 4.0)
    -6.5 ... 4.5

    >>> scale (-2.0) (-1.0 ... 1.0)
    Empty

    >>> scale 3.0 empty
    Empty

symmetric :: (Num a, Ord a) => a -> Interval a Source

Construct a symmetric interval.

    >>> symmetric 3
    -3 ... 3

    >>> symmetric (-2)
    -2 ... 2

contains :: Ord a => Interval a -> Interval a -> Bool Source

Check if interval `X` totally contains interval `Y`

    >>> (20 ... 40 :: Interval Double) `contains` (25 ... 35 :: Interval Double)
    True

    >>> (20 ... 40 :: Interval Double) `contains` (15 ... 35 :: Interval Double)
    False

isSubsetOf :: Ord a => Interval a -> Interval a -> Bool Source

Flipped version of `contains`. Check if interval `X` a subset of interval `Y`

    >>> (25 ... 35 :: Interval Double) `isSubsetOf` (20 ... 40 :: Interval Double)
    True

    >>> (20 ... 40 :: Interval Double) `isSubsetOf` (15 ... 35 :: Interval Double)
    False

certainly :: Ord a => (forall b. Ord b => b -> b -> Bool) -> Interval a -> Interval a -> Bool Source

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

(<!) :: Ord a => Interval a -> Interval a -> Bool Source

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

    >>> (5 ... 10 :: Interval Double) <! (20 ... 30 :: Interval Double)
    True

    >>> (5 ... 10 :: Interval Double) <! (10 ... 30 :: Interval Double)
    False

    >>> (20 ... 30 :: Interval Double) <! (5 ... 10 :: Interval Double)
    False

(<=!) :: Ord a => Interval a -> Interval a -> Bool Source

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

    >>> (5 ... 10 :: Interval Double) <=! (20 ... 30 :: Interval Double)
    True

    >>> (5 ... 10 :: Interval Double) <=! (10 ... 30 :: Interval Double)
    True

    >>> (20 ... 30 :: Interval Double) <=! (5 ... 10 :: Interval Double)
    False

(==!) :: Eq a => Interval a -> Interval a -> Bool Source

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

Only singleton intervals or empty intervals can return true

    >>> (singleton 5 :: Interval Double) ==! (singleton 5 :: Interval Double)
    True

    >>> (5 ... 10 :: Interval Double) ==! (5 ... 10 :: Interval Double)
    False

(>=!) :: Ord a => Interval a -> Interval a -> Bool Source

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

    >>> (20 ... 40 :: Interval Double) >=! (10 ... 20 :: Interval Double)
    True

    >>> (5 ... 20 :: Interval Double) >=! (15 ... 40 :: Interval Double)
    False

(>!) :: Ord a => Interval a -> Interval a -> Bool Source

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

    >>> (20 ... 40 :: Interval Double) >! (10 ... 19 :: Interval Double)
    True

    >>> (5 ... 20 :: Interval Double) >! (15 ... 40 :: Interval Double)
    False

possibly :: Ord a => (forall b. Ord b => b -> b -> Bool) -> Interval a -> Interval a -> Bool Source

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

(<?) :: Ord a => Interval a -> Interval a -> Bool Source

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

(<=?) :: Ord a => Interval a -> Interval a -> Bool Source

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

(==?) :: Ord a => Interval a -> Interval a -> Bool Source

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

(>=?) :: Ord a => Interval a -> Interval a -> Bool Source

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

(>?) :: Ord a => Interval a -> Interval a -> Bool Source

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

idouble :: Interval Double -> Interval Double Source

id function. Useful for type specification

    >>> :t idouble (1 ... 3)
    idouble (1 ... 3) :: Interval Double

ifloat :: Interval Float -> Interval Float Source

id function. Useful for type specification

    >>> :t ifloat (1 ... 3)
    ifloat (1 ... 3) :: Interval Float