{-# OPTIONS_GHC -Wall -fno-warn-orphans #-}
{-# LANGUAGE CPP, LambdaCase, ScopedTypeVariables #-}
{-# LANGUAGE Safe #-}
{-# LANGUAGE RoleAnnotations #-}
module Data.Interval
(
Interval
, module Data.ExtendedReal
, Boundary(..)
, interval
, (<=..<=)
, (<..<=)
, (<=..<)
, (<..<)
, whole
, empty
, singleton
, null
, isSingleton
, extractSingleton
, member
, notMember
, isSubsetOf
, isProperSubsetOf
, isConnected
, lowerBound
, upperBound
, lowerBound'
, upperBound'
, width
, (<!), (<=!), (==!), (>=!), (>!), (/=!)
, (<?), (<=?), (==?), (>=?), (>?), (/=?)
, (<??), (<=??), (==??), (>=??), (>??), (/=??)
, intersection
, intersections
, hull
, hulls
, mapMonotonic
, pickup
, simplestRationalWithin
, relate
) where
#ifdef MIN_VERSION_lattices
import Algebra.Lattice
#endif
import Control.Exception (assert)
import Control.Monad hiding (join)
import Data.ExtendedReal
import Data.Interval.Internal
import Data.IntervalRelation
import Data.List (foldl', maximumBy, minimumBy)
import Data.Maybe
import Data.Monoid
import Data.Ratio
import Prelude hiding (null)
infix 5 <=..<=
infix 5 <..<=
infix 5 <=..<
infix 5 <..<
infix 4 <!
infix 4 <=!
infix 4 ==!
infix 4 >=!
infix 4 >!
infix 4 /=!
infix 4 <?
infix 4 <=?
infix 4 ==?
infix 4 >=?
infix 4 >?
infix 4 /=?
infix 4 <??
infix 4 <=??
infix 4 ==??
infix 4 >=??
infix 4 >??
infix 4 /=??
#ifdef MIN_VERSION_lattices
instance (Ord r) => Lattice (Interval r) where
\/ :: Interval r -> Interval r -> Interval r
(\/) = forall r. Ord r => Interval r -> Interval r -> Interval r
hull
/\ :: Interval r -> Interval r -> Interval r
(/\) = forall r. Ord r => Interval r -> Interval r -> Interval r
intersection
instance (Ord r) => BoundedJoinSemiLattice (Interval r) where
bottom :: Interval r
bottom = forall r. Ord r => Interval r
empty
instance (Ord r) => BoundedMeetSemiLattice (Interval r) where
top :: Interval r
top = forall r. Ord r => Interval r
whole
#endif
instance (Ord r, Show r) => Show (Interval r) where
showsPrec :: Int -> Interval r -> ShowS
showsPrec Int
_ Interval r
x | forall r. Ord r => Interval r -> Bool
null Interval r
x = String -> ShowS
showString String
"empty"
showsPrec Int
p Interval r
i =
Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
> Int
rangeOpPrec) forall a b. (a -> b) -> a -> b
$
forall a. Show a => Int -> a -> ShowS
showsPrec (Int
rangeOpPrecforall a. Num a => a -> a -> a
+Int
1) Extended r
lb forall b c a. (b -> c) -> (a -> b) -> a -> c
.
Char -> ShowS
showChar Char
' ' forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
op forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> ShowS
showChar Char
' ' forall b c a. (b -> c) -> (a -> b) -> a -> c
.
forall a. Show a => Int -> a -> ShowS
showsPrec (Int
rangeOpPrecforall a. Num a => a -> a -> a
+Int
1) Extended r
ub
where
(Extended r
lb, Boundary
in1) = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i
(Extended r
ub, Boundary
in2) = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i
op :: String
op = Boundary -> String
sign Boundary
in1 forall a. [a] -> [a] -> [a]
++ String
".." forall a. [a] -> [a] -> [a]
++ Boundary -> String
sign Boundary
in2
sign :: Boundary -> String
sign = \case
Boundary
Open -> String
"<"
Boundary
Closed -> String
"<="
instance (Ord r, Read r) => Read (Interval r) where
readsPrec :: Int -> ReadS (Interval r)
readsPrec Int
p String
r =
(forall a. Bool -> ReadS a -> ReadS a
readParen (Int
p forall a. Ord a => a -> a -> Bool
> Int
appPrec) forall a b. (a -> b) -> a -> b
$ \String
s0 -> do
(String
"interval",String
s1) <- ReadS String
lex String
s0
((Extended r, Boundary)
lb,String
s2) <- forall a. Read a => Int -> ReadS a
readsPrec (Int
appPrecforall a. Num a => a -> a -> a
+Int
1) String
s1
((Extended r, Boundary)
ub,String
s3) <- forall a. Read a => Int -> ReadS a
readsPrec (Int
appPrecforall a. Num a => a -> a -> a
+Int
1) String
s2
forall (m :: * -> *) a. Monad m => a -> m a
return (forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (Extended r, Boundary)
lb (Extended r, Boundary)
ub, String
s3)) String
r
forall a. [a] -> [a] -> [a]
++
(forall a. Bool -> ReadS a -> ReadS a
readParen (Int
p forall a. Ord a => a -> a -> Bool
> Int
rangeOpPrec) forall a b. (a -> b) -> a -> b
$ \String
s0 -> do
(do (Extended r
l,String
s1) <- forall a. Read a => Int -> ReadS a
readsPrec (Int
rangeOpPrecforall a. Num a => a -> a -> a
+Int
1) String
s0
(String
op',String
s2) <- ReadS String
lex String
s1
Extended r -> Extended r -> Interval r
op <-
case String
op' of
String
"<=..<=" -> forall (m :: * -> *) a. Monad m => a -> m a
return forall r. Ord r => Extended r -> Extended r -> Interval r
(<=..<=)
String
"<..<=" -> forall (m :: * -> *) a. Monad m => a -> m a
return forall r. Ord r => Extended r -> Extended r -> Interval r
(<..<=)
String
"<=..<" -> forall (m :: * -> *) a. Monad m => a -> m a
return forall r. Ord r => Extended r -> Extended r -> Interval r
(<=..<)
String
"<..<" -> forall (m :: * -> *) a. Monad m => a -> m a
return forall r. Ord r => Extended r -> Extended r -> Interval r
(<..<)
String
_ -> []
(Extended r
u,String
s3) <- forall a. Read a => Int -> ReadS a
readsPrec (Int
rangeOpPrecforall a. Num a => a -> a -> a
+Int
1) String
s2
forall (m :: * -> *) a. Monad m => a -> m a
return (Extended r -> Extended r -> Interval r
op Extended r
l Extended r
u, String
s3))) String
r
forall a. [a] -> [a] -> [a]
++
(do (String
"empty", String
s) <- ReadS String
lex String
r
forall (m :: * -> *) a. Monad m => a -> m a
return (forall r. Ord r => Interval r
empty, String
s))
lowerBound :: Interval r -> Extended r
lowerBound :: forall r. Interval r -> Extended r
lowerBound = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r. Interval r -> (Extended r, Boundary)
lowerBound'
upperBound :: Interval r -> Extended r
upperBound :: forall r. Interval r -> Extended r
upperBound = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r. Interval r -> (Extended r, Boundary)
upperBound'
(<=..<=)
:: (Ord r)
=> Extended r
-> Extended r
-> Interval r
<=..<= :: forall r. Ord r => Extended r -> Extended r -> Interval r
(<=..<=) Extended r
lb Extended r
ub = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (Extended r
lb, Boundary
Closed) (Extended r
ub, Boundary
Closed)
(<..<=)
:: (Ord r)
=> Extended r
-> Extended r
-> Interval r
<..<= :: forall r. Ord r => Extended r -> Extended r -> Interval r
(<..<=) Extended r
lb Extended r
ub = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (Extended r
lb, Boundary
Open) (Extended r
ub, Boundary
Closed)
(<=..<)
:: (Ord r)
=> Extended r
-> Extended r
-> Interval r
<=..< :: forall r. Ord r => Extended r -> Extended r -> Interval r
(<=..<) Extended r
lb Extended r
ub = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (Extended r
lb, Boundary
Closed) (Extended r
ub, Boundary
Open)
(<..<)
:: (Ord r)
=> Extended r
-> Extended r
-> Interval r
<..< :: forall r. Ord r => Extended r -> Extended r -> Interval r
(<..<) Extended r
lb Extended r
ub = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (Extended r
lb, Boundary
Open) (Extended r
ub, Boundary
Open)
whole :: Ord r => Interval r
whole :: forall r. Ord r => Interval r
whole = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall r. Extended r
NegInf, Boundary
Open) (forall r. Extended r
PosInf, Boundary
Open)
singleton :: Ord r => r -> Interval r
singleton :: forall r. Ord r => r -> Interval r
singleton r
x = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall r. r -> Extended r
Finite r
x, Boundary
Closed) (forall r. r -> Extended r
Finite r
x, Boundary
Closed)
intersection :: forall r. Ord r => Interval r -> Interval r -> Interval r
intersection :: forall r. Ord r => Interval r -> Interval r -> Interval r
intersection Interval r
i1 Interval r
i2 = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval
((Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
maxLB (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i2))
((Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
minUB (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i2))
where
maxLB :: (Extended r, Boundary) -> (Extended r, Boundary) -> (Extended r, Boundary)
maxLB :: (Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
maxLB (Extended r
x1,Boundary
in1) (Extended r
x2,Boundary
in2) =
( forall a. Ord a => a -> a -> a
max Extended r
x1 Extended r
x2
, case Extended r
x1 forall a. Ord a => a -> a -> Ordering
`compare` Extended r
x2 of
Ordering
EQ -> Boundary
in1 forall a. Ord a => a -> a -> a
`min` Boundary
in2
Ordering
LT -> Boundary
in2
Ordering
GT -> Boundary
in1
)
minUB :: (Extended r, Boundary) -> (Extended r, Boundary) -> (Extended r, Boundary)
minUB :: (Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
minUB (Extended r
x1,Boundary
in1) (Extended r
x2,Boundary
in2) =
( forall a. Ord a => a -> a -> a
min Extended r
x1 Extended r
x2
, case Extended r
x1 forall a. Ord a => a -> a -> Ordering
`compare` Extended r
x2 of
Ordering
EQ -> Boundary
in1 forall a. Ord a => a -> a -> a
`min` Boundary
in2
Ordering
LT -> Boundary
in1
Ordering
GT -> Boundary
in2
)
intersections :: Ord r => [Interval r] -> Interval r
intersections :: forall r. Ord r => [Interval r] -> Interval r
intersections = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' forall r. Ord r => Interval r -> Interval r -> Interval r
intersection forall r. Ord r => Interval r
whole
hull :: forall r. Ord r => Interval r -> Interval r -> Interval r
hull :: forall r. Ord r => Interval r -> Interval r -> Interval r
hull Interval r
x1 Interval r
x2
| forall r. Ord r => Interval r -> Bool
null Interval r
x1 = Interval r
x2
| forall r. Ord r => Interval r -> Bool
null Interval r
x2 = Interval r
x1
hull Interval r
i1 Interval r
i2 = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval
((Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
minLB (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i2))
((Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
maxUB (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i2))
where
maxUB :: (Extended r, Boundary) -> (Extended r, Boundary) -> (Extended r, Boundary)
maxUB :: (Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
maxUB (Extended r
x1,Boundary
in1) (Extended r
x2,Boundary
in2) =
( forall a. Ord a => a -> a -> a
max Extended r
x1 Extended r
x2
, case Extended r
x1 forall a. Ord a => a -> a -> Ordering
`compare` Extended r
x2 of
Ordering
EQ -> Boundary
in1 forall a. Ord a => a -> a -> a
`max` Boundary
in2
Ordering
LT -> Boundary
in2
Ordering
GT -> Boundary
in1
)
minLB :: (Extended r, Boundary) -> (Extended r, Boundary) -> (Extended r, Boundary)
minLB :: (Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
minLB (Extended r
x1,Boundary
in1) (Extended r
x2,Boundary
in2) =
( forall a. Ord a => a -> a -> a
min Extended r
x1 Extended r
x2
, case Extended r
x1 forall a. Ord a => a -> a -> Ordering
`compare` Extended r
x2 of
Ordering
EQ -> Boundary
in1 forall a. Ord a => a -> a -> a
`max` Boundary
in2
Ordering
LT -> Boundary
in1
Ordering
GT -> Boundary
in2
)
hulls :: Ord r => [Interval r] -> Interval r
hulls :: forall r. Ord r => [Interval r] -> Interval r
hulls = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' forall r. Ord r => Interval r -> Interval r -> Interval r
hull forall r. Ord r => Interval r
empty
null :: Ord r => Interval r -> Bool
null :: forall r. Ord r => Interval r -> Bool
null Interval r
i =
case Extended r
x1 forall a. Ord a => a -> a -> Ordering
`compare` Extended r
x2 of
Ordering
EQ -> forall a. (?callStack::CallStack) => Bool -> a -> a
assert (Boundary
in1 forall a. Eq a => a -> a -> Bool
== Boundary
Closed Bool -> Bool -> Bool
&& Boundary
in2 forall a. Eq a => a -> a -> Bool
== Boundary
Closed) Bool
False
Ordering
LT -> Bool
False
Ordering
GT -> Bool
True
where
(Extended r
x1, Boundary
in1) = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i
(Extended r
x2, Boundary
in2) = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i
isSingleton :: Ord r => Interval r -> Bool
isSingleton :: forall r. Ord r => Interval r -> Bool
isSingleton = forall a. Maybe a -> Bool
isJust forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r. Ord r => Interval r -> Maybe r
extractSingleton
extractSingleton :: Ord r => Interval r -> Maybe r
Interval r
i = case (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i, forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i) of
((Finite r
l, Boundary
Closed), (Finite r
u, Boundary
Closed))
| r
l forall a. Eq a => a -> a -> Bool
== r
u -> forall a. a -> Maybe a
Just r
l
((Extended r, Boundary), (Extended r, Boundary))
_ -> forall a. Maybe a
Nothing
member :: Ord r => r -> Interval r -> Bool
member :: forall r. Ord r => r -> Interval r -> Bool
member r
x Interval r
i = Bool
condLB Bool -> Bool -> Bool
&& Bool
condUB
where
(Extended r
x1, Boundary
in1) = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i
(Extended r
x2, Boundary
in2) = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i
condLB :: Bool
condLB = case Boundary
in1 of
Boundary
Open -> Extended r
x1 forall a. Ord a => a -> a -> Bool
< forall r. r -> Extended r
Finite r
x
Boundary
Closed -> Extended r
x1 forall a. Ord a => a -> a -> Bool
<= forall r. r -> Extended r
Finite r
x
condUB :: Bool
condUB = case Boundary
in2 of
Boundary
Open -> forall r. r -> Extended r
Finite r
x forall a. Ord a => a -> a -> Bool
< Extended r
x2
Boundary
Closed -> forall r. r -> Extended r
Finite r
x forall a. Ord a => a -> a -> Bool
<= Extended r
x2
notMember :: Ord r => r -> Interval r -> Bool
notMember :: forall r. Ord r => r -> Interval r -> Bool
notMember r
a Interval r
i = Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall r. Ord r => r -> Interval r -> Bool
member r
a Interval r
i
isSubsetOf :: Ord r => Interval r -> Interval r -> Bool
isSubsetOf :: forall r. Ord r => Interval r -> Interval r -> Bool
isSubsetOf Interval r
i1 Interval r
i2 = forall {a} {a}. (Ord a, Ord a) => (a, a) -> (a, a) -> Bool
testLB (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i2) Bool -> Bool -> Bool
&& forall {a} {a}. (Ord a, Ord a) => (a, a) -> (a, a) -> Bool
testUB (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i2)
where
testLB :: (a, a) -> (a, a) -> Bool
testLB (a
x1,a
in1) (a
x2,a
in2) =
case a
x1 forall a. Ord a => a -> a -> Ordering
`compare` a
x2 of
Ordering
GT -> Bool
True
Ordering
LT -> Bool
False
Ordering
EQ -> a
in1 forall a. Ord a => a -> a -> Bool
<= a
in2
testUB :: (a, a) -> (a, a) -> Bool
testUB (a
x1,a
in1) (a
x2,a
in2) =
case a
x1 forall a. Ord a => a -> a -> Ordering
`compare` a
x2 of
Ordering
LT -> Bool
True
Ordering
GT -> Bool
False
Ordering
EQ -> a
in1 forall a. Ord a => a -> a -> Bool
<= a
in2
isProperSubsetOf :: Ord r => Interval r -> Interval r -> Bool
isProperSubsetOf :: forall r. Ord r => Interval r -> Interval r -> Bool
isProperSubsetOf Interval r
i1 Interval r
i2 = Interval r
i1 forall a. Eq a => a -> a -> Bool
/= Interval r
i2 Bool -> Bool -> Bool
&& Interval r
i1 forall r. Ord r => Interval r -> Interval r -> Bool
`isSubsetOf` Interval r
i2
isConnected :: Ord r => Interval r -> Interval r -> Bool
isConnected :: forall r. Ord r => Interval r -> Interval r -> Bool
isConnected Interval r
x Interval r
y
| forall r. Ord r => Interval r -> Bool
null Interval r
x = Bool
True
| forall r. Ord r => Interval r -> Bool
null Interval r
y = Bool
True
| Bool
otherwise = Interval r
x forall r. Ord r => Interval r -> Interval r -> Bool
==? Interval r
y Bool -> Bool -> Bool
|| (Extended r
lb1forall a. Eq a => a -> a -> Bool
==Extended r
ub2 Bool -> Bool -> Bool
&& (Boundary
lb1in forall a. Eq a => a -> a -> Bool
== Boundary
Closed Bool -> Bool -> Bool
|| Boundary
ub2in forall a. Eq a => a -> a -> Bool
== Boundary
Closed)) Bool -> Bool -> Bool
|| (Extended r
ub1forall a. Eq a => a -> a -> Bool
==Extended r
lb2 Bool -> Bool -> Bool
&& (Boundary
ub1in forall a. Eq a => a -> a -> Bool
== Boundary
Closed Bool -> Bool -> Bool
|| Boundary
lb2in forall a. Eq a => a -> a -> Bool
== Boundary
Closed))
where
(Extended r
lb1,Boundary
lb1in) = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
x
(Extended r
lb2,Boundary
lb2in) = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
y
(Extended r
ub1,Boundary
ub1in) = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
x
(Extended r
ub2,Boundary
ub2in) = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
y
width :: (Num r, Ord r) => Interval r -> r
width :: forall r. (Num r, Ord r) => Interval r -> r
width Interval r
x
| forall r. Ord r => Interval r -> Bool
null Interval r
x = r
0
| Bool
otherwise = case (forall a b. (a, b) -> a
fst (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
x), forall a b. (a, b) -> a
fst (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
x)) of
(Finite r
l, Finite r
u) -> r
u forall a. Num a => a -> a -> a
- r
l
(Extended r, Extended r)
_ -> forall a. (?callStack::CallStack) => String -> a
error String
"Data.Interval.width: unbounded interval"
pickup :: (Real r, Fractional r) => Interval r -> Maybe r
pickup :: forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup Interval r
i = case (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i, forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i) of
((Extended r
NegInf,Boundary
_), (Extended r
PosInf,Boundary
_)) -> forall a. a -> Maybe a
Just r
0
((Finite r
x1, Boundary
in1), (Extended r
PosInf,Boundary
_)) -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ case Boundary
in1 of
Boundary
Open -> r
x1 forall a. Num a => a -> a -> a
+ r
1
Boundary
Closed -> r
x1
((Extended r
NegInf,Boundary
_), (Finite r
x2, Boundary
in2)) -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ case Boundary
in2 of
Boundary
Open -> r
x2 forall a. Num a => a -> a -> a
- r
1
Boundary
Closed -> r
x2
((Finite r
x1, Boundary
in1), (Finite r
x2, Boundary
in2)) ->
case r
x1 forall a. Ord a => a -> a -> Ordering
`compare` r
x2 of
Ordering
GT -> forall a. Maybe a
Nothing
Ordering
LT -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ (r
x1forall a. Num a => a -> a -> a
+r
x2) forall a. Fractional a => a -> a -> a
/ r
2
Ordering
EQ -> if Boundary
in1 forall a. Eq a => a -> a -> Bool
== Boundary
Closed Bool -> Bool -> Bool
&& Boundary
in2 forall a. Eq a => a -> a -> Bool
== Boundary
Closed then forall a. a -> Maybe a
Just r
x1 else forall a. Maybe a
Nothing
((Extended r, Boundary), (Extended r, Boundary))
_ -> forall a. Maybe a
Nothing
simplestRationalWithin :: RealFrac r => Interval r -> Maybe Rational
simplestRationalWithin :: forall r. RealFrac r => Interval r -> Maybe Rational
simplestRationalWithin Interval r
i | forall r. Ord r => Interval r -> Bool
null Interval r
i = forall a. Maybe a
Nothing
simplestRationalWithin Interval r
i
| Interval r
0 forall r. Ord r => Interval r -> Interval r -> Bool
<! Interval r
i = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall {r} {a}. (Fractional a, RealFrac r) => Interval r -> a
go Interval r
i
| Interval r
i forall r. Ord r => Interval r -> Interval r -> Bool
<! Interval r
0 = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ - forall {r} {a}. (Fractional a, RealFrac r) => Interval r -> a
go (- Interval r
i)
| Bool
otherwise = forall a. (?callStack::CallStack) => Bool -> a -> a
assert (r
0 forall r. Ord r => r -> Interval r -> Bool
`member` Interval r
i) forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Rational
0
where
go :: Interval r -> a
go Interval r
j
| forall a. Num a => Integer -> a
fromInteger Integer
lb_floor forall r. Ord r => r -> Interval r -> Bool
`member` Interval r
j = forall a. Num a => Integer -> a
fromInteger Integer
lb_floor
| forall a. Num a => Integer -> a
fromInteger (Integer
lb_floor forall a. Num a => a -> a -> a
+ Integer
1) forall r. Ord r => r -> Interval r -> Bool
`member` Interval r
j = forall a. Num a => Integer -> a
fromInteger (Integer
lb_floor forall a. Num a => a -> a -> a
+ Integer
1)
| Bool
otherwise = forall a. Num a => Integer -> a
fromInteger Integer
lb_floor forall a. Num a => a -> a -> a
+ forall a. Fractional a => a -> a
recip (Interval r -> a
go (forall a. Fractional a => a -> a
recip (Interval r
j forall a. Num a => a -> a -> a
- forall r. Ord r => r -> Interval r
singleton (forall a. Num a => Integer -> a
fromInteger Integer
lb_floor))))
where
Finite r
lb = forall r. Interval r -> Extended r
lowerBound Interval r
j
lb_floor :: Integer
lb_floor = forall a b. (RealFrac a, Integral b) => a -> b
floor r
lb
mapMonotonic :: (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic :: forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic a -> b
f Interval a
i = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Extended a
lb, Boundary
in1) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Extended a
ub, Boundary
in2)
where
(Extended a
lb, Boundary
in1) = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval a
i
(Extended a
ub, Boundary
in2) = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval a
i
mapAntiMonotonic :: (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapAntiMonotonic :: forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapAntiMonotonic a -> b
f Interval a
i
| forall r. Ord r => Interval r -> Bool
null Interval a
i = forall r. Ord r => Interval r
empty
| Bool
otherwise = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Extended a
ub, Boundary
in2) (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f Extended a
lb, Boundary
in1)
where
(Extended a
lb, Boundary
in1) = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval a
i
(Extended a
ub, Boundary
in2) = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval a
i
(<!) :: Ord r => Interval r -> Interval r -> Bool
Interval r
a <! :: forall r. Ord r => Interval r -> Interval r -> Bool
<! Interval r
b =
case Extended r
ub_a forall a. Ord a => a -> a -> Ordering
`compare` Extended r
lb_b of
Ordering
LT -> Bool
True
Ordering
GT -> Bool
False
Ordering
EQ ->
case Extended r
ub_a of
Extended r
NegInf -> Bool
True
Extended r
PosInf -> Bool
True
Finite r
_ -> Boundary
in1 forall a. Eq a => a -> a -> Bool
== Boundary
Open Bool -> Bool -> Bool
|| Boundary
in2 forall a. Eq a => a -> a -> Bool
== Boundary
Open
where
(Extended r
ub_a, Boundary
in1) = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
a
(Extended r
lb_b, Boundary
in2) = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
b
(<=!) :: Ord r => Interval r -> Interval r -> Bool
Interval r
a <=! :: forall r. Ord r => Interval r -> Interval r -> Bool
<=! Interval r
b = forall r. Interval r -> Extended r
upperBound Interval r
a forall a. Ord a => a -> a -> Bool
<= forall r. Interval r -> Extended r
lowerBound Interval r
b
(==!) :: Ord r => Interval r -> Interval r -> Bool
Interval r
a ==! :: forall r. Ord r => Interval r -> Interval r -> Bool
==! Interval r
b = Interval r
a forall r. Ord r => Interval r -> Interval r -> Bool
<=! Interval r
b Bool -> Bool -> Bool
&& Interval r
a forall r. Ord r => Interval r -> Interval r -> Bool
>=! Interval r
b
(/=!) :: Ord r => Interval r -> Interval r -> Bool
Interval r
a /=! :: forall r. Ord r => Interval r -> Interval r -> Bool
/=! Interval r
b = forall r. Ord r => Interval r -> Bool
null forall a b. (a -> b) -> a -> b
$ Interval r
a forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` Interval r
b
(>=!) :: Ord r => Interval r -> Interval r -> Bool
>=! :: forall r. Ord r => Interval r -> Interval r -> Bool
(>=!) = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall r. Ord r => Interval r -> Interval r -> Bool
(<=!)
(>!) :: Ord r => Interval r -> Interval r -> Bool
>! :: forall r. Ord r => Interval r -> Interval r -> Bool
(>!) = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall r. Ord r => Interval r -> Interval r -> Bool
(<!)
(<?) :: Ord r => Interval r -> Interval r -> Bool
Interval r
a <? :: forall r. Ord r => Interval r -> Interval r -> Bool
<? Interval r
b = Extended r
lb_a forall a. Ord a => a -> a -> Bool
< Extended r
ub_b
where
lb_a :: Extended r
lb_a = forall r. Interval r -> Extended r
lowerBound Interval r
a
ub_b :: Extended r
ub_b = forall r. Interval r -> Extended r
upperBound Interval r
b
(<??) :: (Real r, Fractional r) => Interval r -> Interval r -> Maybe (r,r)
Interval r
a <?? :: forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
<?? Interval r
b = do
forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall a b. (a -> b) -> a -> b
$ forall r. Interval r -> Extended r
lowerBound Interval r
a forall a. Ord a => a -> a -> Bool
< forall r. Interval r -> Extended r
upperBound Interval r
b
let c :: Interval r
c = forall r. Ord r => Interval r -> Interval r -> Interval r
intersection Interval r
a Interval r
b
case forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup Interval r
c of
Maybe r
Nothing -> do
r
x <- forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup Interval r
a
r
y <- forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup Interval r
b
forall (m :: * -> *) a. Monad m => a -> m a
return (r
x,r
y)
Just r
z -> do
let r
x:r
y:[r]
_ = forall a. Int -> [a] -> [a]
take Int
2 forall a b. (a -> b) -> a -> b
$
forall a. Maybe a -> [a]
maybeToList (forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup (forall r. Ord r => Interval r -> Interval r -> Interval r
intersection Interval r
a (-forall r. Extended r
inf forall r. Ord r => Extended r -> Extended r -> Interval r
<..< forall r. r -> Extended r
Finite r
z))) forall a. [a] -> [a] -> [a]
++
[r
z] forall a. [a] -> [a] -> [a]
++
forall a. Maybe a -> [a]
maybeToList (forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup (forall r. Ord r => Interval r -> Interval r -> Interval r
intersection Interval r
b (forall r. r -> Extended r
Finite r
z forall r. Ord r => Extended r -> Extended r -> Interval r
<..< forall r. Extended r
inf)))
forall (m :: * -> *) a. Monad m => a -> m a
return (r
x,r
y)
(<=?) :: Ord r => Interval r -> Interval r -> Bool
Interval r
a <=? :: forall r. Ord r => Interval r -> Interval r -> Bool
<=? Interval r
b =
case Extended r
lb_a forall a. Ord a => a -> a -> Ordering
`compare` Extended r
ub_b of
Ordering
LT -> Bool
True
Ordering
GT -> Bool
False
Ordering
EQ ->
case Extended r
lb_a of
Extended r
NegInf -> Bool
False
Extended r
PosInf -> Bool
False
Finite r
_ -> Boundary
in1 forall a. Eq a => a -> a -> Bool
== Boundary
Closed Bool -> Bool -> Bool
&& Boundary
in2 forall a. Eq a => a -> a -> Bool
== Boundary
Closed
where
(Extended r
lb_a, Boundary
in1) = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
a
(Extended r
ub_b, Boundary
in2) = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
b
(<=??) :: (Real r, Fractional r) => Interval r -> Interval r -> Maybe (r,r)
Interval r
a <=?? :: forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
<=?? Interval r
b =
case forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup (forall r. Ord r => Interval r -> Interval r -> Interval r
intersection Interval r
a Interval r
b) of
Just r
x -> forall (m :: * -> *) a. Monad m => a -> m a
return (r
x,r
x)
Maybe r
Nothing -> do
forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall a b. (a -> b) -> a -> b
$ forall r. Interval r -> Extended r
upperBound Interval r
a forall a. Ord a => a -> a -> Bool
<= forall r. Interval r -> Extended r
lowerBound Interval r
b
r
x <- forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup Interval r
a
r
y <- forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup Interval r
b
forall (m :: * -> *) a. Monad m => a -> m a
return (r
x,r
y)
(==?) :: Ord r => Interval r -> Interval r -> Bool
Interval r
a ==? :: forall r. Ord r => Interval r -> Interval r -> Bool
==? Interval r
b = Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall r. Ord r => Interval r -> Bool
null forall a b. (a -> b) -> a -> b
$ forall r. Ord r => Interval r -> Interval r -> Interval r
intersection Interval r
a Interval r
b
(==??) :: (Real r, Fractional r) => Interval r -> Interval r -> Maybe (r,r)
Interval r
a ==?? :: forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
==?? Interval r
b = do
r
x <- forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup (forall r. Ord r => Interval r -> Interval r -> Interval r
intersection Interval r
a Interval r
b)
forall (m :: * -> *) a. Monad m => a -> m a
return (r
x,r
x)
(/=?) :: Ord r => Interval r -> Interval r -> Bool
Interval r
a /=? :: forall r. Ord r => Interval r -> Interval r -> Bool
/=? Interval r
b = Bool -> Bool
not (forall r. Ord r => Interval r -> Bool
null Interval r
a) Bool -> Bool -> Bool
&& Bool -> Bool
not (forall r. Ord r => Interval r -> Bool
null Interval r
b) Bool -> Bool -> Bool
&& Bool -> Bool
not (Interval r
a forall a. Eq a => a -> a -> Bool
== Interval r
b Bool -> Bool -> Bool
&& forall r. Ord r => Interval r -> Bool
isSingleton Interval r
a)
(/=??) :: (Real r, Fractional r) => Interval r -> Interval r -> Maybe (r,r)
Interval r
a /=?? :: forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
/=?? Interval r
b = do
forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall r. Ord r => Interval r -> Bool
null Interval r
a
forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ forall r. Ord r => Interval r -> Bool
null Interval r
b
forall (f :: * -> *). Alternative f => Bool -> f ()
guard forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ Interval r
a forall a. Eq a => a -> a -> Bool
== Interval r
b Bool -> Bool -> Bool
&& forall r. Ord r => Interval r -> Bool
isSingleton Interval r
a
if Bool -> Bool
not (forall r. Ord r => Interval r -> Bool
isSingleton Interval r
b)
then forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
f Interval r
a Interval r
b
else forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\(r
y,r
x) -> (r
x,r
y)) forall a b. (a -> b) -> a -> b
$ forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
f Interval r
b Interval r
a
where
f :: Interval b -> Interval b -> Maybe (b, b)
f Interval b
i Interval b
j = do
b
x <- forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup Interval b
i
b
y <- forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum [forall r. (Real r, Fractional r) => Interval r -> Maybe r
pickup (Interval b
j forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` Interval b
c) | Interval b
c <- [-forall r. Extended r
inf forall r. Ord r => Extended r -> Extended r -> Interval r
<..< forall r. r -> Extended r
Finite b
x, forall r. r -> Extended r
Finite b
x forall r. Ord r => Extended r -> Extended r -> Interval r
<..< forall r. Extended r
inf]]
forall (m :: * -> *) a. Monad m => a -> m a
return (b
x,b
y)
(>=?) :: Ord r => Interval r -> Interval r -> Bool
>=? :: forall r. Ord r => Interval r -> Interval r -> Bool
(>=?) = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall r. Ord r => Interval r -> Interval r -> Bool
(<=?)
(>?) :: Ord r => Interval r -> Interval r -> Bool
>? :: forall r. Ord r => Interval r -> Interval r -> Bool
(>?) = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall r. Ord r => Interval r -> Interval r -> Bool
(<?)
(>=??) :: (Real r, Fractional r) => Interval r -> Interval r -> Maybe (r,r)
>=?? :: forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
(>=??) = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
(<=??)
(>??) :: (Real r, Fractional r) => Interval r -> Interval r -> Maybe (r,r)
>?? :: forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
(>??) = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall r.
(Real r, Fractional r) =>
Interval r -> Interval r -> Maybe (r, r)
(<??)
appPrec :: Int
appPrec :: Int
appPrec = Int
10
rangeOpPrec :: Int
rangeOpPrec :: Int
rangeOpPrec = Int
5
scaleInterval :: (Num r, Ord r) => r -> Interval r -> Interval r
scaleInterval :: forall r. (Num r, Ord r) => r -> Interval r -> Interval r
scaleInterval r
c Interval r
x
| forall r. Ord r => Interval r -> Bool
null Interval r
x = forall r. Ord r => Interval r
empty
| Bool
otherwise = case forall a. Ord a => a -> a -> Ordering
compare r
c r
0 of
Ordering
EQ -> forall r. Ord r => r -> Interval r
singleton r
0
Ordering
LT -> forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall r.
(Num r, Ord r) =>
r -> (Extended r, Boundary) -> (Extended r, Boundary)
scaleInf' r
c (Extended r, Boundary)
ub) (forall r.
(Num r, Ord r) =>
r -> (Extended r, Boundary) -> (Extended r, Boundary)
scaleInf' r
c (Extended r, Boundary)
lb)
Ordering
GT -> forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall r.
(Num r, Ord r) =>
r -> (Extended r, Boundary) -> (Extended r, Boundary)
scaleInf' r
c (Extended r, Boundary)
lb) (forall r.
(Num r, Ord r) =>
r -> (Extended r, Boundary) -> (Extended r, Boundary)
scaleInf' r
c (Extended r, Boundary)
ub)
where
lb :: (Extended r, Boundary)
lb = forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
x
ub :: (Extended r, Boundary)
ub = forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
x
instance (Num r, Ord r) => Num (Interval r) where
Interval r
a + :: Interval r -> Interval r -> Interval r
+ Interval r
b
| forall r. Ord r => Interval r -> Bool
null Interval r
a Bool -> Bool -> Bool
|| forall r. Ord r => Interval r -> Bool
null Interval r
b = forall r. Ord r => Interval r
empty
| Bool
otherwise = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall {r}.
(Num r, Ord r) =>
(Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
f (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
a) (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
b)) (forall {r}.
Num r =>
(Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
g (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
a) (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
b))
where
f :: (Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
f (Finite r
x1, Boundary
in1) (Finite r
x2, Boundary
in2) = (forall r. r -> Extended r
Finite (r
x1forall a. Num a => a -> a -> a
+r
x2), Boundary
in1 forall a. Ord a => a -> a -> a
`min` Boundary
in2)
f (Extended r
NegInf,Boundary
_) (Extended r, Boundary)
_ = (-forall r. Extended r
inf, Boundary
Open)
f (Extended r, Boundary)
_ (Extended r
NegInf,Boundary
_) = (-forall r. Extended r
inf, Boundary
Open)
f (Extended r, Boundary)
_ (Extended r, Boundary)
_ = forall a. (?callStack::CallStack) => String -> a
error String
"Interval.(+) should not happen"
g :: (Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
g (Finite r
x1, Boundary
in1) (Finite r
x2, Boundary
in2) = (forall r. r -> Extended r
Finite (r
x1forall a. Num a => a -> a -> a
+r
x2), Boundary
in1 forall a. Ord a => a -> a -> a
`min` Boundary
in2)
g (Extended r
PosInf,Boundary
_) (Extended r, Boundary)
_ = (forall r. Extended r
inf, Boundary
Open)
g (Extended r, Boundary)
_ (Extended r
PosInf,Boundary
_) = (forall r. Extended r
inf, Boundary
Open)
g (Extended r, Boundary)
_ (Extended r, Boundary)
_ = forall a. (?callStack::CallStack) => String -> a
error String
"Interval.(+) should not happen"
negate :: Interval r -> Interval r
negate = forall r. (Num r, Ord r) => r -> Interval r -> Interval r
scaleInterval (-r
1)
fromInteger :: Integer -> Interval r
fromInteger Integer
i = forall r. Ord r => r -> Interval r
singleton (forall a. Num a => Integer -> a
fromInteger Integer
i)
abs :: Interval r -> Interval r
abs Interval r
x = (Interval r
x forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` Interval r
nonneg) forall r. Ord r => Interval r -> Interval r -> Interval r
`hull` (forall a. Num a => a -> a
negate Interval r
x forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` Interval r
nonneg)
where
nonneg :: Interval r
nonneg = Extended r
0 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..< forall r. Extended r
inf
signum :: Interval r -> Interval r
signum Interval r
x = Interval r
zero forall r. Ord r => Interval r -> Interval r -> Interval r
`hull` Interval r
pos forall r. Ord r => Interval r -> Interval r -> Interval r
`hull` Interval r
neg
where
zero :: Interval r
zero = if forall r. Ord r => r -> Interval r -> Bool
member r
0 Interval r
x then forall r. Ord r => r -> Interval r
singleton r
0 else forall r. Ord r => Interval r
empty
pos :: Interval r
pos = if forall r. Ord r => Interval r -> Bool
null forall a b. (a -> b) -> a -> b
$ (Extended r
0 forall r. Ord r => Extended r -> Extended r -> Interval r
<..< forall r. Extended r
inf) forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` Interval r
x
then forall r. Ord r => Interval r
empty
else forall r. Ord r => r -> Interval r
singleton r
1
neg :: Interval r
neg = if forall r. Ord r => Interval r -> Bool
null forall a b. (a -> b) -> a -> b
$ (-forall r. Extended r
inf forall r. Ord r => Extended r -> Extended r -> Interval r
<..< Extended r
0) forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` Interval r
x
then forall r. Ord r => Interval r
empty
else forall r. Ord r => r -> Interval r
singleton (-r
1)
Interval r
a * :: Interval r -> Interval r -> Interval r
* Interval r
b
| forall r. Ord r => Interval r -> Bool
null Interval r
a Bool -> Bool -> Bool
|| forall r. Ord r => Interval r -> Bool
null Interval r
b = forall r. Ord r => Interval r
empty
| Bool
otherwise = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (Extended r, Boundary)
lb3 (Extended r, Boundary)
ub3
where
xs :: [(Extended r, Boundary)]
xs = [ forall {r}.
(Num r, Ord r) =>
(Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
mulInf' (Extended r, Boundary)
x1 (Extended r, Boundary)
x2 | (Extended r, Boundary)
x1 <- [forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
a, forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
a], (Extended r, Boundary)
x2 <- [forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
b, forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
b] ]
ub3 :: (Extended r, Boundary)
ub3 = forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
maximumBy forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
cmpUB [(Extended r, Boundary)]
xs
lb3 :: (Extended r, Boundary)
lb3 = forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
minimumBy forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
cmpLB [(Extended r, Boundary)]
xs
instance forall r. (Real r, Fractional r) => Fractional (Interval r) where
fromRational :: Rational -> Interval r
fromRational Rational
r = forall r. Ord r => r -> Interval r
singleton (forall a. Fractional a => Rational -> a
fromRational Rational
r)
recip :: Interval r -> Interval r
recip Interval r
a
| forall r. Ord r => Interval r -> Bool
null Interval r
a = forall r. Ord r => Interval r
empty
| Interval r
a forall a. Eq a => a -> a -> Bool
== Interval r
0 = forall r. Ord r => Interval r
empty
| r
0 forall r. Ord r => r -> Interval r -> Bool
`member` Interval r
a Bool -> Bool -> Bool
&& Extended r
0 forall a. Eq a => a -> a -> Bool
/= forall r. Interval r -> Extended r
lowerBound Interval r
a Bool -> Bool -> Bool
&& Extended r
0 forall a. Eq a => a -> a -> Bool
/= forall r. Interval r -> Extended r
upperBound Interval r
a = forall r. Ord r => Interval r
whole
| Bool
otherwise = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (Extended r, Boundary)
lb3 (Extended r, Boundary)
ub3
where
ub3 :: (Extended r, Boundary)
ub3 = forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
maximumBy forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
cmpUB [(Extended r, Boundary)]
xs
lb3 :: (Extended r, Boundary)
lb3 = forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
minimumBy forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
cmpLB [(Extended r, Boundary)]
xs
xs :: [(Extended r, Boundary)]
xs = [forall r.
(Fractional r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
recipLB (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
a), forall r.
(Fractional r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
recipUB (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
a)]
instance (RealFrac r, Floating r) => Floating (Interval r) where
pi :: Interval r
pi = forall r. Ord r => r -> Interval r
singleton forall a. Floating a => a
pi
exp :: Interval r -> Interval r
exp = forall r. Ord r => Interval r -> Interval r -> Interval r
intersection (Extended r
0 forall r. Ord r => Extended r -> Extended r -> Interval r
<..< forall r. Extended r
PosInf) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic forall a. Floating a => a -> a
exp
log :: Interval r -> Interval r
log Interval r
a = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall r.
(Floating r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
logB (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
b)) (forall r.
(Floating r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
logB (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
b))
where
b :: Interval r
b = forall r. Ord r => Interval r -> Interval r -> Interval r
intersection (Extended r
0 forall r. Ord r => Extended r -> Extended r -> Interval r
<..< forall r. Extended r
PosInf) Interval r
a
sqrt :: Interval r -> Interval r
sqrt = forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic forall a. Floating a => a -> a
sqrt forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r. Ord r => Interval r -> Interval r -> Interval r
intersection (Extended r
0 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..< forall r. Extended r
PosInf)
Interval r
a ** :: Interval r -> Interval r -> Interval r
** Interval r
b = forall r. Ord r => [Interval r] -> Interval r
hulls (Interval r
posBase forall a. a -> [a] -> [a]
: Interval r
negBasePosPower forall a. a -> [a] -> [a]
: Interval r
negBaseNegPower forall a. a -> [a] -> [a]
: [Interval r]
zeroPower forall a. [a] -> [a] -> [a]
++ [Interval r]
zeroBase)
where
posBase :: Interval r
posBase = forall a. Floating a => a -> a
exp (forall a. Floating a => a -> a
log Interval r
a forall a. Num a => a -> a -> a
* Interval r
b)
zeroPower :: [Interval r]
zeroPower = [ Interval r
1 | r
0 forall r. Ord r => r -> Interval r -> Bool
`member` Interval r
b, Bool -> Bool
not (forall r. Ord r => Interval r -> Bool
null Interval r
a) ]
zeroBase :: [Interval r]
zeroBase = [ Interval r
0 | r
0 forall r. Ord r => r -> Interval r -> Bool
`member` Interval r
a, Bool -> Bool
not (forall r. Ord r => Interval r -> Bool
null (Interval r
b forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` (Extended r
0 forall r. Ord r => Extended r -> Extended r -> Interval r
<..< forall r. Extended r
PosInf))) ]
negBasePosPower :: Interval r
negBasePosPower = forall r. RealFrac r => Interval r -> Interval r -> Interval r
positiveIntegralPowersOfNegativeValues
(Interval r
a forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` (forall r. Extended r
NegInf forall r. Ord r => Extended r -> Extended r -> Interval r
<..< Extended r
0))
(Interval r
b forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` (Extended r
0 forall r. Ord r => Extended r -> Extended r -> Interval r
<..< forall r. Extended r
PosInf))
negBaseNegPower :: Interval r
negBaseNegPower = forall r. RealFrac r => Interval r -> Interval r -> Interval r
positiveIntegralPowersOfNegativeValues
(forall a. Fractional a => a -> a
recip (Interval r
a forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` (forall r. Extended r
NegInf forall r. Ord r => Extended r -> Extended r -> Interval r
<..< Extended r
0)))
(forall a. Num a => a -> a
negate (Interval r
b forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` (forall r. Extended r
NegInf forall r. Ord r => Extended r -> Extended r -> Interval r
<..< Extended r
0)))
cos :: Interval r -> Interval r
cos Interval r
a = case forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
a of
(Extended r
NegInf, Boundary
_) -> -Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..<= Extended r
1
(Extended r
PosInf, Boundary
_) -> forall r. Ord r => Interval r
empty
(Finite r
lb, Boundary
in1) -> case forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
a of
(Extended r
NegInf, Boundary
_) -> forall r. Ord r => Interval r
empty
(Extended r
PosInf, Boundary
_) -> -Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..<= Extended r
1
(Finite r
ub, Boundary
in2)
| r
ub forall a. Num a => a -> a -> a
- r
lb forall a. Ord a => a -> a -> Bool
> r
2 forall a. Num a => a -> a -> a
* forall a. Floating a => a
pi -> -Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..<= Extended r
1
| Extended r
clb forall a. Eq a => a -> a -> Bool
== -Extended r
1 Bool -> Bool -> Bool
&& r
ub forall a. Num a => a -> a -> a
- r
lb forall a. Eq a => a -> a -> Bool
== r
2 forall a. Num a => a -> a -> a
* forall a. Floating a => a
pi Bool -> Bool -> Bool
&& Boundary
in1 forall a. Eq a => a -> a -> Bool
== Boundary
Open Bool -> Bool -> Bool
&& Boundary
in2 forall a. Eq a => a -> a -> Bool
== Boundary
Open -> -Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<..<= Extended r
1
| Extended r
clb forall a. Eq a => a -> a -> Bool
== Extended r
1 Bool -> Bool -> Bool
&& r
ub forall a. Num a => a -> a -> a
- r
lb forall a. Eq a => a -> a -> Bool
== r
2 forall a. Num a => a -> a -> a
* forall a. Floating a => a
pi Bool -> Bool -> Bool
&& Boundary
in1 forall a. Eq a => a -> a -> Bool
== Boundary
Open Bool -> Bool -> Bool
&& Boundary
in2 forall a. Eq a => a -> a -> Bool
== Boundary
Open -> -Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..< Extended r
1
| r
ub forall a. Num a => a -> a -> a
- r
lb forall a. Eq a => a -> a -> Bool
== r
2 forall a. Num a => a -> a -> a
* forall a. Floating a => a
pi -> -Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..<= Extended r
1
| Bool
lbNorth, Bool
ubNorth, Extended r
clb forall a. Ord a => a -> a -> Bool
>= Extended r
cub -> forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (Extended r
cub, Boundary
in2) (Extended r
clb, Boundary
in1)
| Bool
lbNorth, Bool
ubNorth -> -Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..<= Extended r
1
| Bool
lbNorth -> forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (-Extended r
1, Boundary
Closed) forall a b. (a -> b) -> a -> b
$ case Extended r
clb forall a. Ord a => a -> a -> Ordering
`compare` Extended r
cub of
Ordering
LT -> (Extended r
cub, Boundary
in2)
Ordering
EQ -> (Extended r
cub, Boundary
in1 forall a. Ord a => a -> a -> a
`max` Boundary
in2)
Ordering
GT -> (Extended r
clb, Boundary
in1)
| Bool
ubNorth -> (forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
`interval` (Extended r
1, Boundary
Closed)) forall a b. (a -> b) -> a -> b
$ case Extended r
clb forall a. Ord a => a -> a -> Ordering
`compare` Extended r
cub of
Ordering
LT -> (Extended r
clb, Boundary
in1)
Ordering
EQ -> (Extended r
clb, Boundary
in1 forall a. Ord a => a -> a -> a
`max` Boundary
in2)
Ordering
GT -> (Extended r
cub, Boundary
in2)
| Extended r
clb forall a. Ord a => a -> a -> Bool
> Extended r
cub -> -Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..<= Extended r
1
| Bool
otherwise -> forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (Extended r
clb, Boundary
in1) (Extended r
cub, Boundary
in2)
where
mod2pi :: a -> a
mod2pi a
x = let y :: a
y = a
x forall a. Fractional a => a -> a -> a
/ (a
2 forall a. Num a => a -> a -> a
* forall a. Floating a => a
pi) in a
y forall a. Num a => a -> a -> a
- forall a. Num a => Integer -> a
fromInteger (forall a b. (RealFrac a, Integral b) => a -> b
floor a
y)
lbNorth :: Bool
lbNorth = (forall {a}. (RealFrac a, Floating a) => a -> a
mod2pi r
lb, Boundary
in1) forall a. Ord a => a -> a -> Bool
< (r
1 forall a. Fractional a => a -> a -> a
/ r
2, Boundary
Closed)
ubNorth :: Bool
ubNorth = (forall {a}. (RealFrac a, Floating a) => a -> a
mod2pi r
ub, Boundary
in2) forall a. Ord a => a -> a -> Bool
< (r
1 forall a. Fractional a => a -> a -> a
/ r
2, Boundary
Closed)
clb :: Extended r
clb = forall r. r -> Extended r
Finite (forall a. Floating a => a -> a
cos r
lb)
cub :: Extended r
cub = forall r. r -> Extended r
Finite (forall a. Floating a => a -> a
cos r
ub)
acos :: Interval r -> Interval r
acos = forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapAntiMonotonic forall a. Floating a => a -> a
acos forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r. Ord r => Interval r -> Interval r -> Interval r
intersection (-Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..<= Extended r
1)
sin :: Interval r -> Interval r
sin Interval r
a = forall a. Floating a => a -> a
cos (forall a. Floating a => a
pi forall a. Fractional a => a -> a -> a
/ Interval r
2 forall a. Num a => a -> a -> a
- Interval r
a)
asin :: Interval r -> Interval r
asin = forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic forall a. Floating a => a -> a
asin forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r. Ord r => Interval r -> Interval r -> Interval r
intersection (-Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..<= Extended r
1)
tan :: Interval r -> Interval r
tan Interval r
a = case forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
a of
(Extended r
NegInf, Boundary
_) -> forall r. Ord r => Interval r
whole
(Extended r
PosInf, Boundary
_) -> forall r. Ord r => Interval r
empty
(Finite r
lb, Boundary
in1) -> case forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
a of
(Extended r
NegInf, Boundary
_) -> forall r. Ord r => Interval r
empty
(Extended r
PosInf, Boundary
_) -> forall r. Ord r => Interval r
whole
(Finite r
ub, Boundary
in2)
| r
ub forall a. Num a => a -> a -> a
- r
lb forall a. Ord a => a -> a -> Bool
> forall a. Floating a => a
pi -> forall r. Ord r => Interval r
whole
| r
ub forall a. Num a => a -> a -> a
- r
lb forall a. Eq a => a -> a -> Bool
== forall a. Floating a => a
pi Bool -> Bool -> Bool
&& Boundary
in1 forall a. Eq a => a -> a -> Bool
== Boundary
Open Bool -> Bool -> Bool
&& Boundary
in2 forall a. Eq a => a -> a -> Bool
== Boundary
Open Bool -> Bool -> Bool
&& forall {a}. (RealFrac a, Floating a) => a -> a
modpi r
lb forall a. Eq a => a -> a -> Bool
/= r
1forall a. Fractional a => a -> a -> a
/r
2 -> forall r. Ord r => Interval r
whole
| r
ub forall a. Num a => a -> a -> a
- r
lb forall a. Eq a => a -> a -> Bool
== forall a. Floating a => a
pi -> forall r. Ord r => Interval r
whole
| forall a. Floating a => a -> a
tan r
lb forall a. Ord a => a -> a -> Bool
<= forall a. Floating a => a -> a
tan r
ub -> forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall r. r -> Extended r
Finite forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
tan r
lb, Boundary
in1) (forall r. r -> Extended r
Finite forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
tan r
ub, Boundary
in2)
| Bool
otherwise -> forall r. Ord r => Interval r
whole
where
modpi :: a -> a
modpi a
x = let y :: a
y = a
x forall a. Fractional a => a -> a -> a
/ forall a. Floating a => a
pi in a
y forall a. Num a => a -> a -> a
- forall a. Num a => Integer -> a
fromInteger (forall a b. (RealFrac a, Integral b) => a -> b
floor a
y)
atan :: Interval r -> Interval r
atan = forall r. Ord r => Interval r -> Interval r -> Interval r
intersection (forall r. r -> Extended r
Finite (-forall a. Floating a => a
pi forall a. Fractional a => a -> a -> a
/ r
2) forall r. Ord r => Extended r -> Extended r -> Interval r
<=..<= forall r. r -> Extended r
Finite (forall a. Floating a => a
pi forall a. Fractional a => a -> a -> a
/ r
2)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic forall a. Floating a => a -> a
atan
sinh :: Interval r -> Interval r
sinh = forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic forall a. Floating a => a -> a
sinh
asinh :: Interval r -> Interval r
asinh = forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic forall a. Floating a => a -> a
asinh
cosh :: Interval r -> Interval r
cosh = forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic forall a. Floating a => a -> a
cosh forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => a -> a
abs
acosh :: Interval r -> Interval r
acosh = forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic forall a. Floating a => a -> a
acosh forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r. Ord r => Interval r -> Interval r -> Interval r
intersection (Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<=..< forall r. Extended r
PosInf)
tanh :: Interval r -> Interval r
tanh = forall r. Ord r => Interval r -> Interval r -> Interval r
intersection (-Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<..< Extended r
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Ord a, Ord b) => (a -> b) -> Interval a -> Interval b
mapMonotonic forall a. Floating a => a -> a
tanh
atanh :: Interval r -> Interval r
atanh Interval r
a = forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Interval r
interval (forall r.
(Floating r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
atanhB (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
b)) (forall r.
(Floating r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
atanhB (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
b))
where
b :: Interval r
b = forall r. Ord r => Interval r -> Interval r -> Interval r
intersection (-Extended r
1 forall r. Ord r => Extended r -> Extended r -> Interval r
<..< Extended r
1) Interval r
a
positiveIntegralPowersOfNegativeValues
:: RealFrac r => Interval r -> Interval r -> Interval r
positiveIntegralPowersOfNegativeValues :: forall r. RealFrac r => Interval r -> Interval r -> Interval r
positiveIntegralPowersOfNegativeValues Interval r
a Interval r
b
| forall r. Ord r => Interval r -> Bool
null Interval r
a Bool -> Bool -> Bool
|| forall r. Ord r => Interval r -> Bool
null Interval r
b = forall r. Ord r => Interval r
empty
| Just Integer
ub <- Maybe Integer
mub, Integer
lb forall a. Ord a => a -> a -> Bool
> Integer
ub = forall r. Ord r => Interval r
empty
| Just Integer
ub <- Maybe Integer
mub, Integer
lb forall a. Eq a => a -> a -> Bool
== Integer
ub = Interval r
a forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
lb
| forall r. Interval r -> Extended r
lowerBound Interval r
a forall a. Ord a => a -> a -> Bool
>= -Extended r
1 = forall r. Ord r => Interval r -> Interval r -> Interval r
hull (Interval r
a forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
lb) (Interval r
a forall a b. (Num a, Integral b) => a -> b -> a
^ (Integer
lb forall a. Num a => a -> a -> a
+ Integer
1))
| Just Integer
ub <- Maybe Integer
mub = forall r. Ord r => Interval r -> Interval r -> Interval r
hull (Interval r
a forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
ub) (Interval r
a forall a b. (Num a, Integral b) => a -> b -> a
^ (Integer
ub forall a. Num a => a -> a -> a
- Integer
1))
| Maybe Integer
Nothing <- Maybe Integer
mub = forall r. Ord r => Interval r
whole
where
lb :: Integer
lb :: Integer
lb = case forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
b of
(Finite r
x, Boundary
Open)
| forall a. Num a => Integer -> a
fromInteger (forall a b. (RealFrac a, Integral b) => a -> b
ceiling r
x) forall a. Eq a => a -> a -> Bool
== r
x
-> forall a b. (RealFrac a, Integral b) => a -> b
ceiling r
x forall a. Num a => a -> a -> a
+ Integer
1
(Finite r
x, Boundary
_) -> forall a b. (RealFrac a, Integral b) => a -> b
ceiling r
x
(Extended r, Boundary)
_ -> Integer
0
mub :: Maybe Integer
mub :: Maybe Integer
mub = case forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
b of
(Finite r
x, Boundary
Open)
| forall a. Num a => Integer -> a
fromInteger (forall a b. (RealFrac a, Integral b) => a -> b
floor r
x) forall a. Eq a => a -> a -> Bool
== r
x
-> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
floor r
x forall a. Num a => a -> a -> a
- Integer
1
(Finite r
x, Boundary
_) -> forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a b. (RealFrac a, Integral b) => a -> b
floor r
x
(Extended r, Boundary)
_ -> forall a. Maybe a
Nothing
cmpUB, cmpLB :: Ord r => (Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
cmpUB :: forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
cmpUB (Extended r
x1,Boundary
in1) (Extended r
x2,Boundary
in2) = forall a. Ord a => a -> a -> Ordering
compare Extended r
x1 Extended r
x2 forall a. Monoid a => a -> a -> a
`mappend` forall a. Ord a => a -> a -> Ordering
compare Boundary
in1 Boundary
in2
cmpLB :: forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
cmpLB (Extended r
x1,Boundary
in1) (Extended r
x2,Boundary
in2) = forall a. Ord a => a -> a -> Ordering
compare Extended r
x1 Extended r
x2 forall a. Monoid a => a -> a -> a
`mappend` forall a. Ord a => a -> a -> Ordering
compare Boundary
in2 Boundary
in1
scaleInf' :: (Num r, Ord r) => r -> (Extended r, Boundary) -> (Extended r, Boundary)
scaleInf' :: forall r.
(Num r, Ord r) =>
r -> (Extended r, Boundary) -> (Extended r, Boundary)
scaleInf' r
a (Extended r
x1, Boundary
in1) = (forall r. (Num r, Ord r) => r -> Extended r -> Extended r
scaleEndPoint r
a Extended r
x1, Boundary
in1)
scaleEndPoint :: (Num r, Ord r) => r -> Extended r -> Extended r
scaleEndPoint :: forall r. (Num r, Ord r) => r -> Extended r -> Extended r
scaleEndPoint r
a Extended r
e =
case r
a forall a. Ord a => a -> a -> Ordering
`compare` r
0 of
Ordering
EQ -> Extended r
0
Ordering
GT ->
case Extended r
e of
Extended r
NegInf -> forall r. Extended r
NegInf
Finite r
b -> forall r. r -> Extended r
Finite (r
aforall a. Num a => a -> a -> a
*r
b)
Extended r
PosInf -> forall r. Extended r
PosInf
Ordering
LT ->
case Extended r
e of
Extended r
NegInf -> forall r. Extended r
PosInf
Finite r
b -> forall r. r -> Extended r
Finite (r
aforall a. Num a => a -> a -> a
*r
b)
Extended r
PosInf -> forall r. Extended r
NegInf
mulInf' :: (Num r, Ord r) => (Extended r, Boundary) -> (Extended r, Boundary) -> (Extended r, Boundary)
mulInf' :: forall {r}.
(Num r, Ord r) =>
(Extended r, Boundary)
-> (Extended r, Boundary) -> (Extended r, Boundary)
mulInf' (Extended r
0, Boundary
Closed) (Extended r, Boundary)
_ = (Extended r
0, Boundary
Closed)
mulInf' (Extended r, Boundary)
_ (Extended r
0, Boundary
Closed) = (Extended r
0, Boundary
Closed)
mulInf' (Extended r
x1,Boundary
in1) (Extended r
x2,Boundary
in2) = (Extended r
x1forall a. Num a => a -> a -> a
*Extended r
x2, Boundary
in1 forall a. Ord a => a -> a -> a
`min` Boundary
in2)
recipLB :: (Fractional r, Ord r) => (Extended r, Boundary) -> (Extended r, Boundary)
recipLB :: forall r.
(Fractional r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
recipLB (Extended r
0, Boundary
_) = (forall r. Extended r
PosInf, Boundary
Open)
recipLB (Extended r
x1, Boundary
in1) = (forall a. Fractional a => a -> a
recip Extended r
x1, Boundary
in1)
recipUB :: (Fractional r, Ord r) => (Extended r, Boundary) -> (Extended r, Boundary)
recipUB :: forall r.
(Fractional r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
recipUB (Extended r
0, Boundary
_) = (forall r. Extended r
NegInf, Boundary
Open)
recipUB (Extended r
x1, Boundary
in1) = (forall a. Fractional a => a -> a
recip Extended r
x1, Boundary
in1)
logB :: (Floating r, Ord r) => (Extended r, Boundary) -> (Extended r, Boundary)
logB :: forall r.
(Floating r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
logB (Extended r
NegInf, Boundary
in1) = (forall r. r -> Extended r
Finite forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
log (forall a. Floating a => a -> a
log r
0), Boundary
in1)
logB (Finite r
0, Boundary
_) = (forall r. Extended r
NegInf, Boundary
Open)
logB (Finite r
x1, Boundary
in1) = (forall r. r -> Extended r
Finite forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
log r
x1, Boundary
in1)
logB (Extended r
PosInf, Boundary
in1) = (forall r. Extended r
PosInf, Boundary
in1)
atanhB :: (Floating r, Ord r) => (Extended r, Boundary) -> (Extended r, Boundary)
atanhB :: forall r.
(Floating r, Ord r) =>
(Extended r, Boundary) -> (Extended r, Boundary)
atanhB (Extended r
NegInf, Boundary
in1) = (forall r. r -> Extended r
Finite forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
atanh (-r
1forall a. Fractional a => a -> a -> a
/r
0), Boundary
in1)
atanhB (Finite (-1), Boundary
_) = (forall r. Extended r
NegInf, Boundary
Open)
atanhB (Finite r
1, Boundary
_) = (forall r. Extended r
PosInf, Boundary
Open)
atanhB (Finite r
x1, Boundary
in1) = (forall r. r -> Extended r
Finite forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
atanh r
x1, Boundary
in1)
atanhB (Extended r
PosInf, Boundary
in1) = (forall r. r -> Extended r
Finite forall a b. (a -> b) -> a -> b
$ forall a. Floating a => a -> a
atanh (r
1forall a. Fractional a => a -> a -> a
/r
0), Boundary
in1)
relate :: Ord r => Interval r -> Interval r -> Relation
relate :: forall r. Ord r => Interval r -> Interval r -> Relation
relate Interval r
i1 Interval r
i2 =
case (Interval r
i1 forall r. Ord r => Interval r -> Interval r -> Bool
`isSubsetOf` Interval r
i2, Interval r
i2 forall r. Ord r => Interval r -> Interval r -> Bool
`isSubsetOf` Interval r
i1) of
(Bool
True , Bool
True ) -> Relation
Equal
(Bool
True , Bool
False) | forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
compareBound (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i2) forall a. Eq a => a -> a -> Bool
== Ordering
EQ -> Relation
Starts
| forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
compareBound (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i2) forall a. Eq a => a -> a -> Bool
== Ordering
EQ -> Relation
Finishes
| Bool
otherwise -> Relation
During
(Bool
False, Bool
True ) | forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
compareBound (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
lowerBound' Interval r
i2) forall a. Eq a => a -> a -> Bool
== Ordering
EQ -> Relation
StartedBy
| forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
compareBound (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i2) forall a. Eq a => a -> a -> Bool
== Ordering
EQ -> Relation
FinishedBy
| Bool
otherwise -> Relation
Contains
(Bool
False, Bool
False) -> case ( forall r. Ord r => Interval r -> Bool
null (Interval r
i1 forall r. Ord r => Interval r -> Interval r -> Interval r
`intersection` Interval r
i2)
, forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
compareBound (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i1) (forall r. Interval r -> (Extended r, Boundary)
upperBound' Interval r
i2) forall a. Ord a => a -> a -> Bool
<= Ordering
EQ
, Interval r
i1 forall r. Ord r => Interval r -> Interval r -> Bool
`isConnected` Interval r
i2
) of
(Bool
True , Bool
True , Bool
True ) -> Relation
JustBefore
(Bool
True , Bool
True , Bool
False) -> Relation
Before
(Bool
True , Bool
False, Bool
True ) -> Relation
JustAfter
(Bool
True , Bool
False, Bool
False) -> Relation
After
(Bool
False, Bool
True , Bool
_ ) -> Relation
Overlaps
(Bool
False, Bool
False, Bool
_ ) -> Relation
OverlappedBy
where
compareBound :: Ord r => (Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
compareBound :: forall r.
Ord r =>
(Extended r, Boundary) -> (Extended r, Boundary) -> Ordering
compareBound (Extended r
PosInf, Boundary
_) (Extended r
PosInf, Boundary
_) = Ordering
EQ
compareBound (Extended r
PosInf, Boundary
_) (Extended r, Boundary)
_ = Ordering
GT
compareBound (Extended r
NegInf, Boundary
_) (Extended r
NegInf, Boundary
_) = Ordering
EQ
compareBound (Extended r
NegInf, Boundary
_) (Extended r, Boundary)
_ = Ordering
LT
compareBound (Extended r, Boundary)
a (Extended r, Boundary)
b = forall a. Ord a => a -> a -> Ordering
compare (Extended r, Boundary)
a (Extended r, Boundary)
b