{- |
This module provides several ways to cope with over-determined values.
-}
module UniqueLogic.ST.Duplicate (
   C, accept,
   Ignore(Ignore),
   Forbid(Forbid),
   Verify(Verify),
   ) where


class C a where
   accept :: a -> a -> Bool

instance (C a, C b) => C (a, b) where
   accept :: (a, b) -> (a, b) -> Bool
accept (a
a0,b
b0) (a
a1,b
b1) =
      forall a. C a => a -> a -> Bool
accept a
a0 a
a1 Bool -> Bool -> Bool
&& forall a. C a => a -> a -> Bool
accept b
b0 b
b1

instance (C a, C b, C c) => C (a, b, c) where
   accept :: (a, b, c) -> (a, b, c) -> Bool
accept (a
a0,b
b0,c
c0) (a
a1,b
b1,c
c1) =
      forall a. C a => a -> a -> Bool
accept a
a0 a
a1 Bool -> Bool -> Bool
&& forall a. C a => a -> a -> Bool
accept b
b0 b
b1 Bool -> Bool -> Bool
&& forall a. C a => a -> a -> Bool
accept c
c0 c
c1


{- |
Ignore duplicate ways to determine a variable.
The chosen value depends on the particular algorithm.
-}
newtype Ignore a = Ignore a deriving (Ignore a -> Ignore a -> Bool
forall a. Eq a => Ignore a -> Ignore a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Ignore a -> Ignore a -> Bool
$c/= :: forall a. Eq a => Ignore a -> Ignore a -> Bool
== :: Ignore a -> Ignore a -> Bool
$c== :: forall a. Eq a => Ignore a -> Ignore a -> Bool
Eq, Ignore a -> Ignore a -> Bool
Ignore a -> Ignore a -> Ordering
Ignore a -> Ignore a -> Ignore a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Ignore a)
forall a. Ord a => Ignore a -> Ignore a -> Bool
forall a. Ord a => Ignore a -> Ignore a -> Ordering
forall a. Ord a => Ignore a -> Ignore a -> Ignore a
min :: Ignore a -> Ignore a -> Ignore a
$cmin :: forall a. Ord a => Ignore a -> Ignore a -> Ignore a
max :: Ignore a -> Ignore a -> Ignore a
$cmax :: forall a. Ord a => Ignore a -> Ignore a -> Ignore a
>= :: Ignore a -> Ignore a -> Bool
$c>= :: forall a. Ord a => Ignore a -> Ignore a -> Bool
> :: Ignore a -> Ignore a -> Bool
$c> :: forall a. Ord a => Ignore a -> Ignore a -> Bool
<= :: Ignore a -> Ignore a -> Bool
$c<= :: forall a. Ord a => Ignore a -> Ignore a -> Bool
< :: Ignore a -> Ignore a -> Bool
$c< :: forall a. Ord a => Ignore a -> Ignore a -> Bool
compare :: Ignore a -> Ignore a -> Ordering
$ccompare :: forall a. Ord a => Ignore a -> Ignore a -> Ordering
Ord, Int -> Ignore a -> ShowS
forall a. Show a => Int -> Ignore a -> ShowS
forall a. Show a => [Ignore a] -> ShowS
forall a. Show a => Ignore a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Ignore a] -> ShowS
$cshowList :: forall a. Show a => [Ignore a] -> ShowS
show :: Ignore a -> String
$cshow :: forall a. Show a => Ignore a -> String
showsPrec :: Int -> Ignore a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Ignore a -> ShowS
Show)

instance C (Ignore a) where accept :: Ignore a -> Ignore a -> Bool
accept Ignore a
_ Ignore a
_ = Bool
True

ignore1 :: (a -> b) -> Ignore a -> Ignore b
ignore1 :: forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 a -> b
f (Ignore a
x) = forall a. a -> Ignore a
Ignore forall a b. (a -> b) -> a -> b
$ a -> b
f a
x

ignore2 :: (a -> b -> c) -> Ignore a -> Ignore b -> Ignore c
ignore2 :: forall a b c. (a -> b -> c) -> Ignore a -> Ignore b -> Ignore c
ignore2 a -> b -> c
f (Ignore a
x) (Ignore b
y) = forall a. a -> Ignore a
Ignore forall a b. (a -> b) -> a -> b
$ a -> b -> c
f a
x b
y

instance Num a => Num (Ignore a) where
   fromInteger :: Integer -> Ignore a
fromInteger = forall a. a -> Ignore a
Ignore forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => Integer -> a
fromInteger
   + :: Ignore a -> Ignore a -> Ignore a
(+) = forall a b c. (a -> b -> c) -> Ignore a -> Ignore b -> Ignore c
ignore2 forall a. Num a => a -> a -> a
(+)
   (-) = forall a b c. (a -> b -> c) -> Ignore a -> Ignore b -> Ignore c
ignore2 (-)
   * :: Ignore a -> Ignore a -> Ignore a
(*) = forall a b c. (a -> b -> c) -> Ignore a -> Ignore b -> Ignore c
ignore2 forall a. Num a => a -> a -> a
(*)
   abs :: Ignore a -> Ignore a
abs = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Num a => a -> a
abs
   signum :: Ignore a -> Ignore a
signum = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Num a => a -> a
signum

instance Fractional a => Fractional (Ignore a) where
   fromRational :: Rational -> Ignore a
fromRational = forall a. a -> Ignore a
Ignore forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Fractional a => Rational -> a
fromRational
   / :: Ignore a -> Ignore a -> Ignore a
(/) = forall a b c. (a -> b -> c) -> Ignore a -> Ignore b -> Ignore c
ignore2 forall a. Fractional a => a -> a -> a
(/)

instance Floating a => Floating (Ignore a) where
   pi :: Ignore a
pi = forall a. a -> Ignore a
Ignore forall a. Floating a => a
pi
   exp :: Ignore a -> Ignore a
exp = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
exp
   sqrt :: Ignore a -> Ignore a
sqrt = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
sqrt
   log :: Ignore a -> Ignore a
log = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
log
   ** :: Ignore a -> Ignore a -> Ignore a
(**) = forall a b c. (a -> b -> c) -> Ignore a -> Ignore b -> Ignore c
ignore2 forall a. Floating a => a -> a -> a
(**)
   logBase :: Ignore a -> Ignore a -> Ignore a
logBase = forall a b c. (a -> b -> c) -> Ignore a -> Ignore b -> Ignore c
ignore2 forall a. Floating a => a -> a -> a
logBase
   sin :: Ignore a -> Ignore a
sin = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
sin
   tan :: Ignore a -> Ignore a
tan = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
tan
   cos :: Ignore a -> Ignore a
cos = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
cos
   asin :: Ignore a -> Ignore a
asin = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
asin
   atan :: Ignore a -> Ignore a
atan = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
atan
   acos :: Ignore a -> Ignore a
acos = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
acos
   sinh :: Ignore a -> Ignore a
sinh = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
sinh
   tanh :: Ignore a -> Ignore a
tanh = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
tanh
   cosh :: Ignore a -> Ignore a
cosh = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
cosh
   asinh :: Ignore a -> Ignore a
asinh = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
asinh
   atanh :: Ignore a -> Ignore a
atanh = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
atanh
   acosh :: Ignore a -> Ignore a
acosh = forall a b. (a -> b) -> Ignore a -> Ignore b
ignore1 forall a. Floating a => a -> a
acosh



{- |
Duplicate ways to determine a variable value
are always considered an error.
If you use @Rule@s or @Expression@s this is not a good idea,
since every rule is over-determined.
-}
newtype Forbid a = Forbid a deriving (Forbid a -> Forbid a -> Bool
forall a. Eq a => Forbid a -> Forbid a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Forbid a -> Forbid a -> Bool
$c/= :: forall a. Eq a => Forbid a -> Forbid a -> Bool
== :: Forbid a -> Forbid a -> Bool
$c== :: forall a. Eq a => Forbid a -> Forbid a -> Bool
Eq, Forbid a -> Forbid a -> Bool
Forbid a -> Forbid a -> Ordering
Forbid a -> Forbid a -> Forbid a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Forbid a)
forall a. Ord a => Forbid a -> Forbid a -> Bool
forall a. Ord a => Forbid a -> Forbid a -> Ordering
forall a. Ord a => Forbid a -> Forbid a -> Forbid a
min :: Forbid a -> Forbid a -> Forbid a
$cmin :: forall a. Ord a => Forbid a -> Forbid a -> Forbid a
max :: Forbid a -> Forbid a -> Forbid a
$cmax :: forall a. Ord a => Forbid a -> Forbid a -> Forbid a
>= :: Forbid a -> Forbid a -> Bool
$c>= :: forall a. Ord a => Forbid a -> Forbid a -> Bool
> :: Forbid a -> Forbid a -> Bool
$c> :: forall a. Ord a => Forbid a -> Forbid a -> Bool
<= :: Forbid a -> Forbid a -> Bool
$c<= :: forall a. Ord a => Forbid a -> Forbid a -> Bool
< :: Forbid a -> Forbid a -> Bool
$c< :: forall a. Ord a => Forbid a -> Forbid a -> Bool
compare :: Forbid a -> Forbid a -> Ordering
$ccompare :: forall a. Ord a => Forbid a -> Forbid a -> Ordering
Ord, Int -> Forbid a -> ShowS
forall a. Show a => Int -> Forbid a -> ShowS
forall a. Show a => [Forbid a] -> ShowS
forall a. Show a => Forbid a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Forbid a] -> ShowS
$cshowList :: forall a. Show a => [Forbid a] -> ShowS
show :: Forbid a -> String
$cshow :: forall a. Show a => Forbid a -> String
showsPrec :: Int -> Forbid a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Forbid a -> ShowS
Show)

instance C (Forbid a) where accept :: Forbid a -> Forbid a -> Bool
accept Forbid a
_ Forbid a
_ = Bool
False

forbid1 :: (a -> b) -> Forbid a -> Forbid b
forbid1 :: forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 a -> b
f (Forbid a
x) = forall a. a -> Forbid a
Forbid forall a b. (a -> b) -> a -> b
$ a -> b
f a
x

forbid2 :: (a -> b -> c) -> Forbid a -> Forbid b -> Forbid c
forbid2 :: forall a b c. (a -> b -> c) -> Forbid a -> Forbid b -> Forbid c
forbid2 a -> b -> c
f (Forbid a
x) (Forbid b
y) = forall a. a -> Forbid a
Forbid forall a b. (a -> b) -> a -> b
$ a -> b -> c
f a
x b
y

instance Num a => Num (Forbid a) where
   fromInteger :: Integer -> Forbid a
fromInteger = forall a. a -> Forbid a
Forbid forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => Integer -> a
fromInteger
   + :: Forbid a -> Forbid a -> Forbid a
(+) = forall a b c. (a -> b -> c) -> Forbid a -> Forbid b -> Forbid c
forbid2 forall a. Num a => a -> a -> a
(+)
   (-) = forall a b c. (a -> b -> c) -> Forbid a -> Forbid b -> Forbid c
forbid2 (-)
   * :: Forbid a -> Forbid a -> Forbid a
(*) = forall a b c. (a -> b -> c) -> Forbid a -> Forbid b -> Forbid c
forbid2 forall a. Num a => a -> a -> a
(*)
   abs :: Forbid a -> Forbid a
abs = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Num a => a -> a
abs
   signum :: Forbid a -> Forbid a
signum = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Num a => a -> a
signum

instance Fractional a => Fractional (Forbid a) where
   fromRational :: Rational -> Forbid a
fromRational = forall a. a -> Forbid a
Forbid forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Fractional a => Rational -> a
fromRational
   / :: Forbid a -> Forbid a -> Forbid a
(/) = forall a b c. (a -> b -> c) -> Forbid a -> Forbid b -> Forbid c
forbid2 forall a. Fractional a => a -> a -> a
(/)

instance Floating a => Floating (Forbid a) where
   pi :: Forbid a
pi = forall a. a -> Forbid a
Forbid forall a. Floating a => a
pi
   exp :: Forbid a -> Forbid a
exp = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
exp
   sqrt :: Forbid a -> Forbid a
sqrt = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
sqrt
   log :: Forbid a -> Forbid a
log = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
log
   ** :: Forbid a -> Forbid a -> Forbid a
(**) = forall a b c. (a -> b -> c) -> Forbid a -> Forbid b -> Forbid c
forbid2 forall a. Floating a => a -> a -> a
(**)
   logBase :: Forbid a -> Forbid a -> Forbid a
logBase = forall a b c. (a -> b -> c) -> Forbid a -> Forbid b -> Forbid c
forbid2 forall a. Floating a => a -> a -> a
logBase
   sin :: Forbid a -> Forbid a
sin = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
sin
   tan :: Forbid a -> Forbid a
tan = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
tan
   cos :: Forbid a -> Forbid a
cos = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
cos
   asin :: Forbid a -> Forbid a
asin = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
asin
   atan :: Forbid a -> Forbid a
atan = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
atan
   acos :: Forbid a -> Forbid a
acos = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
acos
   sinh :: Forbid a -> Forbid a
sinh = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
sinh
   tanh :: Forbid a -> Forbid a
tanh = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
tanh
   cosh :: Forbid a -> Forbid a
cosh = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
cosh
   asinh :: Forbid a -> Forbid a
asinh = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
asinh
   atanh :: Forbid a -> Forbid a
atanh = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
atanh
   acosh :: Forbid a -> Forbid a
acosh = forall a b. (a -> b) -> Forbid a -> Forbid b
forbid1 forall a. Floating a => a -> a
acosh


{- |
Duplicate ways to determine a variable value are allowed
as long as every way yields the same result.
\"Same\" is meant with respect to the 'Eq' class.
-}
newtype Verify a = Verify a deriving (Verify a -> Verify a -> Bool
forall a. Eq a => Verify a -> Verify a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Verify a -> Verify a -> Bool
$c/= :: forall a. Eq a => Verify a -> Verify a -> Bool
== :: Verify a -> Verify a -> Bool
$c== :: forall a. Eq a => Verify a -> Verify a -> Bool
Eq, Verify a -> Verify a -> Bool
Verify a -> Verify a -> Ordering
Verify a -> Verify a -> Verify a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {a}. Ord a => Eq (Verify a)
forall a. Ord a => Verify a -> Verify a -> Bool
forall a. Ord a => Verify a -> Verify a -> Ordering
forall a. Ord a => Verify a -> Verify a -> Verify a
min :: Verify a -> Verify a -> Verify a
$cmin :: forall a. Ord a => Verify a -> Verify a -> Verify a
max :: Verify a -> Verify a -> Verify a
$cmax :: forall a. Ord a => Verify a -> Verify a -> Verify a
>= :: Verify a -> Verify a -> Bool
$c>= :: forall a. Ord a => Verify a -> Verify a -> Bool
> :: Verify a -> Verify a -> Bool
$c> :: forall a. Ord a => Verify a -> Verify a -> Bool
<= :: Verify a -> Verify a -> Bool
$c<= :: forall a. Ord a => Verify a -> Verify a -> Bool
< :: Verify a -> Verify a -> Bool
$c< :: forall a. Ord a => Verify a -> Verify a -> Bool
compare :: Verify a -> Verify a -> Ordering
$ccompare :: forall a. Ord a => Verify a -> Verify a -> Ordering
Ord, Int -> Verify a -> ShowS
forall a. Show a => Int -> Verify a -> ShowS
forall a. Show a => [Verify a] -> ShowS
forall a. Show a => Verify a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Verify a] -> ShowS
$cshowList :: forall a. Show a => [Verify a] -> ShowS
show :: Verify a -> String
$cshow :: forall a. Show a => Verify a -> String
showsPrec :: Int -> Verify a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Verify a -> ShowS
Show)

instance Eq a => C (Verify a) where accept :: Verify a -> Verify a -> Bool
accept (Verify a
x) (Verify a
y) = a
xforall a. Eq a => a -> a -> Bool
==a
y

verify1 :: (a -> b) -> Verify a -> Verify b
verify1 :: forall a b. (a -> b) -> Verify a -> Verify b
verify1 a -> b
f (Verify a
x) = forall a. a -> Verify a
Verify forall a b. (a -> b) -> a -> b
$ a -> b
f a
x

verify2 :: (a -> b -> c) -> Verify a -> Verify b -> Verify c
verify2 :: forall a b c. (a -> b -> c) -> Verify a -> Verify b -> Verify c
verify2 a -> b -> c
f (Verify a
x) (Verify b
y) = forall a. a -> Verify a
Verify forall a b. (a -> b) -> a -> b
$ a -> b -> c
f a
x b
y

instance Num a => Num (Verify a) where
   fromInteger :: Integer -> Verify a
fromInteger = forall a. a -> Verify a
Verify forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Num a => Integer -> a
fromInteger
   + :: Verify a -> Verify a -> Verify a
(+) = forall a b c. (a -> b -> c) -> Verify a -> Verify b -> Verify c
verify2 forall a. Num a => a -> a -> a
(+)
   (-) = forall a b c. (a -> b -> c) -> Verify a -> Verify b -> Verify c
verify2 (-)
   * :: Verify a -> Verify a -> Verify a
(*) = forall a b c. (a -> b -> c) -> Verify a -> Verify b -> Verify c
verify2 forall a. Num a => a -> a -> a
(*)
   abs :: Verify a -> Verify a
abs = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Num a => a -> a
abs
   signum :: Verify a -> Verify a
signum = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Num a => a -> a
signum

instance Fractional a => Fractional (Verify a) where
   fromRational :: Rational -> Verify a
fromRational = forall a. a -> Verify a
Verify forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Fractional a => Rational -> a
fromRational
   / :: Verify a -> Verify a -> Verify a
(/) = forall a b c. (a -> b -> c) -> Verify a -> Verify b -> Verify c
verify2 forall a. Fractional a => a -> a -> a
(/)

instance Floating a => Floating (Verify a) where
   pi :: Verify a
pi = forall a. a -> Verify a
Verify forall a. Floating a => a
pi
   exp :: Verify a -> Verify a
exp = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
exp
   sqrt :: Verify a -> Verify a
sqrt = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
sqrt
   log :: Verify a -> Verify a
log = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
log
   ** :: Verify a -> Verify a -> Verify a
(**) = forall a b c. (a -> b -> c) -> Verify a -> Verify b -> Verify c
verify2 forall a. Floating a => a -> a -> a
(**)
   logBase :: Verify a -> Verify a -> Verify a
logBase = forall a b c. (a -> b -> c) -> Verify a -> Verify b -> Verify c
verify2 forall a. Floating a => a -> a -> a
logBase
   sin :: Verify a -> Verify a
sin = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
sin
   tan :: Verify a -> Verify a
tan = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
tan
   cos :: Verify a -> Verify a
cos = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
cos
   asin :: Verify a -> Verify a
asin = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
asin
   atan :: Verify a -> Verify a
atan = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
atan
   acos :: Verify a -> Verify a
acos = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
acos
   sinh :: Verify a -> Verify a
sinh = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
sinh
   tanh :: Verify a -> Verify a
tanh = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
tanh
   cosh :: Verify a -> Verify a
cosh = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
cosh
   asinh :: Verify a -> Verify a
asinh = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
asinh
   atanh :: Verify a -> Verify a
atanh = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
atanh
   acosh :: Verify a -> Verify a
acosh = forall a b. (a -> b) -> Verify a -> Verify b
verify1 forall a. Floating a => a -> a
acosh