Numeric.Interval.NonEmpty

Interval arithmetic

Documentation

data Interval a

Instances

Foldable Interval

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

Associated Types

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

Methods

from1 :: Interval a -> Rep1 Interval a

to1 :: Rep1 Interval a -> Interval a

Eq a => Eq (Interval a)

Methods

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

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

(RealFloat a, Ord a) => Floating (Interval a)

Transcendental functions for intervals.

conservative (exp :: Double -> Double) exp

conservativeExceptNaN (log :: Double -> Double) log

conservative (sin :: Double -> Double) sin

conservative (cos :: Double -> Double) cos

conservative (tan :: Double -> Double) tan

conservativeExceptNaN (asin :: Double -> Double) asin

conservativeExceptNaN (acos :: Double -> Double) acos

conservative (atan :: Double -> Double) atan

conservative (sinh :: Double -> Double) sinh

conservative (cosh :: Double -> Double) cosh

conservative (tanh :: Double -> Double) tanh

conservativeExceptNaN (asinh :: Double -> Double) asinh

conservativeExceptNaN (acosh :: Double -> Double) acosh

conservativeExceptNaN (atanh :: Double -> Double) atanh

>>> cos (0 ... (pi + 0.1))
-1.0 ... 1.0

Methods

pi :: Interval a

exp :: Interval a -> Interval a

log :: Interval a -> Interval a

sqrt :: Interval a -> Interval a

(**) :: Interval a -> Interval a -> Interval a

logBase :: Interval a -> Interval a -> Interval a

sin :: Interval a -> Interval a

cos :: Interval a -> Interval a

tan :: Interval a -> Interval a

asin :: Interval a -> Interval a

acos :: Interval a -> Interval a

atan :: Interval a -> Interval a

sinh :: Interval a -> Interval a

cosh :: Interval a -> Interval a

tanh :: Interval a -> Interval a

asinh :: Interval a -> Interval a

acosh :: Interval a -> Interval a

atanh :: Interval a -> Interval a

log1p :: Interval a -> Interval a

expm1 :: Interval a -> Interval a

log1pexp :: Interval a -> Interval a

log1mexp :: Interval a -> Interval a

(Fractional a, Ord a) => Fractional (Interval a)

Fractional instance for intervals.

ys /= singleton 0 ==> conservative2 ((/) :: Double -> Double -> Double) (/) xs ys

xs /= singleton 0 ==> conservative (recip :: Double -> Double) recip xs

Methods

(/) :: Interval a -> Interval a -> Interval a

recip :: Interval a -> Interval a

fromRational :: Rational -> Interval a

Data a => Data (Interval a)

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)

Num instance for intervals.

conservative2 ((+) :: Double -> Double -> Double) (+)

conservative2 ((-) :: Double -> Double -> Double) (-)

conservative2 ((*) :: Double -> Double -> Double) (*)

conservative (abs :: Double -> Double) abs

Methods

(+) :: Interval a -> Interval a -> Interval a

(-) :: Interval a -> Interval a -> Interval a

(*) :: Interval a -> Interval a -> Interval a

negate :: Interval a -> Interval a

abs :: Interval a -> Interval a

signum :: Interval a -> Interval a

fromInteger :: Integer -> Interval a

Ord a => Ord (Interval a)

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)

realToFrac will use the midpoint

Methods

toRational :: Interval a -> Rational

RealFloat a => RealFloat (Interval a)

We have to play some semantic games to make these methods make sense. Most compute with the midpoint of the interval.

Methods

floatRadix :: Interval a -> Integer

floatDigits :: Interval a -> Int

floatRange :: Interval a -> (Int, Int)

decodeFloat :: Interval a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Interval a

exponent :: Interval a -> Int

significand :: Interval a -> Interval a

scaleFloat :: Int -> Interval a -> Interval a

isNaN :: Interval a -> Bool

isInfinite :: Interval a -> Bool

isDenormalized :: Interval a -> Bool

isNegativeZero :: Interval a -> Bool

isIEEE :: Interval a -> Bool

atan2 :: Interval a -> Interval a -> Interval a

RealFrac a => RealFrac (Interval a)

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)

Methods

showsPrec :: Int -> Interval a -> ShowS

show :: Interval a -> String

showList :: [Interval a] -> ShowS

Generic (Interval a)

Associated Types

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

Methods

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

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

type Rep1 Interval

type Rep1 Interval = D1 (MetaData "Interval" "Numeric.Interval.NonEmpty.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)))

type Rep (Interval a)

type Rep (Interval a) = D1 (MetaData "Interval" "Numeric.Interval.NonEmpty.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))))

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

Create a non-empty interval, turning it around if necessary

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

Try to create a non-empty interval.

whole :: Fractional a => Interval a

The whole real number line

>>> whole
-Infinity ... Infinity

(x :: Double) `elem` whole

singleton :: a -> Interval a

A singleton point

>>> singleton 1
1 ... 1

x `elem` (singleton x)

x /= y ==> y `notElem` (singleton x)

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

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

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

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

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

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

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

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

inf :: Interval a -> a

The infinumum (lower bound) of an interval

>>> inf (1 ... 20)
1

min x y == inf (x ... y)

inf x <= sup x

sup :: Interval a -> a

The supremum (upper bound) of an interval

>>> sup (1 ... 20)
20

sup x `elem` x

max x y == sup (x ... y)

inf x <= sup x

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

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

Calculate the width of an interval.

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

>>> width (singleton 1)
0

0 <= width x

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

Nearest point to the midpoint of the interval.

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

>>> midpoint (singleton 5.0)
5.0

midpoint x `elem` (x :: Interval Double)

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

Hausdorff distance between intervals.

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

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

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

commutative (distance :: Interval Double -> Interval Double -> Double)

0 <= distance x y

intersection :: Ord a => Interval a -> Interval a -> Maybe (Interval a)

Calculate the intersection of two intervals.

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

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

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

conservative2 const hull

conservative2 (flip const) hull

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

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)

let (a, b) = bisect (x :: Interval Double) in sup a == inf b

let (a, b) = bisect (x :: Interval Double) in inf a == inf x

let (a, b) = bisect (x :: Interval Double) in sup b == sup x

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

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

Magnitude

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

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

>>> magnitude (singleton 5)
5

0 <= magnitude x

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

"mignitude"

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

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

>>> mignitude (singleton 5)
5

0 <= mignitude x

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

clamp :: Ord a => Interval a -> a -> a

The nearest value to that supplied which is contained in the interval.

(clamp xs y) `elem` xs

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

Inflate an interval by enlarging it at both ends.

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

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

inflate x i `contains` i

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

Deflate an interval by shrinking it from both ends. Note that in cases that would result in an empty interval, the result is a singleton interval at the midpoint.

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

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

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

Scale an interval about its midpoint.

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

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

abs x >= 1 ==> (scale (x :: Double) i) `contains` i

forAll (choose (0,1)) $ \x -> abs x <= 1 ==> i `contains` (scale (x :: Double) i)

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

Construct a symmetric interval.

>>> symmetric 3
-3 ... 3

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

x `elem` symmetric x

0 `elem` symmetric x

idouble :: Interval Double -> Interval Double

id function. Useful for type specification

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

ifloat :: Interval Float -> Interval Float

id function. Useful for type specification

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

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

an interval containing all x quot y prop> forAll (memberOf xs) $ x -> forAll (memberOf ys) $ y -> 0 notMember ys ==> (x quot y) member (xs iquot ys) prop> 0 member ys ==> ioProperty $ do z <- try (evaluate (xs iquot ys)); return $ z === Left DivideByZero

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

an interval containing all x rem y prop> forAll (memberOf xs) $ x -> forAll (memberOf ys) $ y -> 0 notMember ys ==> (x rem y) member (xs irem ys) prop> 0 member ys ==> ioProperty $ do z <- try (evaluate (xs irem ys)); return $ z === Left DivideByZero

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

an interval containing all x div y prop> forAll (memberOf xs) $ x -> forAll (memberOf ys) $ y -> 0 notMember ys ==> (x div y) member (xs idiv ys) prop> 0 member ys ==> ioProperty $ do z <- try (evaluate (xs idiv ys)); return $ z === Left DivideByZero

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

an interval containing all x mod y prop> forAll (memberOf xs) $ x -> forAll (memberOf ys) $ y -> 0 notMember ys ==> (x mod y) member (xs imod ys) prop> 0 member ys ==> ioProperty $ do z <- try (evaluate (xs imod ys)); return $ z === Left DivideByZero