intervals-0.8.1: Interval Arithmetic

Copyright(c) Edward Kmett 2010-2013
LicenseBSD3
Maintainerekmett@gmail.com
Stabilityexperimental
PortabilityDeriveDataTypeable
Safe HaskellSafe
LanguageHaskell98

Numeric.Interval.Internal

Description

Interval arithmetic

Synopsis

Documentation

data Interval a Source #

Constructors

I !a !a 
Empty 

Instances

Foldable Interval Source # 

Methods

fold :: Monoid m => Interval m -> m #

foldMap :: Monoid m => (a -> m) -> Interval a -> m #

foldr :: (a -> b -> b) -> b -> Interval a -> b #

foldr' :: (a -> b -> b) -> b -> Interval a -> b #

foldl :: (b -> a -> b) -> b -> Interval a -> b #

foldl' :: (b -> a -> b) -> b -> Interval a -> b #

foldr1 :: (a -> a -> a) -> Interval a -> a #

foldl1 :: (a -> a -> a) -> Interval a -> a #

toList :: Interval a -> [a] #

null :: Interval a -> Bool #

length :: Interval a -> Int #

elem :: Eq a => a -> Interval a -> Bool #

maximum :: Ord a => Interval a -> a #

minimum :: Ord a => Interval a -> a #

sum :: Num a => Interval a -> a #

product :: Num a => Interval a -> a #

Generic1 Interval Source # 

Associated Types

type Rep1 (Interval :: * -> *) :: * -> * #

Methods

from1 :: Interval a -> Rep1 Interval a #

to1 :: Rep1 Interval a -> Interval a #

Eq a => Eq (Interval a) Source # 

Methods

(==) :: Interval a -> Interval a -> Bool #

(/=) :: Interval a -> Interval a -> Bool #

(RealFloat a, Ord a) => Floating (Interval a) Source # 
(Fractional a, Ord a) => Fractional (Interval a) Source # 
Data a => Data (Interval a) Source # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Interval a -> c (Interval a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Interval a) #

toConstr :: Interval a -> Constr #

dataTypeOf :: Interval a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Interval a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Interval a)) #

gmapT :: (forall b. Data b => b -> b) -> Interval a -> Interval a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Interval a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Interval a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Interval a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Interval a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Interval a -> m (Interval a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval a -> m (Interval a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Interval a -> m (Interval a) #

(Num a, Ord a) => Num (Interval a) Source # 
Ord a => Ord (Interval a) Source # 

Methods

compare :: Interval a -> Interval a -> Ordering #

(<) :: Interval a -> Interval a -> Bool #

(<=) :: Interval a -> Interval a -> Bool #

(>) :: Interval a -> Interval a -> Bool #

(>=) :: Interval a -> Interval a -> Bool #

max :: Interval a -> Interval a -> Interval a #

min :: Interval a -> Interval a -> Interval a #

Real a => Real (Interval a) Source #

realToFrac will use the midpoint

Methods

toRational :: Interval a -> Rational #

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 # 

Methods

properFraction :: Integral b => Interval a -> (b, Interval a) #

truncate :: Integral b => Interval a -> b #

round :: Integral b => Interval a -> b #

ceiling :: Integral b => Interval a -> b #

floor :: Integral b => Interval a -> b #

Show a => Show (Interval a) Source # 

Methods

showsPrec :: Int -> Interval a -> ShowS #

show :: Interval a -> String #

showList :: [Interval a] -> ShowS #

Generic (Interval a) Source # 

Associated Types

type Rep (Interval a) :: * -> * #

Methods

from :: Interval a -> Rep (Interval a) x #

to :: Rep (Interval a) x -> Interval a #

type Rep1 Interval Source # 
type Rep1 Interval = D1 (MetaData "Interval" "Numeric.Interval.Internal" "intervals-0.8.1-GzVvQrzuz8X8ZCkgHM3GNi" False) ((:+:) (C1 (MetaCons "I" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1))) (C1 (MetaCons "Empty" PrefixI False) U1))
type Rep (Interval a) Source # 
type Rep (Interval a) = D1 (MetaData "Interval" "Numeric.Interval.Internal" "intervals-0.8.1-GzVvQrzuz8X8ZCkgHM3GNi" False) ((:+:) (C1 (MetaCons "I" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)))) (C1 (MetaCons "Empty" PrefixI False) U1))

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

member :: Ord a => a -> Interval a -> Bool Source #

Determine if a point is in the interval.

>>> member 3.2 (1.0 ... 5.0)
True
>>> member 5 (1.0 ... 5.0)
True
>>> member 1 (1.0 ... 5.0)
True
>>> member 8 (1.0 ... 5.0)
False
>>> member 5 empty
False

notMember :: Ord a => a -> Interval a -> Bool Source #

Determine if a point is not included in the interval

>>> notMember 8 (1.0 ... 5.0)
True
>>> notMember 1.4 (1.0 ... 5.0)
False

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

>>> notMember 5 empty
True

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

Deprecated: Use member instead.

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 #

Deprecated: Use notMember instead.

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)

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 :: (Num 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

iquot :: Integral a => Interval a -> Interval a -> Interval a Source #

an interval containing all x quot y >>> (5 quot 3) member ((4...6) iquot (2...4)) True >>> (1...10) iquot ((-5)...4) *** Exception: divide by zero

irem :: Integral a => Interval a -> Interval a -> Interval a Source #

an interval containing all x rem y >>> (5 rem 3) member ((4...6) irem (2...4)) True >>> (1...10) irem ((-5)...4) *** Exception: divide by zero

idiv :: Integral a => Interval a -> Interval a -> Interval a Source #

an interval containing all x div y >>> (5 div 3) member ((4...6) idiv (2...4)) True >>> (1...10) idiv ((-5)...4) *** Exception: divide by zero

imod :: Integral a => Interval a -> Interval a -> Interval a Source #

an interval containing all x mod y >>> (5 mod 3) member ((4...6) imod (2...4)) True >>> (1...10) imod ((-5)...4) *** Exception: divide by zero