{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings          #-}

module Q.Types (
    Observables1(..)
  , Observables2(..)
  , Observables3(..)
  , Observables4(..)
  , Observables5(..)
  , OptionType(..)
  , Cash(..)
  , Spot(..)
  , Obs1(..)
  , Obs2(..)
  , Obs3(..)
  , Obs4(..)
  , Obs5(..)
  , Strike(..)
  , Forward(..)
  , Premium(..)
  , Delta(..)
  , Vega(..)
  , Gamma(..)
  , Expiry(..)
  , YearFrac(..)
  , Rate(..)
  , DF(..)
  , Vol(..)
  , TotalVar(..)
  , TimeScaleable(..)
  , cpi
  , discountFactor
  , discount
  , undiscount
  , rateFromDiscount
  , totalVarToVol
  , volToTotalVar
  , ($*$)
  , ($/$)
  , ($+$)
  ) where

import qualified Data.ByteString as B
import           Data.Csv        (FromField (..), ToField (..))
import           Data.Time
import           GHC.Generics    (Generic)
import           Q.Time
import           Q.Time.Date
import Foreign (Storable)
import Numeric.LinearAlgebra (Element(..))
import Data.Coerce
-- | Type for Put or Calls
data OptionType  = Put | Call deriving ((forall x. OptionType -> Rep OptionType x)
-> (forall x. Rep OptionType x -> OptionType) -> Generic OptionType
forall x. Rep OptionType x -> OptionType
forall x. OptionType -> Rep OptionType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OptionType x -> OptionType
$cfrom :: forall x. OptionType -> Rep OptionType x
Generic, OptionType -> OptionType -> Bool
(OptionType -> OptionType -> Bool)
-> (OptionType -> OptionType -> Bool) -> Eq OptionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OptionType -> OptionType -> Bool
$c/= :: OptionType -> OptionType -> Bool
== :: OptionType -> OptionType -> Bool
$c== :: OptionType -> OptionType -> Bool
Eq, Int -> OptionType -> ShowS
[OptionType] -> ShowS
OptionType -> String
(Int -> OptionType -> ShowS)
-> (OptionType -> String)
-> ([OptionType] -> ShowS)
-> Show OptionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OptionType] -> ShowS
$cshowList :: [OptionType] -> ShowS
show :: OptionType -> String
$cshow :: OptionType -> String
showsPrec :: Int -> OptionType -> ShowS
$cshowsPrec :: Int -> OptionType -> ShowS
Show, ReadPrec [OptionType]
ReadPrec OptionType
Int -> ReadS OptionType
ReadS [OptionType]
(Int -> ReadS OptionType)
-> ReadS [OptionType]
-> ReadPrec OptionType
-> ReadPrec [OptionType]
-> Read OptionType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [OptionType]
$creadListPrec :: ReadPrec [OptionType]
readPrec :: ReadPrec OptionType
$creadPrec :: ReadPrec OptionType
readList :: ReadS [OptionType]
$creadList :: ReadS [OptionType]
readsPrec :: Int -> ReadS OptionType
$creadsPrec :: Int -> ReadS OptionType
Read, OptionType
OptionType -> OptionType -> Bounded OptionType
forall a. a -> a -> Bounded a
maxBound :: OptionType
$cmaxBound :: OptionType
minBound :: OptionType
$cminBound :: OptionType
Bounded)
instance Enum OptionType where
  succ :: OptionType -> OptionType
succ OptionType
Call = OptionType
Put
  succ OptionType
Put  = OptionType
Call

  pred :: OptionType -> OptionType
pred = OptionType -> OptionType
forall a. Enum a => a -> a
succ
  toEnum :: Int -> OptionType
toEnum Int
x = if Int -> Int
forall a. Num a => a -> a
signum Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 then OptionType
Call else OptionType
Put
  fromEnum :: OptionType -> Int
fromEnum OptionType
Call = Int
1
  fromEnum OptionType
Put  = -Int
1


cpi :: OptionType -> p
cpi OptionType
Call = p
1
cpi OptionType
Put  = -p
1

newtype Cash     = Cash    Double deriving ((forall x. Cash -> Rep Cash x)
-> (forall x. Rep Cash x -> Cash) -> Generic Cash
forall x. Rep Cash x -> Cash
forall x. Cash -> Rep Cash x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Cash x -> Cash
$cfrom :: forall x. Cash -> Rep Cash x
Generic, Cash -> Cash -> Bool
(Cash -> Cash -> Bool) -> (Cash -> Cash -> Bool) -> Eq Cash
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cash -> Cash -> Bool
$c/= :: Cash -> Cash -> Bool
== :: Cash -> Cash -> Bool
$c== :: Cash -> Cash -> Bool
Eq, Int -> Cash -> ShowS
[Cash] -> ShowS
Cash -> String
(Int -> Cash -> ShowS)
-> (Cash -> String) -> ([Cash] -> ShowS) -> Show Cash
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Cash] -> ShowS
$cshowList :: [Cash] -> ShowS
show :: Cash -> String
$cshow :: Cash -> String
showsPrec :: Int -> Cash -> ShowS
$cshowsPrec :: Int -> Cash -> ShowS
Show, ReadPrec [Cash]
ReadPrec Cash
Int -> ReadS Cash
ReadS [Cash]
(Int -> ReadS Cash)
-> ReadS [Cash] -> ReadPrec Cash -> ReadPrec [Cash] -> Read Cash
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Cash]
$creadListPrec :: ReadPrec [Cash]
readPrec :: ReadPrec Cash
$creadPrec :: ReadPrec Cash
readList :: ReadS [Cash]
$creadList :: ReadS [Cash]
readsPrec :: Int -> ReadS Cash
$creadsPrec :: Int -> ReadS Cash
Read, Eq Cash
Eq Cash
-> (Cash -> Cash -> Ordering)
-> (Cash -> Cash -> Bool)
-> (Cash -> Cash -> Bool)
-> (Cash -> Cash -> Bool)
-> (Cash -> Cash -> Bool)
-> (Cash -> Cash -> Cash)
-> (Cash -> Cash -> Cash)
-> Ord Cash
Cash -> Cash -> Bool
Cash -> Cash -> Ordering
Cash -> Cash -> Cash
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
min :: Cash -> Cash -> Cash
$cmin :: Cash -> Cash -> Cash
max :: Cash -> Cash -> Cash
$cmax :: Cash -> Cash -> Cash
>= :: Cash -> Cash -> Bool
$c>= :: Cash -> Cash -> Bool
> :: Cash -> Cash -> Bool
$c> :: Cash -> Cash -> Bool
<= :: Cash -> Cash -> Bool
$c<= :: Cash -> Cash -> Bool
< :: Cash -> Cash -> Bool
$c< :: Cash -> Cash -> Bool
compare :: Cash -> Cash -> Ordering
$ccompare :: Cash -> Cash -> Ordering
$cp1Ord :: Eq Cash
Ord, Integer -> Cash
Cash -> Cash
Cash -> Cash -> Cash
(Cash -> Cash -> Cash)
-> (Cash -> Cash -> Cash)
-> (Cash -> Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Integer -> Cash)
-> Num Cash
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Cash
$cfromInteger :: Integer -> Cash
signum :: Cash -> Cash
$csignum :: Cash -> Cash
abs :: Cash -> Cash
$cabs :: Cash -> Cash
negate :: Cash -> Cash
$cnegate :: Cash -> Cash
* :: Cash -> Cash -> Cash
$c* :: Cash -> Cash -> Cash
- :: Cash -> Cash -> Cash
$c- :: Cash -> Cash -> Cash
+ :: Cash -> Cash -> Cash
$c+ :: Cash -> Cash -> Cash
Num, Num Cash
Num Cash
-> (Cash -> Cash -> Cash)
-> (Cash -> Cash)
-> (Rational -> Cash)
-> Fractional Cash
Rational -> Cash
Cash -> Cash
Cash -> Cash -> Cash
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Cash
$cfromRational :: Rational -> Cash
recip :: Cash -> Cash
$crecip :: Cash -> Cash
/ :: Cash -> Cash -> Cash
$c/ :: Cash -> Cash -> Cash
$cp1Fractional :: Num Cash
Fractional, Num Cash
Ord Cash
Num Cash -> Ord Cash -> (Cash -> Rational) -> Real Cash
Cash -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Cash -> Rational
$ctoRational :: Cash -> Rational
$cp2Real :: Ord Cash
$cp1Real :: Num Cash
Real, Fractional Cash
Real Cash
Real Cash
-> Fractional Cash
-> (forall b. Integral b => Cash -> (b, Cash))
-> (forall b. Integral b => Cash -> b)
-> (forall b. Integral b => Cash -> b)
-> (forall b. Integral b => Cash -> b)
-> (forall b. Integral b => Cash -> b)
-> RealFrac Cash
Cash -> b
Cash -> b
Cash -> b
Cash -> b
Cash -> (b, Cash)
forall b. Integral b => Cash -> b
forall b. Integral b => Cash -> (b, Cash)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Cash -> b
$cfloor :: forall b. Integral b => Cash -> b
ceiling :: Cash -> b
$cceiling :: forall b. Integral b => Cash -> b
round :: Cash -> b
$cround :: forall b. Integral b => Cash -> b
truncate :: Cash -> b
$ctruncate :: forall b. Integral b => Cash -> b
properFraction :: Cash -> (b, Cash)
$cproperFraction :: forall b. Integral b => Cash -> (b, Cash)
$cp2RealFrac :: Fractional Cash
$cp1RealFrac :: Real Cash
RealFrac, Floating Cash
RealFrac Cash
RealFrac Cash
-> Floating Cash
-> (Cash -> Integer)
-> (Cash -> Int)
-> (Cash -> (Int, Int))
-> (Cash -> (Integer, Int))
-> (Integer -> Int -> Cash)
-> (Cash -> Int)
-> (Cash -> Cash)
-> (Int -> Cash -> Cash)
-> (Cash -> Bool)
-> (Cash -> Bool)
-> (Cash -> Bool)
-> (Cash -> Bool)
-> (Cash -> Bool)
-> (Cash -> Cash -> Cash)
-> RealFloat Cash
Int -> Cash -> Cash
Integer -> Int -> Cash
Cash -> Bool
Cash -> Int
Cash -> Integer
Cash -> (Int, Int)
Cash -> (Integer, Int)
Cash -> Cash
Cash -> Cash -> Cash
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Cash -> Cash -> Cash
$catan2 :: Cash -> Cash -> Cash
isIEEE :: Cash -> Bool
$cisIEEE :: Cash -> Bool
isNegativeZero :: Cash -> Bool
$cisNegativeZero :: Cash -> Bool
isDenormalized :: Cash -> Bool
$cisDenormalized :: Cash -> Bool
isInfinite :: Cash -> Bool
$cisInfinite :: Cash -> Bool
isNaN :: Cash -> Bool
$cisNaN :: Cash -> Bool
scaleFloat :: Int -> Cash -> Cash
$cscaleFloat :: Int -> Cash -> Cash
significand :: Cash -> Cash
$csignificand :: Cash -> Cash
exponent :: Cash -> Int
$cexponent :: Cash -> Int
encodeFloat :: Integer -> Int -> Cash
$cencodeFloat :: Integer -> Int -> Cash
decodeFloat :: Cash -> (Integer, Int)
$cdecodeFloat :: Cash -> (Integer, Int)
floatRange :: Cash -> (Int, Int)
$cfloatRange :: Cash -> (Int, Int)
floatDigits :: Cash -> Int
$cfloatDigits :: Cash -> Int
floatRadix :: Cash -> Integer
$cfloatRadix :: Cash -> Integer
$cp2RealFloat :: Floating Cash
$cp1RealFloat :: RealFrac Cash
RealFloat, Fractional Cash
Cash
Fractional Cash
-> Cash
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash -> Cash)
-> (Cash -> Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> (Cash -> Cash)
-> Floating Cash
Cash -> Cash
Cash -> Cash -> Cash
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Cash -> Cash
$clog1mexp :: Cash -> Cash
log1pexp :: Cash -> Cash
$clog1pexp :: Cash -> Cash
expm1 :: Cash -> Cash
$cexpm1 :: Cash -> Cash
log1p :: Cash -> Cash
$clog1p :: Cash -> Cash
atanh :: Cash -> Cash
$catanh :: Cash -> Cash
acosh :: Cash -> Cash
$cacosh :: Cash -> Cash
asinh :: Cash -> Cash
$casinh :: Cash -> Cash
tanh :: Cash -> Cash
$ctanh :: Cash -> Cash
cosh :: Cash -> Cash
$ccosh :: Cash -> Cash
sinh :: Cash -> Cash
$csinh :: Cash -> Cash
atan :: Cash -> Cash
$catan :: Cash -> Cash
acos :: Cash -> Cash
$cacos :: Cash -> Cash
asin :: Cash -> Cash
$casin :: Cash -> Cash
tan :: Cash -> Cash
$ctan :: Cash -> Cash
cos :: Cash -> Cash
$ccos :: Cash -> Cash
sin :: Cash -> Cash
$csin :: Cash -> Cash
logBase :: Cash -> Cash -> Cash
$clogBase :: Cash -> Cash -> Cash
** :: Cash -> Cash -> Cash
$c** :: Cash -> Cash -> Cash
sqrt :: Cash -> Cash
$csqrt :: Cash -> Cash
log :: Cash -> Cash
$clog :: Cash -> Cash
exp :: Cash -> Cash
$cexp :: Cash -> Cash
pi :: Cash
$cpi :: Cash
$cp1Floating :: Fractional Cash
Floating, Ptr b -> Int -> IO Cash
Ptr b -> Int -> Cash -> IO ()
Ptr Cash -> IO Cash
Ptr Cash -> Int -> IO Cash
Ptr Cash -> Int -> Cash -> IO ()
Ptr Cash -> Cash -> IO ()
Cash -> Int
(Cash -> Int)
-> (Cash -> Int)
-> (Ptr Cash -> Int -> IO Cash)
-> (Ptr Cash -> Int -> Cash -> IO ())
-> (forall b. Ptr b -> Int -> IO Cash)
-> (forall b. Ptr b -> Int -> Cash -> IO ())
-> (Ptr Cash -> IO Cash)
-> (Ptr Cash -> Cash -> IO ())
-> Storable Cash
forall b. Ptr b -> Int -> IO Cash
forall b. Ptr b -> Int -> Cash -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Cash -> Cash -> IO ()
$cpoke :: Ptr Cash -> Cash -> IO ()
peek :: Ptr Cash -> IO Cash
$cpeek :: Ptr Cash -> IO Cash
pokeByteOff :: Ptr b -> Int -> Cash -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Cash -> IO ()
peekByteOff :: Ptr b -> Int -> IO Cash
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Cash
pokeElemOff :: Ptr Cash -> Int -> Cash -> IO ()
$cpokeElemOff :: Ptr Cash -> Int -> Cash -> IO ()
peekElemOff :: Ptr Cash -> Int -> IO Cash
$cpeekElemOff :: Ptr Cash -> Int -> IO Cash
alignment :: Cash -> Int
$calignment :: Cash -> Int
sizeOf :: Cash -> Int
$csizeOf :: Cash -> Int
Storable) 

newtype Spot     = Spot    Double deriving ((forall x. Spot -> Rep Spot x)
-> (forall x. Rep Spot x -> Spot) -> Generic Spot
forall x. Rep Spot x -> Spot
forall x. Spot -> Rep Spot x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Spot x -> Spot
$cfrom :: forall x. Spot -> Rep Spot x
Generic, Spot -> Spot -> Bool
(Spot -> Spot -> Bool) -> (Spot -> Spot -> Bool) -> Eq Spot
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Spot -> Spot -> Bool
$c/= :: Spot -> Spot -> Bool
== :: Spot -> Spot -> Bool
$c== :: Spot -> Spot -> Bool
Eq, Int -> Spot -> ShowS
[Spot] -> ShowS
Spot -> String
(Int -> Spot -> ShowS)
-> (Spot -> String) -> ([Spot] -> ShowS) -> Show Spot
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Spot] -> ShowS
$cshowList :: [Spot] -> ShowS
show :: Spot -> String
$cshow :: Spot -> String
showsPrec :: Int -> Spot -> ShowS
$cshowsPrec :: Int -> Spot -> ShowS
Show, ReadPrec [Spot]
ReadPrec Spot
Int -> ReadS Spot
ReadS [Spot]
(Int -> ReadS Spot)
-> ReadS [Spot] -> ReadPrec Spot -> ReadPrec [Spot] -> Read Spot
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Spot]
$creadListPrec :: ReadPrec [Spot]
readPrec :: ReadPrec Spot
$creadPrec :: ReadPrec Spot
readList :: ReadS [Spot]
$creadList :: ReadS [Spot]
readsPrec :: Int -> ReadS Spot
$creadsPrec :: Int -> ReadS Spot
Read, Eq Spot
Eq Spot
-> (Spot -> Spot -> Ordering)
-> (Spot -> Spot -> Bool)
-> (Spot -> Spot -> Bool)
-> (Spot -> Spot -> Bool)
-> (Spot -> Spot -> Bool)
-> (Spot -> Spot -> Spot)
-> (Spot -> Spot -> Spot)
-> Ord Spot
Spot -> Spot -> Bool
Spot -> Spot -> Ordering
Spot -> Spot -> Spot
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
min :: Spot -> Spot -> Spot
$cmin :: Spot -> Spot -> Spot
max :: Spot -> Spot -> Spot
$cmax :: Spot -> Spot -> Spot
>= :: Spot -> Spot -> Bool
$c>= :: Spot -> Spot -> Bool
> :: Spot -> Spot -> Bool
$c> :: Spot -> Spot -> Bool
<= :: Spot -> Spot -> Bool
$c<= :: Spot -> Spot -> Bool
< :: Spot -> Spot -> Bool
$c< :: Spot -> Spot -> Bool
compare :: Spot -> Spot -> Ordering
$ccompare :: Spot -> Spot -> Ordering
$cp1Ord :: Eq Spot
Ord, Integer -> Spot
Spot -> Spot
Spot -> Spot -> Spot
(Spot -> Spot -> Spot)
-> (Spot -> Spot -> Spot)
-> (Spot -> Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Integer -> Spot)
-> Num Spot
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Spot
$cfromInteger :: Integer -> Spot
signum :: Spot -> Spot
$csignum :: Spot -> Spot
abs :: Spot -> Spot
$cabs :: Spot -> Spot
negate :: Spot -> Spot
$cnegate :: Spot -> Spot
* :: Spot -> Spot -> Spot
$c* :: Spot -> Spot -> Spot
- :: Spot -> Spot -> Spot
$c- :: Spot -> Spot -> Spot
+ :: Spot -> Spot -> Spot
$c+ :: Spot -> Spot -> Spot
Num, Num Spot
Num Spot
-> (Spot -> Spot -> Spot)
-> (Spot -> Spot)
-> (Rational -> Spot)
-> Fractional Spot
Rational -> Spot
Spot -> Spot
Spot -> Spot -> Spot
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Spot
$cfromRational :: Rational -> Spot
recip :: Spot -> Spot
$crecip :: Spot -> Spot
/ :: Spot -> Spot -> Spot
$c/ :: Spot -> Spot -> Spot
$cp1Fractional :: Num Spot
Fractional, Num Spot
Ord Spot
Num Spot -> Ord Spot -> (Spot -> Rational) -> Real Spot
Spot -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Spot -> Rational
$ctoRational :: Spot -> Rational
$cp2Real :: Ord Spot
$cp1Real :: Num Spot
Real, Fractional Spot
Real Spot
Real Spot
-> Fractional Spot
-> (forall b. Integral b => Spot -> (b, Spot))
-> (forall b. Integral b => Spot -> b)
-> (forall b. Integral b => Spot -> b)
-> (forall b. Integral b => Spot -> b)
-> (forall b. Integral b => Spot -> b)
-> RealFrac Spot
Spot -> b
Spot -> b
Spot -> b
Spot -> b
Spot -> (b, Spot)
forall b. Integral b => Spot -> b
forall b. Integral b => Spot -> (b, Spot)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Spot -> b
$cfloor :: forall b. Integral b => Spot -> b
ceiling :: Spot -> b
$cceiling :: forall b. Integral b => Spot -> b
round :: Spot -> b
$cround :: forall b. Integral b => Spot -> b
truncate :: Spot -> b
$ctruncate :: forall b. Integral b => Spot -> b
properFraction :: Spot -> (b, Spot)
$cproperFraction :: forall b. Integral b => Spot -> (b, Spot)
$cp2RealFrac :: Fractional Spot
$cp1RealFrac :: Real Spot
RealFrac, Floating Spot
RealFrac Spot
RealFrac Spot
-> Floating Spot
-> (Spot -> Integer)
-> (Spot -> Int)
-> (Spot -> (Int, Int))
-> (Spot -> (Integer, Int))
-> (Integer -> Int -> Spot)
-> (Spot -> Int)
-> (Spot -> Spot)
-> (Int -> Spot -> Spot)
-> (Spot -> Bool)
-> (Spot -> Bool)
-> (Spot -> Bool)
-> (Spot -> Bool)
-> (Spot -> Bool)
-> (Spot -> Spot -> Spot)
-> RealFloat Spot
Int -> Spot -> Spot
Integer -> Int -> Spot
Spot -> Bool
Spot -> Int
Spot -> Integer
Spot -> (Int, Int)
Spot -> (Integer, Int)
Spot -> Spot
Spot -> Spot -> Spot
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Spot -> Spot -> Spot
$catan2 :: Spot -> Spot -> Spot
isIEEE :: Spot -> Bool
$cisIEEE :: Spot -> Bool
isNegativeZero :: Spot -> Bool
$cisNegativeZero :: Spot -> Bool
isDenormalized :: Spot -> Bool
$cisDenormalized :: Spot -> Bool
isInfinite :: Spot -> Bool
$cisInfinite :: Spot -> Bool
isNaN :: Spot -> Bool
$cisNaN :: Spot -> Bool
scaleFloat :: Int -> Spot -> Spot
$cscaleFloat :: Int -> Spot -> Spot
significand :: Spot -> Spot
$csignificand :: Spot -> Spot
exponent :: Spot -> Int
$cexponent :: Spot -> Int
encodeFloat :: Integer -> Int -> Spot
$cencodeFloat :: Integer -> Int -> Spot
decodeFloat :: Spot -> (Integer, Int)
$cdecodeFloat :: Spot -> (Integer, Int)
floatRange :: Spot -> (Int, Int)
$cfloatRange :: Spot -> (Int, Int)
floatDigits :: Spot -> Int
$cfloatDigits :: Spot -> Int
floatRadix :: Spot -> Integer
$cfloatRadix :: Spot -> Integer
$cp2RealFloat :: Floating Spot
$cp1RealFloat :: RealFrac Spot
RealFloat, Fractional Spot
Spot
Fractional Spot
-> Spot
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot -> Spot)
-> (Spot -> Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> (Spot -> Spot)
-> Floating Spot
Spot -> Spot
Spot -> Spot -> Spot
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Spot -> Spot
$clog1mexp :: Spot -> Spot
log1pexp :: Spot -> Spot
$clog1pexp :: Spot -> Spot
expm1 :: Spot -> Spot
$cexpm1 :: Spot -> Spot
log1p :: Spot -> Spot
$clog1p :: Spot -> Spot
atanh :: Spot -> Spot
$catanh :: Spot -> Spot
acosh :: Spot -> Spot
$cacosh :: Spot -> Spot
asinh :: Spot -> Spot
$casinh :: Spot -> Spot
tanh :: Spot -> Spot
$ctanh :: Spot -> Spot
cosh :: Spot -> Spot
$ccosh :: Spot -> Spot
sinh :: Spot -> Spot
$csinh :: Spot -> Spot
atan :: Spot -> Spot
$catan :: Spot -> Spot
acos :: Spot -> Spot
$cacos :: Spot -> Spot
asin :: Spot -> Spot
$casin :: Spot -> Spot
tan :: Spot -> Spot
$ctan :: Spot -> Spot
cos :: Spot -> Spot
$ccos :: Spot -> Spot
sin :: Spot -> Spot
$csin :: Spot -> Spot
logBase :: Spot -> Spot -> Spot
$clogBase :: Spot -> Spot -> Spot
** :: Spot -> Spot -> Spot
$c** :: Spot -> Spot -> Spot
sqrt :: Spot -> Spot
$csqrt :: Spot -> Spot
log :: Spot -> Spot
$clog :: Spot -> Spot
exp :: Spot -> Spot
$cexp :: Spot -> Spot
pi :: Spot
$cpi :: Spot
$cp1Floating :: Fractional Spot
Floating, Ptr b -> Int -> IO Spot
Ptr b -> Int -> Spot -> IO ()
Ptr Spot -> IO Spot
Ptr Spot -> Int -> IO Spot
Ptr Spot -> Int -> Spot -> IO ()
Ptr Spot -> Spot -> IO ()
Spot -> Int
(Spot -> Int)
-> (Spot -> Int)
-> (Ptr Spot -> Int -> IO Spot)
-> (Ptr Spot -> Int -> Spot -> IO ())
-> (forall b. Ptr b -> Int -> IO Spot)
-> (forall b. Ptr b -> Int -> Spot -> IO ())
-> (Ptr Spot -> IO Spot)
-> (Ptr Spot -> Spot -> IO ())
-> Storable Spot
forall b. Ptr b -> Int -> IO Spot
forall b. Ptr b -> Int -> Spot -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Spot -> Spot -> IO ()
$cpoke :: Ptr Spot -> Spot -> IO ()
peek :: Ptr Spot -> IO Spot
$cpeek :: Ptr Spot -> IO Spot
pokeByteOff :: Ptr b -> Int -> Spot -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Spot -> IO ()
peekByteOff :: Ptr b -> Int -> IO Spot
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Spot
pokeElemOff :: Ptr Spot -> Int -> Spot -> IO ()
$cpokeElemOff :: Ptr Spot -> Int -> Spot -> IO ()
peekElemOff :: Ptr Spot -> Int -> IO Spot
$cpeekElemOff :: Ptr Spot -> Int -> IO Spot
alignment :: Spot -> Int
$calignment :: Spot -> Int
sizeOf :: Spot -> Int
$csizeOf :: Spot -> Int
Storable)
newtype Forward  = Forward Double deriving ((forall x. Forward -> Rep Forward x)
-> (forall x. Rep Forward x -> Forward) -> Generic Forward
forall x. Rep Forward x -> Forward
forall x. Forward -> Rep Forward x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Forward x -> Forward
$cfrom :: forall x. Forward -> Rep Forward x
Generic, Forward -> Forward -> Bool
(Forward -> Forward -> Bool)
-> (Forward -> Forward -> Bool) -> Eq Forward
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Forward -> Forward -> Bool
$c/= :: Forward -> Forward -> Bool
== :: Forward -> Forward -> Bool
$c== :: Forward -> Forward -> Bool
Eq, Int -> Forward -> ShowS
[Forward] -> ShowS
Forward -> String
(Int -> Forward -> ShowS)
-> (Forward -> String) -> ([Forward] -> ShowS) -> Show Forward
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Forward] -> ShowS
$cshowList :: [Forward] -> ShowS
show :: Forward -> String
$cshow :: Forward -> String
showsPrec :: Int -> Forward -> ShowS
$cshowsPrec :: Int -> Forward -> ShowS
Show, ReadPrec [Forward]
ReadPrec Forward
Int -> ReadS Forward
ReadS [Forward]
(Int -> ReadS Forward)
-> ReadS [Forward]
-> ReadPrec Forward
-> ReadPrec [Forward]
-> Read Forward
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Forward]
$creadListPrec :: ReadPrec [Forward]
readPrec :: ReadPrec Forward
$creadPrec :: ReadPrec Forward
readList :: ReadS [Forward]
$creadList :: ReadS [Forward]
readsPrec :: Int -> ReadS Forward
$creadsPrec :: Int -> ReadS Forward
Read, Eq Forward
Eq Forward
-> (Forward -> Forward -> Ordering)
-> (Forward -> Forward -> Bool)
-> (Forward -> Forward -> Bool)
-> (Forward -> Forward -> Bool)
-> (Forward -> Forward -> Bool)
-> (Forward -> Forward -> Forward)
-> (Forward -> Forward -> Forward)
-> Ord Forward
Forward -> Forward -> Bool
Forward -> Forward -> Ordering
Forward -> Forward -> Forward
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
min :: Forward -> Forward -> Forward
$cmin :: Forward -> Forward -> Forward
max :: Forward -> Forward -> Forward
$cmax :: Forward -> Forward -> Forward
>= :: Forward -> Forward -> Bool
$c>= :: Forward -> Forward -> Bool
> :: Forward -> Forward -> Bool
$c> :: Forward -> Forward -> Bool
<= :: Forward -> Forward -> Bool
$c<= :: Forward -> Forward -> Bool
< :: Forward -> Forward -> Bool
$c< :: Forward -> Forward -> Bool
compare :: Forward -> Forward -> Ordering
$ccompare :: Forward -> Forward -> Ordering
$cp1Ord :: Eq Forward
Ord, Integer -> Forward
Forward -> Forward
Forward -> Forward -> Forward
(Forward -> Forward -> Forward)
-> (Forward -> Forward -> Forward)
-> (Forward -> Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Integer -> Forward)
-> Num Forward
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Forward
$cfromInteger :: Integer -> Forward
signum :: Forward -> Forward
$csignum :: Forward -> Forward
abs :: Forward -> Forward
$cabs :: Forward -> Forward
negate :: Forward -> Forward
$cnegate :: Forward -> Forward
* :: Forward -> Forward -> Forward
$c* :: Forward -> Forward -> Forward
- :: Forward -> Forward -> Forward
$c- :: Forward -> Forward -> Forward
+ :: Forward -> Forward -> Forward
$c+ :: Forward -> Forward -> Forward
Num, Num Forward
Num Forward
-> (Forward -> Forward -> Forward)
-> (Forward -> Forward)
-> (Rational -> Forward)
-> Fractional Forward
Rational -> Forward
Forward -> Forward
Forward -> Forward -> Forward
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Forward
$cfromRational :: Rational -> Forward
recip :: Forward -> Forward
$crecip :: Forward -> Forward
/ :: Forward -> Forward -> Forward
$c/ :: Forward -> Forward -> Forward
$cp1Fractional :: Num Forward
Fractional, Num Forward
Ord Forward
Num Forward -> Ord Forward -> (Forward -> Rational) -> Real Forward
Forward -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Forward -> Rational
$ctoRational :: Forward -> Rational
$cp2Real :: Ord Forward
$cp1Real :: Num Forward
Real, Fractional Forward
Real Forward
Real Forward
-> Fractional Forward
-> (forall b. Integral b => Forward -> (b, Forward))
-> (forall b. Integral b => Forward -> b)
-> (forall b. Integral b => Forward -> b)
-> (forall b. Integral b => Forward -> b)
-> (forall b. Integral b => Forward -> b)
-> RealFrac Forward
Forward -> b
Forward -> b
Forward -> b
Forward -> b
Forward -> (b, Forward)
forall b. Integral b => Forward -> b
forall b. Integral b => Forward -> (b, Forward)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Forward -> b
$cfloor :: forall b. Integral b => Forward -> b
ceiling :: Forward -> b
$cceiling :: forall b. Integral b => Forward -> b
round :: Forward -> b
$cround :: forall b. Integral b => Forward -> b
truncate :: Forward -> b
$ctruncate :: forall b. Integral b => Forward -> b
properFraction :: Forward -> (b, Forward)
$cproperFraction :: forall b. Integral b => Forward -> (b, Forward)
$cp2RealFrac :: Fractional Forward
$cp1RealFrac :: Real Forward
RealFrac, Floating Forward
RealFrac Forward
RealFrac Forward
-> Floating Forward
-> (Forward -> Integer)
-> (Forward -> Int)
-> (Forward -> (Int, Int))
-> (Forward -> (Integer, Int))
-> (Integer -> Int -> Forward)
-> (Forward -> Int)
-> (Forward -> Forward)
-> (Int -> Forward -> Forward)
-> (Forward -> Bool)
-> (Forward -> Bool)
-> (Forward -> Bool)
-> (Forward -> Bool)
-> (Forward -> Bool)
-> (Forward -> Forward -> Forward)
-> RealFloat Forward
Int -> Forward -> Forward
Integer -> Int -> Forward
Forward -> Bool
Forward -> Int
Forward -> Integer
Forward -> (Int, Int)
Forward -> (Integer, Int)
Forward -> Forward
Forward -> Forward -> Forward
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Forward -> Forward -> Forward
$catan2 :: Forward -> Forward -> Forward
isIEEE :: Forward -> Bool
$cisIEEE :: Forward -> Bool
isNegativeZero :: Forward -> Bool
$cisNegativeZero :: Forward -> Bool
isDenormalized :: Forward -> Bool
$cisDenormalized :: Forward -> Bool
isInfinite :: Forward -> Bool
$cisInfinite :: Forward -> Bool
isNaN :: Forward -> Bool
$cisNaN :: Forward -> Bool
scaleFloat :: Int -> Forward -> Forward
$cscaleFloat :: Int -> Forward -> Forward
significand :: Forward -> Forward
$csignificand :: Forward -> Forward
exponent :: Forward -> Int
$cexponent :: Forward -> Int
encodeFloat :: Integer -> Int -> Forward
$cencodeFloat :: Integer -> Int -> Forward
decodeFloat :: Forward -> (Integer, Int)
$cdecodeFloat :: Forward -> (Integer, Int)
floatRange :: Forward -> (Int, Int)
$cfloatRange :: Forward -> (Int, Int)
floatDigits :: Forward -> Int
$cfloatDigits :: Forward -> Int
floatRadix :: Forward -> Integer
$cfloatRadix :: Forward -> Integer
$cp2RealFloat :: Floating Forward
$cp1RealFloat :: RealFrac Forward
RealFloat, Fractional Forward
Forward
Fractional Forward
-> Forward
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward -> Forward)
-> (Forward -> Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> (Forward -> Forward)
-> Floating Forward
Forward -> Forward
Forward -> Forward -> Forward
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Forward -> Forward
$clog1mexp :: Forward -> Forward
log1pexp :: Forward -> Forward
$clog1pexp :: Forward -> Forward
expm1 :: Forward -> Forward
$cexpm1 :: Forward -> Forward
log1p :: Forward -> Forward
$clog1p :: Forward -> Forward
atanh :: Forward -> Forward
$catanh :: Forward -> Forward
acosh :: Forward -> Forward
$cacosh :: Forward -> Forward
asinh :: Forward -> Forward
$casinh :: Forward -> Forward
tanh :: Forward -> Forward
$ctanh :: Forward -> Forward
cosh :: Forward -> Forward
$ccosh :: Forward -> Forward
sinh :: Forward -> Forward
$csinh :: Forward -> Forward
atan :: Forward -> Forward
$catan :: Forward -> Forward
acos :: Forward -> Forward
$cacos :: Forward -> Forward
asin :: Forward -> Forward
$casin :: Forward -> Forward
tan :: Forward -> Forward
$ctan :: Forward -> Forward
cos :: Forward -> Forward
$ccos :: Forward -> Forward
sin :: Forward -> Forward
$csin :: Forward -> Forward
logBase :: Forward -> Forward -> Forward
$clogBase :: Forward -> Forward -> Forward
** :: Forward -> Forward -> Forward
$c** :: Forward -> Forward -> Forward
sqrt :: Forward -> Forward
$csqrt :: Forward -> Forward
log :: Forward -> Forward
$clog :: Forward -> Forward
exp :: Forward -> Forward
$cexp :: Forward -> Forward
pi :: Forward
$cpi :: Forward
$cp1Floating :: Fractional Forward
Floating, Ptr b -> Int -> IO Forward
Ptr b -> Int -> Forward -> IO ()
Ptr Forward -> IO Forward
Ptr Forward -> Int -> IO Forward
Ptr Forward -> Int -> Forward -> IO ()
Ptr Forward -> Forward -> IO ()
Forward -> Int
(Forward -> Int)
-> (Forward -> Int)
-> (Ptr Forward -> Int -> IO Forward)
-> (Ptr Forward -> Int -> Forward -> IO ())
-> (forall b. Ptr b -> Int -> IO Forward)
-> (forall b. Ptr b -> Int -> Forward -> IO ())
-> (Ptr Forward -> IO Forward)
-> (Ptr Forward -> Forward -> IO ())
-> Storable Forward
forall b. Ptr b -> Int -> IO Forward
forall b. Ptr b -> Int -> Forward -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Forward -> Forward -> IO ()
$cpoke :: Ptr Forward -> Forward -> IO ()
peek :: Ptr Forward -> IO Forward
$cpeek :: Ptr Forward -> IO Forward
pokeByteOff :: Ptr b -> Int -> Forward -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Forward -> IO ()
peekByteOff :: Ptr b -> Int -> IO Forward
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Forward
pokeElemOff :: Ptr Forward -> Int -> Forward -> IO ()
$cpokeElemOff :: Ptr Forward -> Int -> Forward -> IO ()
peekElemOff :: Ptr Forward -> Int -> IO Forward
$cpeekElemOff :: Ptr Forward -> Int -> IO Forward
alignment :: Forward -> Int
$calignment :: Forward -> Int
sizeOf :: Forward -> Int
$csizeOf :: Forward -> Int
Storable)
newtype Strike   = Strike  Double deriving ((forall x. Strike -> Rep Strike x)
-> (forall x. Rep Strike x -> Strike) -> Generic Strike
forall x. Rep Strike x -> Strike
forall x. Strike -> Rep Strike x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Strike x -> Strike
$cfrom :: forall x. Strike -> Rep Strike x
Generic, Strike -> Strike -> Bool
(Strike -> Strike -> Bool)
-> (Strike -> Strike -> Bool) -> Eq Strike
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Strike -> Strike -> Bool
$c/= :: Strike -> Strike -> Bool
== :: Strike -> Strike -> Bool
$c== :: Strike -> Strike -> Bool
Eq, Int -> Strike -> ShowS
[Strike] -> ShowS
Strike -> String
(Int -> Strike -> ShowS)
-> (Strike -> String) -> ([Strike] -> ShowS) -> Show Strike
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Strike] -> ShowS
$cshowList :: [Strike] -> ShowS
show :: Strike -> String
$cshow :: Strike -> String
showsPrec :: Int -> Strike -> ShowS
$cshowsPrec :: Int -> Strike -> ShowS
Show, ReadPrec [Strike]
ReadPrec Strike
Int -> ReadS Strike
ReadS [Strike]
(Int -> ReadS Strike)
-> ReadS [Strike]
-> ReadPrec Strike
-> ReadPrec [Strike]
-> Read Strike
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Strike]
$creadListPrec :: ReadPrec [Strike]
readPrec :: ReadPrec Strike
$creadPrec :: ReadPrec Strike
readList :: ReadS [Strike]
$creadList :: ReadS [Strike]
readsPrec :: Int -> ReadS Strike
$creadsPrec :: Int -> ReadS Strike
Read, Eq Strike
Eq Strike
-> (Strike -> Strike -> Ordering)
-> (Strike -> Strike -> Bool)
-> (Strike -> Strike -> Bool)
-> (Strike -> Strike -> Bool)
-> (Strike -> Strike -> Bool)
-> (Strike -> Strike -> Strike)
-> (Strike -> Strike -> Strike)
-> Ord Strike
Strike -> Strike -> Bool
Strike -> Strike -> Ordering
Strike -> Strike -> Strike
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
min :: Strike -> Strike -> Strike
$cmin :: Strike -> Strike -> Strike
max :: Strike -> Strike -> Strike
$cmax :: Strike -> Strike -> Strike
>= :: Strike -> Strike -> Bool
$c>= :: Strike -> Strike -> Bool
> :: Strike -> Strike -> Bool
$c> :: Strike -> Strike -> Bool
<= :: Strike -> Strike -> Bool
$c<= :: Strike -> Strike -> Bool
< :: Strike -> Strike -> Bool
$c< :: Strike -> Strike -> Bool
compare :: Strike -> Strike -> Ordering
$ccompare :: Strike -> Strike -> Ordering
$cp1Ord :: Eq Strike
Ord, Integer -> Strike
Strike -> Strike
Strike -> Strike -> Strike
(Strike -> Strike -> Strike)
-> (Strike -> Strike -> Strike)
-> (Strike -> Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Integer -> Strike)
-> Num Strike
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Strike
$cfromInteger :: Integer -> Strike
signum :: Strike -> Strike
$csignum :: Strike -> Strike
abs :: Strike -> Strike
$cabs :: Strike -> Strike
negate :: Strike -> Strike
$cnegate :: Strike -> Strike
* :: Strike -> Strike -> Strike
$c* :: Strike -> Strike -> Strike
- :: Strike -> Strike -> Strike
$c- :: Strike -> Strike -> Strike
+ :: Strike -> Strike -> Strike
$c+ :: Strike -> Strike -> Strike
Num, Num Strike
Num Strike
-> (Strike -> Strike -> Strike)
-> (Strike -> Strike)
-> (Rational -> Strike)
-> Fractional Strike
Rational -> Strike
Strike -> Strike
Strike -> Strike -> Strike
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Strike
$cfromRational :: Rational -> Strike
recip :: Strike -> Strike
$crecip :: Strike -> Strike
/ :: Strike -> Strike -> Strike
$c/ :: Strike -> Strike -> Strike
$cp1Fractional :: Num Strike
Fractional, Num Strike
Ord Strike
Num Strike -> Ord Strike -> (Strike -> Rational) -> Real Strike
Strike -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Strike -> Rational
$ctoRational :: Strike -> Rational
$cp2Real :: Ord Strike
$cp1Real :: Num Strike
Real, Fractional Strike
Real Strike
Real Strike
-> Fractional Strike
-> (forall b. Integral b => Strike -> (b, Strike))
-> (forall b. Integral b => Strike -> b)
-> (forall b. Integral b => Strike -> b)
-> (forall b. Integral b => Strike -> b)
-> (forall b. Integral b => Strike -> b)
-> RealFrac Strike
Strike -> b
Strike -> b
Strike -> b
Strike -> b
Strike -> (b, Strike)
forall b. Integral b => Strike -> b
forall b. Integral b => Strike -> (b, Strike)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Strike -> b
$cfloor :: forall b. Integral b => Strike -> b
ceiling :: Strike -> b
$cceiling :: forall b. Integral b => Strike -> b
round :: Strike -> b
$cround :: forall b. Integral b => Strike -> b
truncate :: Strike -> b
$ctruncate :: forall b. Integral b => Strike -> b
properFraction :: Strike -> (b, Strike)
$cproperFraction :: forall b. Integral b => Strike -> (b, Strike)
$cp2RealFrac :: Fractional Strike
$cp1RealFrac :: Real Strike
RealFrac, Floating Strike
RealFrac Strike
RealFrac Strike
-> Floating Strike
-> (Strike -> Integer)
-> (Strike -> Int)
-> (Strike -> (Int, Int))
-> (Strike -> (Integer, Int))
-> (Integer -> Int -> Strike)
-> (Strike -> Int)
-> (Strike -> Strike)
-> (Int -> Strike -> Strike)
-> (Strike -> Bool)
-> (Strike -> Bool)
-> (Strike -> Bool)
-> (Strike -> Bool)
-> (Strike -> Bool)
-> (Strike -> Strike -> Strike)
-> RealFloat Strike
Int -> Strike -> Strike
Integer -> Int -> Strike
Strike -> Bool
Strike -> Int
Strike -> Integer
Strike -> (Int, Int)
Strike -> (Integer, Int)
Strike -> Strike
Strike -> Strike -> Strike
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Strike -> Strike -> Strike
$catan2 :: Strike -> Strike -> Strike
isIEEE :: Strike -> Bool
$cisIEEE :: Strike -> Bool
isNegativeZero :: Strike -> Bool
$cisNegativeZero :: Strike -> Bool
isDenormalized :: Strike -> Bool
$cisDenormalized :: Strike -> Bool
isInfinite :: Strike -> Bool
$cisInfinite :: Strike -> Bool
isNaN :: Strike -> Bool
$cisNaN :: Strike -> Bool
scaleFloat :: Int -> Strike -> Strike
$cscaleFloat :: Int -> Strike -> Strike
significand :: Strike -> Strike
$csignificand :: Strike -> Strike
exponent :: Strike -> Int
$cexponent :: Strike -> Int
encodeFloat :: Integer -> Int -> Strike
$cencodeFloat :: Integer -> Int -> Strike
decodeFloat :: Strike -> (Integer, Int)
$cdecodeFloat :: Strike -> (Integer, Int)
floatRange :: Strike -> (Int, Int)
$cfloatRange :: Strike -> (Int, Int)
floatDigits :: Strike -> Int
$cfloatDigits :: Strike -> Int
floatRadix :: Strike -> Integer
$cfloatRadix :: Strike -> Integer
$cp2RealFloat :: Floating Strike
$cp1RealFloat :: RealFrac Strike
RealFloat, Fractional Strike
Strike
Fractional Strike
-> Strike
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike -> Strike)
-> (Strike -> Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> (Strike -> Strike)
-> Floating Strike
Strike -> Strike
Strike -> Strike -> Strike
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Strike -> Strike
$clog1mexp :: Strike -> Strike
log1pexp :: Strike -> Strike
$clog1pexp :: Strike -> Strike
expm1 :: Strike -> Strike
$cexpm1 :: Strike -> Strike
log1p :: Strike -> Strike
$clog1p :: Strike -> Strike
atanh :: Strike -> Strike
$catanh :: Strike -> Strike
acosh :: Strike -> Strike
$cacosh :: Strike -> Strike
asinh :: Strike -> Strike
$casinh :: Strike -> Strike
tanh :: Strike -> Strike
$ctanh :: Strike -> Strike
cosh :: Strike -> Strike
$ccosh :: Strike -> Strike
sinh :: Strike -> Strike
$csinh :: Strike -> Strike
atan :: Strike -> Strike
$catan :: Strike -> Strike
acos :: Strike -> Strike
$cacos :: Strike -> Strike
asin :: Strike -> Strike
$casin :: Strike -> Strike
tan :: Strike -> Strike
$ctan :: Strike -> Strike
cos :: Strike -> Strike
$ccos :: Strike -> Strike
sin :: Strike -> Strike
$csin :: Strike -> Strike
logBase :: Strike -> Strike -> Strike
$clogBase :: Strike -> Strike -> Strike
** :: Strike -> Strike -> Strike
$c** :: Strike -> Strike -> Strike
sqrt :: Strike -> Strike
$csqrt :: Strike -> Strike
log :: Strike -> Strike
$clog :: Strike -> Strike
exp :: Strike -> Strike
$cexp :: Strike -> Strike
pi :: Strike
$cpi :: Strike
$cp1Floating :: Fractional Strike
Floating, Ptr b -> Int -> IO Strike
Ptr b -> Int -> Strike -> IO ()
Ptr Strike -> IO Strike
Ptr Strike -> Int -> IO Strike
Ptr Strike -> Int -> Strike -> IO ()
Ptr Strike -> Strike -> IO ()
Strike -> Int
(Strike -> Int)
-> (Strike -> Int)
-> (Ptr Strike -> Int -> IO Strike)
-> (Ptr Strike -> Int -> Strike -> IO ())
-> (forall b. Ptr b -> Int -> IO Strike)
-> (forall b. Ptr b -> Int -> Strike -> IO ())
-> (Ptr Strike -> IO Strike)
-> (Ptr Strike -> Strike -> IO ())
-> Storable Strike
forall b. Ptr b -> Int -> IO Strike
forall b. Ptr b -> Int -> Strike -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Strike -> Strike -> IO ()
$cpoke :: Ptr Strike -> Strike -> IO ()
peek :: Ptr Strike -> IO Strike
$cpeek :: Ptr Strike -> IO Strike
pokeByteOff :: Ptr b -> Int -> Strike -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Strike -> IO ()
peekByteOff :: Ptr b -> Int -> IO Strike
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Strike
pokeElemOff :: Ptr Strike -> Int -> Strike -> IO ()
$cpokeElemOff :: Ptr Strike -> Int -> Strike -> IO ()
peekElemOff :: Ptr Strike -> Int -> IO Strike
$cpeekElemOff :: Ptr Strike -> Int -> IO Strike
alignment :: Strike -> Int
$calignment :: Strike -> Int
sizeOf :: Strike -> Int
$csizeOf :: Strike -> Int
Storable)

($*$) :: (Coercible a Double, Coercible b Double) => a -> b -> a
a
x1 $*$ :: a -> b -> a
$*$ b
x2 = Double -> a
coerce (Double -> a) -> Double -> a
forall a b. (a -> b) -> a -> b
$ (a -> Double
coerce a
x1::Double) Double -> Double -> Double
forall a. Num a => a -> a -> a
* (b -> Double
coerce b
x2::Double)

($/$) :: (Coercible a Double, Coercible b Double) => a -> b -> a
a
x1 $/$ :: a -> b -> a
$/$ b
x2 = Double -> a
coerce (Double -> a) -> Double -> a
forall a b. (a -> b) -> a -> b
$ (a -> Double
coerce a
x1::Double) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ (b -> Double
coerce b
x2::Double)

($+$) :: (Coercible a Double, Coercible b Double) => a -> b -> a
a
x1 $+$ :: a -> b -> a
$+$ b
x2 = Double -> a
coerce (Double -> a) -> Double -> a
forall a b. (a -> b) -> a -> b
$ (a -> Double
coerce a
x1::Double) Double -> Double -> Double
forall a. Num a => a -> a -> a
+ (b -> Double
coerce b
x2::Double)



-- Later on i should add roll.
newtype Expiry   = Expiry   Day    deriving ((forall x. Expiry -> Rep Expiry x)
-> (forall x. Rep Expiry x -> Expiry) -> Generic Expiry
forall x. Rep Expiry x -> Expiry
forall x. Expiry -> Rep Expiry x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Expiry x -> Expiry
$cfrom :: forall x. Expiry -> Rep Expiry x
Generic, Expiry -> Expiry -> Bool
(Expiry -> Expiry -> Bool)
-> (Expiry -> Expiry -> Bool) -> Eq Expiry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Expiry -> Expiry -> Bool
$c/= :: Expiry -> Expiry -> Bool
== :: Expiry -> Expiry -> Bool
$c== :: Expiry -> Expiry -> Bool
Eq, Int -> Expiry -> ShowS
[Expiry] -> ShowS
Expiry -> String
(Int -> Expiry -> ShowS)
-> (Expiry -> String) -> ([Expiry] -> ShowS) -> Show Expiry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Expiry] -> ShowS
$cshowList :: [Expiry] -> ShowS
show :: Expiry -> String
$cshow :: Expiry -> String
showsPrec :: Int -> Expiry -> ShowS
$cshowsPrec :: Int -> Expiry -> ShowS
Show, ReadPrec [Expiry]
ReadPrec Expiry
Int -> ReadS Expiry
ReadS [Expiry]
(Int -> ReadS Expiry)
-> ReadS [Expiry]
-> ReadPrec Expiry
-> ReadPrec [Expiry]
-> Read Expiry
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Expiry]
$creadListPrec :: ReadPrec [Expiry]
readPrec :: ReadPrec Expiry
$creadPrec :: ReadPrec Expiry
readList :: ReadS [Expiry]
$creadList :: ReadS [Expiry]
readsPrec :: Int -> ReadS Expiry
$creadsPrec :: Int -> ReadS Expiry
Read, Eq Expiry
Eq Expiry
-> (Expiry -> Expiry -> Ordering)
-> (Expiry -> Expiry -> Bool)
-> (Expiry -> Expiry -> Bool)
-> (Expiry -> Expiry -> Bool)
-> (Expiry -> Expiry -> Bool)
-> (Expiry -> Expiry -> Expiry)
-> (Expiry -> Expiry -> Expiry)
-> Ord Expiry
Expiry -> Expiry -> Bool
Expiry -> Expiry -> Ordering
Expiry -> Expiry -> Expiry
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
min :: Expiry -> Expiry -> Expiry
$cmin :: Expiry -> Expiry -> Expiry
max :: Expiry -> Expiry -> Expiry
$cmax :: Expiry -> Expiry -> Expiry
>= :: Expiry -> Expiry -> Bool
$c>= :: Expiry -> Expiry -> Bool
> :: Expiry -> Expiry -> Bool
$c> :: Expiry -> Expiry -> Bool
<= :: Expiry -> Expiry -> Bool
$c<= :: Expiry -> Expiry -> Bool
< :: Expiry -> Expiry -> Bool
$c< :: Expiry -> Expiry -> Bool
compare :: Expiry -> Expiry -> Ordering
$ccompare :: Expiry -> Expiry -> Ordering
$cp1Ord :: Eq Expiry
Ord)

newtype Premium  = Premium  Double deriving ((forall x. Premium -> Rep Premium x)
-> (forall x. Rep Premium x -> Premium) -> Generic Premium
forall x. Rep Premium x -> Premium
forall x. Premium -> Rep Premium x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Premium x -> Premium
$cfrom :: forall x. Premium -> Rep Premium x
Generic, Premium -> Premium -> Bool
(Premium -> Premium -> Bool)
-> (Premium -> Premium -> Bool) -> Eq Premium
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Premium -> Premium -> Bool
$c/= :: Premium -> Premium -> Bool
== :: Premium -> Premium -> Bool
$c== :: Premium -> Premium -> Bool
Eq, Int -> Premium -> ShowS
[Premium] -> ShowS
Premium -> String
(Int -> Premium -> ShowS)
-> (Premium -> String) -> ([Premium] -> ShowS) -> Show Premium
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Premium] -> ShowS
$cshowList :: [Premium] -> ShowS
show :: Premium -> String
$cshow :: Premium -> String
showsPrec :: Int -> Premium -> ShowS
$cshowsPrec :: Int -> Premium -> ShowS
Show, ReadPrec [Premium]
ReadPrec Premium
Int -> ReadS Premium
ReadS [Premium]
(Int -> ReadS Premium)
-> ReadS [Premium]
-> ReadPrec Premium
-> ReadPrec [Premium]
-> Read Premium
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Premium]
$creadListPrec :: ReadPrec [Premium]
readPrec :: ReadPrec Premium
$creadPrec :: ReadPrec Premium
readList :: ReadS [Premium]
$creadList :: ReadS [Premium]
readsPrec :: Int -> ReadS Premium
$creadsPrec :: Int -> ReadS Premium
Read, Eq Premium
Eq Premium
-> (Premium -> Premium -> Ordering)
-> (Premium -> Premium -> Bool)
-> (Premium -> Premium -> Bool)
-> (Premium -> Premium -> Bool)
-> (Premium -> Premium -> Bool)
-> (Premium -> Premium -> Premium)
-> (Premium -> Premium -> Premium)
-> Ord Premium
Premium -> Premium -> Bool
Premium -> Premium -> Ordering
Premium -> Premium -> Premium
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
min :: Premium -> Premium -> Premium
$cmin :: Premium -> Premium -> Premium
max :: Premium -> Premium -> Premium
$cmax :: Premium -> Premium -> Premium
>= :: Premium -> Premium -> Bool
$c>= :: Premium -> Premium -> Bool
> :: Premium -> Premium -> Bool
$c> :: Premium -> Premium -> Bool
<= :: Premium -> Premium -> Bool
$c<= :: Premium -> Premium -> Bool
< :: Premium -> Premium -> Bool
$c< :: Premium -> Premium -> Bool
compare :: Premium -> Premium -> Ordering
$ccompare :: Premium -> Premium -> Ordering
$cp1Ord :: Eq Premium
Ord, Integer -> Premium
Premium -> Premium
Premium -> Premium -> Premium
(Premium -> Premium -> Premium)
-> (Premium -> Premium -> Premium)
-> (Premium -> Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Integer -> Premium)
-> Num Premium
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Premium
$cfromInteger :: Integer -> Premium
signum :: Premium -> Premium
$csignum :: Premium -> Premium
abs :: Premium -> Premium
$cabs :: Premium -> Premium
negate :: Premium -> Premium
$cnegate :: Premium -> Premium
* :: Premium -> Premium -> Premium
$c* :: Premium -> Premium -> Premium
- :: Premium -> Premium -> Premium
$c- :: Premium -> Premium -> Premium
+ :: Premium -> Premium -> Premium
$c+ :: Premium -> Premium -> Premium
Num, Num Premium
Num Premium
-> (Premium -> Premium -> Premium)
-> (Premium -> Premium)
-> (Rational -> Premium)
-> Fractional Premium
Rational -> Premium
Premium -> Premium
Premium -> Premium -> Premium
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Premium
$cfromRational :: Rational -> Premium
recip :: Premium -> Premium
$crecip :: Premium -> Premium
/ :: Premium -> Premium -> Premium
$c/ :: Premium -> Premium -> Premium
$cp1Fractional :: Num Premium
Fractional, Num Premium
Ord Premium
Num Premium -> Ord Premium -> (Premium -> Rational) -> Real Premium
Premium -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Premium -> Rational
$ctoRational :: Premium -> Rational
$cp2Real :: Ord Premium
$cp1Real :: Num Premium
Real, Fractional Premium
Real Premium
Real Premium
-> Fractional Premium
-> (forall b. Integral b => Premium -> (b, Premium))
-> (forall b. Integral b => Premium -> b)
-> (forall b. Integral b => Premium -> b)
-> (forall b. Integral b => Premium -> b)
-> (forall b. Integral b => Premium -> b)
-> RealFrac Premium
Premium -> b
Premium -> b
Premium -> b
Premium -> b
Premium -> (b, Premium)
forall b. Integral b => Premium -> b
forall b. Integral b => Premium -> (b, Premium)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Premium -> b
$cfloor :: forall b. Integral b => Premium -> b
ceiling :: Premium -> b
$cceiling :: forall b. Integral b => Premium -> b
round :: Premium -> b
$cround :: forall b. Integral b => Premium -> b
truncate :: Premium -> b
$ctruncate :: forall b. Integral b => Premium -> b
properFraction :: Premium -> (b, Premium)
$cproperFraction :: forall b. Integral b => Premium -> (b, Premium)
$cp2RealFrac :: Fractional Premium
$cp1RealFrac :: Real Premium
RealFrac, Floating Premium
RealFrac Premium
RealFrac Premium
-> Floating Premium
-> (Premium -> Integer)
-> (Premium -> Int)
-> (Premium -> (Int, Int))
-> (Premium -> (Integer, Int))
-> (Integer -> Int -> Premium)
-> (Premium -> Int)
-> (Premium -> Premium)
-> (Int -> Premium -> Premium)
-> (Premium -> Bool)
-> (Premium -> Bool)
-> (Premium -> Bool)
-> (Premium -> Bool)
-> (Premium -> Bool)
-> (Premium -> Premium -> Premium)
-> RealFloat Premium
Int -> Premium -> Premium
Integer -> Int -> Premium
Premium -> Bool
Premium -> Int
Premium -> Integer
Premium -> (Int, Int)
Premium -> (Integer, Int)
Premium -> Premium
Premium -> Premium -> Premium
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Premium -> Premium -> Premium
$catan2 :: Premium -> Premium -> Premium
isIEEE :: Premium -> Bool
$cisIEEE :: Premium -> Bool
isNegativeZero :: Premium -> Bool
$cisNegativeZero :: Premium -> Bool
isDenormalized :: Premium -> Bool
$cisDenormalized :: Premium -> Bool
isInfinite :: Premium -> Bool
$cisInfinite :: Premium -> Bool
isNaN :: Premium -> Bool
$cisNaN :: Premium -> Bool
scaleFloat :: Int -> Premium -> Premium
$cscaleFloat :: Int -> Premium -> Premium
significand :: Premium -> Premium
$csignificand :: Premium -> Premium
exponent :: Premium -> Int
$cexponent :: Premium -> Int
encodeFloat :: Integer -> Int -> Premium
$cencodeFloat :: Integer -> Int -> Premium
decodeFloat :: Premium -> (Integer, Int)
$cdecodeFloat :: Premium -> (Integer, Int)
floatRange :: Premium -> (Int, Int)
$cfloatRange :: Premium -> (Int, Int)
floatDigits :: Premium -> Int
$cfloatDigits :: Premium -> Int
floatRadix :: Premium -> Integer
$cfloatRadix :: Premium -> Integer
$cp2RealFloat :: Floating Premium
$cp1RealFloat :: RealFrac Premium
RealFloat, Fractional Premium
Premium
Fractional Premium
-> Premium
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium -> Premium)
-> (Premium -> Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> (Premium -> Premium)
-> Floating Premium
Premium -> Premium
Premium -> Premium -> Premium
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Premium -> Premium
$clog1mexp :: Premium -> Premium
log1pexp :: Premium -> Premium
$clog1pexp :: Premium -> Premium
expm1 :: Premium -> Premium
$cexpm1 :: Premium -> Premium
log1p :: Premium -> Premium
$clog1p :: Premium -> Premium
atanh :: Premium -> Premium
$catanh :: Premium -> Premium
acosh :: Premium -> Premium
$cacosh :: Premium -> Premium
asinh :: Premium -> Premium
$casinh :: Premium -> Premium
tanh :: Premium -> Premium
$ctanh :: Premium -> Premium
cosh :: Premium -> Premium
$ccosh :: Premium -> Premium
sinh :: Premium -> Premium
$csinh :: Premium -> Premium
atan :: Premium -> Premium
$catan :: Premium -> Premium
acos :: Premium -> Premium
$cacos :: Premium -> Premium
asin :: Premium -> Premium
$casin :: Premium -> Premium
tan :: Premium -> Premium
$ctan :: Premium -> Premium
cos :: Premium -> Premium
$ccos :: Premium -> Premium
sin :: Premium -> Premium
$csin :: Premium -> Premium
logBase :: Premium -> Premium -> Premium
$clogBase :: Premium -> Premium -> Premium
** :: Premium -> Premium -> Premium
$c** :: Premium -> Premium -> Premium
sqrt :: Premium -> Premium
$csqrt :: Premium -> Premium
log :: Premium -> Premium
$clog :: Premium -> Premium
exp :: Premium -> Premium
$cexp :: Premium -> Premium
pi :: Premium
$cpi :: Premium
$cp1Floating :: Fractional Premium
Floating, Ptr b -> Int -> IO Premium
Ptr b -> Int -> Premium -> IO ()
Ptr Premium -> IO Premium
Ptr Premium -> Int -> IO Premium
Ptr Premium -> Int -> Premium -> IO ()
Ptr Premium -> Premium -> IO ()
Premium -> Int
(Premium -> Int)
-> (Premium -> Int)
-> (Ptr Premium -> Int -> IO Premium)
-> (Ptr Premium -> Int -> Premium -> IO ())
-> (forall b. Ptr b -> Int -> IO Premium)
-> (forall b. Ptr b -> Int -> Premium -> IO ())
-> (Ptr Premium -> IO Premium)
-> (Ptr Premium -> Premium -> IO ())
-> Storable Premium
forall b. Ptr b -> Int -> IO Premium
forall b. Ptr b -> Int -> Premium -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Premium -> Premium -> IO ()
$cpoke :: Ptr Premium -> Premium -> IO ()
peek :: Ptr Premium -> IO Premium
$cpeek :: Ptr Premium -> IO Premium
pokeByteOff :: Ptr b -> Int -> Premium -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Premium -> IO ()
peekByteOff :: Ptr b -> Int -> IO Premium
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Premium
pokeElemOff :: Ptr Premium -> Int -> Premium -> IO ()
$cpokeElemOff :: Ptr Premium -> Int -> Premium -> IO ()
peekElemOff :: Ptr Premium -> Int -> IO Premium
$cpeekElemOff :: Ptr Premium -> Int -> IO Premium
alignment :: Premium -> Int
$calignment :: Premium -> Int
sizeOf :: Premium -> Int
$csizeOf :: Premium -> Int
Storable)
newtype Delta    = Delta    Double deriving ((forall x. Delta -> Rep Delta x)
-> (forall x. Rep Delta x -> Delta) -> Generic Delta
forall x. Rep Delta x -> Delta
forall x. Delta -> Rep Delta x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Delta x -> Delta
$cfrom :: forall x. Delta -> Rep Delta x
Generic, Delta -> Delta -> Bool
(Delta -> Delta -> Bool) -> (Delta -> Delta -> Bool) -> Eq Delta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Delta -> Delta -> Bool
$c/= :: Delta -> Delta -> Bool
== :: Delta -> Delta -> Bool
$c== :: Delta -> Delta -> Bool
Eq, Int -> Delta -> ShowS
[Delta] -> ShowS
Delta -> String
(Int -> Delta -> ShowS)
-> (Delta -> String) -> ([Delta] -> ShowS) -> Show Delta
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Delta] -> ShowS
$cshowList :: [Delta] -> ShowS
show :: Delta -> String
$cshow :: Delta -> String
showsPrec :: Int -> Delta -> ShowS
$cshowsPrec :: Int -> Delta -> ShowS
Show, ReadPrec [Delta]
ReadPrec Delta
Int -> ReadS Delta
ReadS [Delta]
(Int -> ReadS Delta)
-> ReadS [Delta]
-> ReadPrec Delta
-> ReadPrec [Delta]
-> Read Delta
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Delta]
$creadListPrec :: ReadPrec [Delta]
readPrec :: ReadPrec Delta
$creadPrec :: ReadPrec Delta
readList :: ReadS [Delta]
$creadList :: ReadS [Delta]
readsPrec :: Int -> ReadS Delta
$creadsPrec :: Int -> ReadS Delta
Read, Eq Delta
Eq Delta
-> (Delta -> Delta -> Ordering)
-> (Delta -> Delta -> Bool)
-> (Delta -> Delta -> Bool)
-> (Delta -> Delta -> Bool)
-> (Delta -> Delta -> Bool)
-> (Delta -> Delta -> Delta)
-> (Delta -> Delta -> Delta)
-> Ord Delta
Delta -> Delta -> Bool
Delta -> Delta -> Ordering
Delta -> Delta -> Delta
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
min :: Delta -> Delta -> Delta
$cmin :: Delta -> Delta -> Delta
max :: Delta -> Delta -> Delta
$cmax :: Delta -> Delta -> Delta
>= :: Delta -> Delta -> Bool
$c>= :: Delta -> Delta -> Bool
> :: Delta -> Delta -> Bool
$c> :: Delta -> Delta -> Bool
<= :: Delta -> Delta -> Bool
$c<= :: Delta -> Delta -> Bool
< :: Delta -> Delta -> Bool
$c< :: Delta -> Delta -> Bool
compare :: Delta -> Delta -> Ordering
$ccompare :: Delta -> Delta -> Ordering
$cp1Ord :: Eq Delta
Ord, Integer -> Delta
Delta -> Delta
Delta -> Delta -> Delta
(Delta -> Delta -> Delta)
-> (Delta -> Delta -> Delta)
-> (Delta -> Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Integer -> Delta)
-> Num Delta
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Delta
$cfromInteger :: Integer -> Delta
signum :: Delta -> Delta
$csignum :: Delta -> Delta
abs :: Delta -> Delta
$cabs :: Delta -> Delta
negate :: Delta -> Delta
$cnegate :: Delta -> Delta
* :: Delta -> Delta -> Delta
$c* :: Delta -> Delta -> Delta
- :: Delta -> Delta -> Delta
$c- :: Delta -> Delta -> Delta
+ :: Delta -> Delta -> Delta
$c+ :: Delta -> Delta -> Delta
Num, Num Delta
Num Delta
-> (Delta -> Delta -> Delta)
-> (Delta -> Delta)
-> (Rational -> Delta)
-> Fractional Delta
Rational -> Delta
Delta -> Delta
Delta -> Delta -> Delta
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Delta
$cfromRational :: Rational -> Delta
recip :: Delta -> Delta
$crecip :: Delta -> Delta
/ :: Delta -> Delta -> Delta
$c/ :: Delta -> Delta -> Delta
$cp1Fractional :: Num Delta
Fractional, Num Delta
Ord Delta
Num Delta -> Ord Delta -> (Delta -> Rational) -> Real Delta
Delta -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Delta -> Rational
$ctoRational :: Delta -> Rational
$cp2Real :: Ord Delta
$cp1Real :: Num Delta
Real, Fractional Delta
Real Delta
Real Delta
-> Fractional Delta
-> (forall b. Integral b => Delta -> (b, Delta))
-> (forall b. Integral b => Delta -> b)
-> (forall b. Integral b => Delta -> b)
-> (forall b. Integral b => Delta -> b)
-> (forall b. Integral b => Delta -> b)
-> RealFrac Delta
Delta -> b
Delta -> b
Delta -> b
Delta -> b
Delta -> (b, Delta)
forall b. Integral b => Delta -> b
forall b. Integral b => Delta -> (b, Delta)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Delta -> b
$cfloor :: forall b. Integral b => Delta -> b
ceiling :: Delta -> b
$cceiling :: forall b. Integral b => Delta -> b
round :: Delta -> b
$cround :: forall b. Integral b => Delta -> b
truncate :: Delta -> b
$ctruncate :: forall b. Integral b => Delta -> b
properFraction :: Delta -> (b, Delta)
$cproperFraction :: forall b. Integral b => Delta -> (b, Delta)
$cp2RealFrac :: Fractional Delta
$cp1RealFrac :: Real Delta
RealFrac, Floating Delta
RealFrac Delta
RealFrac Delta
-> Floating Delta
-> (Delta -> Integer)
-> (Delta -> Int)
-> (Delta -> (Int, Int))
-> (Delta -> (Integer, Int))
-> (Integer -> Int -> Delta)
-> (Delta -> Int)
-> (Delta -> Delta)
-> (Int -> Delta -> Delta)
-> (Delta -> Bool)
-> (Delta -> Bool)
-> (Delta -> Bool)
-> (Delta -> Bool)
-> (Delta -> Bool)
-> (Delta -> Delta -> Delta)
-> RealFloat Delta
Int -> Delta -> Delta
Integer -> Int -> Delta
Delta -> Bool
Delta -> Int
Delta -> Integer
Delta -> (Int, Int)
Delta -> (Integer, Int)
Delta -> Delta
Delta -> Delta -> Delta
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Delta -> Delta -> Delta
$catan2 :: Delta -> Delta -> Delta
isIEEE :: Delta -> Bool
$cisIEEE :: Delta -> Bool
isNegativeZero :: Delta -> Bool
$cisNegativeZero :: Delta -> Bool
isDenormalized :: Delta -> Bool
$cisDenormalized :: Delta -> Bool
isInfinite :: Delta -> Bool
$cisInfinite :: Delta -> Bool
isNaN :: Delta -> Bool
$cisNaN :: Delta -> Bool
scaleFloat :: Int -> Delta -> Delta
$cscaleFloat :: Int -> Delta -> Delta
significand :: Delta -> Delta
$csignificand :: Delta -> Delta
exponent :: Delta -> Int
$cexponent :: Delta -> Int
encodeFloat :: Integer -> Int -> Delta
$cencodeFloat :: Integer -> Int -> Delta
decodeFloat :: Delta -> (Integer, Int)
$cdecodeFloat :: Delta -> (Integer, Int)
floatRange :: Delta -> (Int, Int)
$cfloatRange :: Delta -> (Int, Int)
floatDigits :: Delta -> Int
$cfloatDigits :: Delta -> Int
floatRadix :: Delta -> Integer
$cfloatRadix :: Delta -> Integer
$cp2RealFloat :: Floating Delta
$cp1RealFloat :: RealFrac Delta
RealFloat, Fractional Delta
Delta
Fractional Delta
-> Delta
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta -> Delta)
-> (Delta -> Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> (Delta -> Delta)
-> Floating Delta
Delta -> Delta
Delta -> Delta -> Delta
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Delta -> Delta
$clog1mexp :: Delta -> Delta
log1pexp :: Delta -> Delta
$clog1pexp :: Delta -> Delta
expm1 :: Delta -> Delta
$cexpm1 :: Delta -> Delta
log1p :: Delta -> Delta
$clog1p :: Delta -> Delta
atanh :: Delta -> Delta
$catanh :: Delta -> Delta
acosh :: Delta -> Delta
$cacosh :: Delta -> Delta
asinh :: Delta -> Delta
$casinh :: Delta -> Delta
tanh :: Delta -> Delta
$ctanh :: Delta -> Delta
cosh :: Delta -> Delta
$ccosh :: Delta -> Delta
sinh :: Delta -> Delta
$csinh :: Delta -> Delta
atan :: Delta -> Delta
$catan :: Delta -> Delta
acos :: Delta -> Delta
$cacos :: Delta -> Delta
asin :: Delta -> Delta
$casin :: Delta -> Delta
tan :: Delta -> Delta
$ctan :: Delta -> Delta
cos :: Delta -> Delta
$ccos :: Delta -> Delta
sin :: Delta -> Delta
$csin :: Delta -> Delta
logBase :: Delta -> Delta -> Delta
$clogBase :: Delta -> Delta -> Delta
** :: Delta -> Delta -> Delta
$c** :: Delta -> Delta -> Delta
sqrt :: Delta -> Delta
$csqrt :: Delta -> Delta
log :: Delta -> Delta
$clog :: Delta -> Delta
exp :: Delta -> Delta
$cexp :: Delta -> Delta
pi :: Delta
$cpi :: Delta
$cp1Floating :: Fractional Delta
Floating, Ptr b -> Int -> IO Delta
Ptr b -> Int -> Delta -> IO ()
Ptr Delta -> IO Delta
Ptr Delta -> Int -> IO Delta
Ptr Delta -> Int -> Delta -> IO ()
Ptr Delta -> Delta -> IO ()
Delta -> Int
(Delta -> Int)
-> (Delta -> Int)
-> (Ptr Delta -> Int -> IO Delta)
-> (Ptr Delta -> Int -> Delta -> IO ())
-> (forall b. Ptr b -> Int -> IO Delta)
-> (forall b. Ptr b -> Int -> Delta -> IO ())
-> (Ptr Delta -> IO Delta)
-> (Ptr Delta -> Delta -> IO ())
-> Storable Delta
forall b. Ptr b -> Int -> IO Delta
forall b. Ptr b -> Int -> Delta -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Delta -> Delta -> IO ()
$cpoke :: Ptr Delta -> Delta -> IO ()
peek :: Ptr Delta -> IO Delta
$cpeek :: Ptr Delta -> IO Delta
pokeByteOff :: Ptr b -> Int -> Delta -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Delta -> IO ()
peekByteOff :: Ptr b -> Int -> IO Delta
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Delta
pokeElemOff :: Ptr Delta -> Int -> Delta -> IO ()
$cpokeElemOff :: Ptr Delta -> Int -> Delta -> IO ()
peekElemOff :: Ptr Delta -> Int -> IO Delta
$cpeekElemOff :: Ptr Delta -> Int -> IO Delta
alignment :: Delta -> Int
$calignment :: Delta -> Int
sizeOf :: Delta -> Int
$csizeOf :: Delta -> Int
Storable)
newtype Vega     = Vega     Double deriving ((forall x. Vega -> Rep Vega x)
-> (forall x. Rep Vega x -> Vega) -> Generic Vega
forall x. Rep Vega x -> Vega
forall x. Vega -> Rep Vega x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Vega x -> Vega
$cfrom :: forall x. Vega -> Rep Vega x
Generic, Vega -> Vega -> Bool
(Vega -> Vega -> Bool) -> (Vega -> Vega -> Bool) -> Eq Vega
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Vega -> Vega -> Bool
$c/= :: Vega -> Vega -> Bool
== :: Vega -> Vega -> Bool
$c== :: Vega -> Vega -> Bool
Eq, Int -> Vega -> ShowS
[Vega] -> ShowS
Vega -> String
(Int -> Vega -> ShowS)
-> (Vega -> String) -> ([Vega] -> ShowS) -> Show Vega
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Vega] -> ShowS
$cshowList :: [Vega] -> ShowS
show :: Vega -> String
$cshow :: Vega -> String
showsPrec :: Int -> Vega -> ShowS
$cshowsPrec :: Int -> Vega -> ShowS
Show, ReadPrec [Vega]
ReadPrec Vega
Int -> ReadS Vega
ReadS [Vega]
(Int -> ReadS Vega)
-> ReadS [Vega] -> ReadPrec Vega -> ReadPrec [Vega] -> Read Vega
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Vega]
$creadListPrec :: ReadPrec [Vega]
readPrec :: ReadPrec Vega
$creadPrec :: ReadPrec Vega
readList :: ReadS [Vega]
$creadList :: ReadS [Vega]
readsPrec :: Int -> ReadS Vega
$creadsPrec :: Int -> ReadS Vega
Read, Eq Vega
Eq Vega
-> (Vega -> Vega -> Ordering)
-> (Vega -> Vega -> Bool)
-> (Vega -> Vega -> Bool)
-> (Vega -> Vega -> Bool)
-> (Vega -> Vega -> Bool)
-> (Vega -> Vega -> Vega)
-> (Vega -> Vega -> Vega)
-> Ord Vega
Vega -> Vega -> Bool
Vega -> Vega -> Ordering
Vega -> Vega -> Vega
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
min :: Vega -> Vega -> Vega
$cmin :: Vega -> Vega -> Vega
max :: Vega -> Vega -> Vega
$cmax :: Vega -> Vega -> Vega
>= :: Vega -> Vega -> Bool
$c>= :: Vega -> Vega -> Bool
> :: Vega -> Vega -> Bool
$c> :: Vega -> Vega -> Bool
<= :: Vega -> Vega -> Bool
$c<= :: Vega -> Vega -> Bool
< :: Vega -> Vega -> Bool
$c< :: Vega -> Vega -> Bool
compare :: Vega -> Vega -> Ordering
$ccompare :: Vega -> Vega -> Ordering
$cp1Ord :: Eq Vega
Ord, Integer -> Vega
Vega -> Vega
Vega -> Vega -> Vega
(Vega -> Vega -> Vega)
-> (Vega -> Vega -> Vega)
-> (Vega -> Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Integer -> Vega)
-> Num Vega
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Vega
$cfromInteger :: Integer -> Vega
signum :: Vega -> Vega
$csignum :: Vega -> Vega
abs :: Vega -> Vega
$cabs :: Vega -> Vega
negate :: Vega -> Vega
$cnegate :: Vega -> Vega
* :: Vega -> Vega -> Vega
$c* :: Vega -> Vega -> Vega
- :: Vega -> Vega -> Vega
$c- :: Vega -> Vega -> Vega
+ :: Vega -> Vega -> Vega
$c+ :: Vega -> Vega -> Vega
Num, Num Vega
Num Vega
-> (Vega -> Vega -> Vega)
-> (Vega -> Vega)
-> (Rational -> Vega)
-> Fractional Vega
Rational -> Vega
Vega -> Vega
Vega -> Vega -> Vega
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Vega
$cfromRational :: Rational -> Vega
recip :: Vega -> Vega
$crecip :: Vega -> Vega
/ :: Vega -> Vega -> Vega
$c/ :: Vega -> Vega -> Vega
$cp1Fractional :: Num Vega
Fractional, Num Vega
Ord Vega
Num Vega -> Ord Vega -> (Vega -> Rational) -> Real Vega
Vega -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Vega -> Rational
$ctoRational :: Vega -> Rational
$cp2Real :: Ord Vega
$cp1Real :: Num Vega
Real, Fractional Vega
Real Vega
Real Vega
-> Fractional Vega
-> (forall b. Integral b => Vega -> (b, Vega))
-> (forall b. Integral b => Vega -> b)
-> (forall b. Integral b => Vega -> b)
-> (forall b. Integral b => Vega -> b)
-> (forall b. Integral b => Vega -> b)
-> RealFrac Vega
Vega -> b
Vega -> b
Vega -> b
Vega -> b
Vega -> (b, Vega)
forall b. Integral b => Vega -> b
forall b. Integral b => Vega -> (b, Vega)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Vega -> b
$cfloor :: forall b. Integral b => Vega -> b
ceiling :: Vega -> b
$cceiling :: forall b. Integral b => Vega -> b
round :: Vega -> b
$cround :: forall b. Integral b => Vega -> b
truncate :: Vega -> b
$ctruncate :: forall b. Integral b => Vega -> b
properFraction :: Vega -> (b, Vega)
$cproperFraction :: forall b. Integral b => Vega -> (b, Vega)
$cp2RealFrac :: Fractional Vega
$cp1RealFrac :: Real Vega
RealFrac, Floating Vega
RealFrac Vega
RealFrac Vega
-> Floating Vega
-> (Vega -> Integer)
-> (Vega -> Int)
-> (Vega -> (Int, Int))
-> (Vega -> (Integer, Int))
-> (Integer -> Int -> Vega)
-> (Vega -> Int)
-> (Vega -> Vega)
-> (Int -> Vega -> Vega)
-> (Vega -> Bool)
-> (Vega -> Bool)
-> (Vega -> Bool)
-> (Vega -> Bool)
-> (Vega -> Bool)
-> (Vega -> Vega -> Vega)
-> RealFloat Vega
Int -> Vega -> Vega
Integer -> Int -> Vega
Vega -> Bool
Vega -> Int
Vega -> Integer
Vega -> (Int, Int)
Vega -> (Integer, Int)
Vega -> Vega
Vega -> Vega -> Vega
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Vega -> Vega -> Vega
$catan2 :: Vega -> Vega -> Vega
isIEEE :: Vega -> Bool
$cisIEEE :: Vega -> Bool
isNegativeZero :: Vega -> Bool
$cisNegativeZero :: Vega -> Bool
isDenormalized :: Vega -> Bool
$cisDenormalized :: Vega -> Bool
isInfinite :: Vega -> Bool
$cisInfinite :: Vega -> Bool
isNaN :: Vega -> Bool
$cisNaN :: Vega -> Bool
scaleFloat :: Int -> Vega -> Vega
$cscaleFloat :: Int -> Vega -> Vega
significand :: Vega -> Vega
$csignificand :: Vega -> Vega
exponent :: Vega -> Int
$cexponent :: Vega -> Int
encodeFloat :: Integer -> Int -> Vega
$cencodeFloat :: Integer -> Int -> Vega
decodeFloat :: Vega -> (Integer, Int)
$cdecodeFloat :: Vega -> (Integer, Int)
floatRange :: Vega -> (Int, Int)
$cfloatRange :: Vega -> (Int, Int)
floatDigits :: Vega -> Int
$cfloatDigits :: Vega -> Int
floatRadix :: Vega -> Integer
$cfloatRadix :: Vega -> Integer
$cp2RealFloat :: Floating Vega
$cp1RealFloat :: RealFrac Vega
RealFloat, Fractional Vega
Vega
Fractional Vega
-> Vega
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega -> Vega)
-> (Vega -> Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> (Vega -> Vega)
-> Floating Vega
Vega -> Vega
Vega -> Vega -> Vega
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Vega -> Vega
$clog1mexp :: Vega -> Vega
log1pexp :: Vega -> Vega
$clog1pexp :: Vega -> Vega
expm1 :: Vega -> Vega
$cexpm1 :: Vega -> Vega
log1p :: Vega -> Vega
$clog1p :: Vega -> Vega
atanh :: Vega -> Vega
$catanh :: Vega -> Vega
acosh :: Vega -> Vega
$cacosh :: Vega -> Vega
asinh :: Vega -> Vega
$casinh :: Vega -> Vega
tanh :: Vega -> Vega
$ctanh :: Vega -> Vega
cosh :: Vega -> Vega
$ccosh :: Vega -> Vega
sinh :: Vega -> Vega
$csinh :: Vega -> Vega
atan :: Vega -> Vega
$catan :: Vega -> Vega
acos :: Vega -> Vega
$cacos :: Vega -> Vega
asin :: Vega -> Vega
$casin :: Vega -> Vega
tan :: Vega -> Vega
$ctan :: Vega -> Vega
cos :: Vega -> Vega
$ccos :: Vega -> Vega
sin :: Vega -> Vega
$csin :: Vega -> Vega
logBase :: Vega -> Vega -> Vega
$clogBase :: Vega -> Vega -> Vega
** :: Vega -> Vega -> Vega
$c** :: Vega -> Vega -> Vega
sqrt :: Vega -> Vega
$csqrt :: Vega -> Vega
log :: Vega -> Vega
$clog :: Vega -> Vega
exp :: Vega -> Vega
$cexp :: Vega -> Vega
pi :: Vega
$cpi :: Vega
$cp1Floating :: Fractional Vega
Floating, Ptr b -> Int -> IO Vega
Ptr b -> Int -> Vega -> IO ()
Ptr Vega -> IO Vega
Ptr Vega -> Int -> IO Vega
Ptr Vega -> Int -> Vega -> IO ()
Ptr Vega -> Vega -> IO ()
Vega -> Int
(Vega -> Int)
-> (Vega -> Int)
-> (Ptr Vega -> Int -> IO Vega)
-> (Ptr Vega -> Int -> Vega -> IO ())
-> (forall b. Ptr b -> Int -> IO Vega)
-> (forall b. Ptr b -> Int -> Vega -> IO ())
-> (Ptr Vega -> IO Vega)
-> (Ptr Vega -> Vega -> IO ())
-> Storable Vega
forall b. Ptr b -> Int -> IO Vega
forall b. Ptr b -> Int -> Vega -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Vega -> Vega -> IO ()
$cpoke :: Ptr Vega -> Vega -> IO ()
peek :: Ptr Vega -> IO Vega
$cpeek :: Ptr Vega -> IO Vega
pokeByteOff :: Ptr b -> Int -> Vega -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Vega -> IO ()
peekByteOff :: Ptr b -> Int -> IO Vega
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Vega
pokeElemOff :: Ptr Vega -> Int -> Vega -> IO ()
$cpokeElemOff :: Ptr Vega -> Int -> Vega -> IO ()
peekElemOff :: Ptr Vega -> Int -> IO Vega
$cpeekElemOff :: Ptr Vega -> Int -> IO Vega
alignment :: Vega -> Int
$calignment :: Vega -> Int
sizeOf :: Vega -> Int
$csizeOf :: Vega -> Int
Storable)
newtype Gamma    = Gamma    Double deriving ((forall x. Gamma -> Rep Gamma x)
-> (forall x. Rep Gamma x -> Gamma) -> Generic Gamma
forall x. Rep Gamma x -> Gamma
forall x. Gamma -> Rep Gamma x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Gamma x -> Gamma
$cfrom :: forall x. Gamma -> Rep Gamma x
Generic, Gamma -> Gamma -> Bool
(Gamma -> Gamma -> Bool) -> (Gamma -> Gamma -> Bool) -> Eq Gamma
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Gamma -> Gamma -> Bool
$c/= :: Gamma -> Gamma -> Bool
== :: Gamma -> Gamma -> Bool
$c== :: Gamma -> Gamma -> Bool
Eq, Int -> Gamma -> ShowS
[Gamma] -> ShowS
Gamma -> String
(Int -> Gamma -> ShowS)
-> (Gamma -> String) -> ([Gamma] -> ShowS) -> Show Gamma
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Gamma] -> ShowS
$cshowList :: [Gamma] -> ShowS
show :: Gamma -> String
$cshow :: Gamma -> String
showsPrec :: Int -> Gamma -> ShowS
$cshowsPrec :: Int -> Gamma -> ShowS
Show, ReadPrec [Gamma]
ReadPrec Gamma
Int -> ReadS Gamma
ReadS [Gamma]
(Int -> ReadS Gamma)
-> ReadS [Gamma]
-> ReadPrec Gamma
-> ReadPrec [Gamma]
-> Read Gamma
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Gamma]
$creadListPrec :: ReadPrec [Gamma]
readPrec :: ReadPrec Gamma
$creadPrec :: ReadPrec Gamma
readList :: ReadS [Gamma]
$creadList :: ReadS [Gamma]
readsPrec :: Int -> ReadS Gamma
$creadsPrec :: Int -> ReadS Gamma
Read, Eq Gamma
Eq Gamma
-> (Gamma -> Gamma -> Ordering)
-> (Gamma -> Gamma -> Bool)
-> (Gamma -> Gamma -> Bool)
-> (Gamma -> Gamma -> Bool)
-> (Gamma -> Gamma -> Bool)
-> (Gamma -> Gamma -> Gamma)
-> (Gamma -> Gamma -> Gamma)
-> Ord Gamma
Gamma -> Gamma -> Bool
Gamma -> Gamma -> Ordering
Gamma -> Gamma -> Gamma
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
min :: Gamma -> Gamma -> Gamma
$cmin :: Gamma -> Gamma -> Gamma
max :: Gamma -> Gamma -> Gamma
$cmax :: Gamma -> Gamma -> Gamma
>= :: Gamma -> Gamma -> Bool
$c>= :: Gamma -> Gamma -> Bool
> :: Gamma -> Gamma -> Bool
$c> :: Gamma -> Gamma -> Bool
<= :: Gamma -> Gamma -> Bool
$c<= :: Gamma -> Gamma -> Bool
< :: Gamma -> Gamma -> Bool
$c< :: Gamma -> Gamma -> Bool
compare :: Gamma -> Gamma -> Ordering
$ccompare :: Gamma -> Gamma -> Ordering
$cp1Ord :: Eq Gamma
Ord, Integer -> Gamma
Gamma -> Gamma
Gamma -> Gamma -> Gamma
(Gamma -> Gamma -> Gamma)
-> (Gamma -> Gamma -> Gamma)
-> (Gamma -> Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Integer -> Gamma)
-> Num Gamma
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Gamma
$cfromInteger :: Integer -> Gamma
signum :: Gamma -> Gamma
$csignum :: Gamma -> Gamma
abs :: Gamma -> Gamma
$cabs :: Gamma -> Gamma
negate :: Gamma -> Gamma
$cnegate :: Gamma -> Gamma
* :: Gamma -> Gamma -> Gamma
$c* :: Gamma -> Gamma -> Gamma
- :: Gamma -> Gamma -> Gamma
$c- :: Gamma -> Gamma -> Gamma
+ :: Gamma -> Gamma -> Gamma
$c+ :: Gamma -> Gamma -> Gamma
Num, Num Gamma
Num Gamma
-> (Gamma -> Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Rational -> Gamma)
-> Fractional Gamma
Rational -> Gamma
Gamma -> Gamma
Gamma -> Gamma -> Gamma
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Gamma
$cfromRational :: Rational -> Gamma
recip :: Gamma -> Gamma
$crecip :: Gamma -> Gamma
/ :: Gamma -> Gamma -> Gamma
$c/ :: Gamma -> Gamma -> Gamma
$cp1Fractional :: Num Gamma
Fractional, Num Gamma
Ord Gamma
Num Gamma -> Ord Gamma -> (Gamma -> Rational) -> Real Gamma
Gamma -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Gamma -> Rational
$ctoRational :: Gamma -> Rational
$cp2Real :: Ord Gamma
$cp1Real :: Num Gamma
Real, Fractional Gamma
Real Gamma
Real Gamma
-> Fractional Gamma
-> (forall b. Integral b => Gamma -> (b, Gamma))
-> (forall b. Integral b => Gamma -> b)
-> (forall b. Integral b => Gamma -> b)
-> (forall b. Integral b => Gamma -> b)
-> (forall b. Integral b => Gamma -> b)
-> RealFrac Gamma
Gamma -> b
Gamma -> b
Gamma -> b
Gamma -> b
Gamma -> (b, Gamma)
forall b. Integral b => Gamma -> b
forall b. Integral b => Gamma -> (b, Gamma)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Gamma -> b
$cfloor :: forall b. Integral b => Gamma -> b
ceiling :: Gamma -> b
$cceiling :: forall b. Integral b => Gamma -> b
round :: Gamma -> b
$cround :: forall b. Integral b => Gamma -> b
truncate :: Gamma -> b
$ctruncate :: forall b. Integral b => Gamma -> b
properFraction :: Gamma -> (b, Gamma)
$cproperFraction :: forall b. Integral b => Gamma -> (b, Gamma)
$cp2RealFrac :: Fractional Gamma
$cp1RealFrac :: Real Gamma
RealFrac, Floating Gamma
RealFrac Gamma
RealFrac Gamma
-> Floating Gamma
-> (Gamma -> Integer)
-> (Gamma -> Int)
-> (Gamma -> (Int, Int))
-> (Gamma -> (Integer, Int))
-> (Integer -> Int -> Gamma)
-> (Gamma -> Int)
-> (Gamma -> Gamma)
-> (Int -> Gamma -> Gamma)
-> (Gamma -> Bool)
-> (Gamma -> Bool)
-> (Gamma -> Bool)
-> (Gamma -> Bool)
-> (Gamma -> Bool)
-> (Gamma -> Gamma -> Gamma)
-> RealFloat Gamma
Int -> Gamma -> Gamma
Integer -> Int -> Gamma
Gamma -> Bool
Gamma -> Int
Gamma -> Integer
Gamma -> (Int, Int)
Gamma -> (Integer, Int)
Gamma -> Gamma
Gamma -> Gamma -> Gamma
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Gamma -> Gamma -> Gamma
$catan2 :: Gamma -> Gamma -> Gamma
isIEEE :: Gamma -> Bool
$cisIEEE :: Gamma -> Bool
isNegativeZero :: Gamma -> Bool
$cisNegativeZero :: Gamma -> Bool
isDenormalized :: Gamma -> Bool
$cisDenormalized :: Gamma -> Bool
isInfinite :: Gamma -> Bool
$cisInfinite :: Gamma -> Bool
isNaN :: Gamma -> Bool
$cisNaN :: Gamma -> Bool
scaleFloat :: Int -> Gamma -> Gamma
$cscaleFloat :: Int -> Gamma -> Gamma
significand :: Gamma -> Gamma
$csignificand :: Gamma -> Gamma
exponent :: Gamma -> Int
$cexponent :: Gamma -> Int
encodeFloat :: Integer -> Int -> Gamma
$cencodeFloat :: Integer -> Int -> Gamma
decodeFloat :: Gamma -> (Integer, Int)
$cdecodeFloat :: Gamma -> (Integer, Int)
floatRange :: Gamma -> (Int, Int)
$cfloatRange :: Gamma -> (Int, Int)
floatDigits :: Gamma -> Int
$cfloatDigits :: Gamma -> Int
floatRadix :: Gamma -> Integer
$cfloatRadix :: Gamma -> Integer
$cp2RealFloat :: Floating Gamma
$cp1RealFloat :: RealFrac Gamma
RealFloat, Fractional Gamma
Gamma
Fractional Gamma
-> Gamma
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma -> Gamma)
-> (Gamma -> Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> (Gamma -> Gamma)
-> Floating Gamma
Gamma -> Gamma
Gamma -> Gamma -> Gamma
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Gamma -> Gamma
$clog1mexp :: Gamma -> Gamma
log1pexp :: Gamma -> Gamma
$clog1pexp :: Gamma -> Gamma
expm1 :: Gamma -> Gamma
$cexpm1 :: Gamma -> Gamma
log1p :: Gamma -> Gamma
$clog1p :: Gamma -> Gamma
atanh :: Gamma -> Gamma
$catanh :: Gamma -> Gamma
acosh :: Gamma -> Gamma
$cacosh :: Gamma -> Gamma
asinh :: Gamma -> Gamma
$casinh :: Gamma -> Gamma
tanh :: Gamma -> Gamma
$ctanh :: Gamma -> Gamma
cosh :: Gamma -> Gamma
$ccosh :: Gamma -> Gamma
sinh :: Gamma -> Gamma
$csinh :: Gamma -> Gamma
atan :: Gamma -> Gamma
$catan :: Gamma -> Gamma
acos :: Gamma -> Gamma
$cacos :: Gamma -> Gamma
asin :: Gamma -> Gamma
$casin :: Gamma -> Gamma
tan :: Gamma -> Gamma
$ctan :: Gamma -> Gamma
cos :: Gamma -> Gamma
$ccos :: Gamma -> Gamma
sin :: Gamma -> Gamma
$csin :: Gamma -> Gamma
logBase :: Gamma -> Gamma -> Gamma
$clogBase :: Gamma -> Gamma -> Gamma
** :: Gamma -> Gamma -> Gamma
$c** :: Gamma -> Gamma -> Gamma
sqrt :: Gamma -> Gamma
$csqrt :: Gamma -> Gamma
log :: Gamma -> Gamma
$clog :: Gamma -> Gamma
exp :: Gamma -> Gamma
$cexp :: Gamma -> Gamma
pi :: Gamma
$cpi :: Gamma
$cp1Floating :: Fractional Gamma
Floating, Ptr b -> Int -> IO Gamma
Ptr b -> Int -> Gamma -> IO ()
Ptr Gamma -> IO Gamma
Ptr Gamma -> Int -> IO Gamma
Ptr Gamma -> Int -> Gamma -> IO ()
Ptr Gamma -> Gamma -> IO ()
Gamma -> Int
(Gamma -> Int)
-> (Gamma -> Int)
-> (Ptr Gamma -> Int -> IO Gamma)
-> (Ptr Gamma -> Int -> Gamma -> IO ())
-> (forall b. Ptr b -> Int -> IO Gamma)
-> (forall b. Ptr b -> Int -> Gamma -> IO ())
-> (Ptr Gamma -> IO Gamma)
-> (Ptr Gamma -> Gamma -> IO ())
-> Storable Gamma
forall b. Ptr b -> Int -> IO Gamma
forall b. Ptr b -> Int -> Gamma -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Gamma -> Gamma -> IO ()
$cpoke :: Ptr Gamma -> Gamma -> IO ()
peek :: Ptr Gamma -> IO Gamma
$cpeek :: Ptr Gamma -> IO Gamma
pokeByteOff :: Ptr b -> Int -> Gamma -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Gamma -> IO ()
peekByteOff :: Ptr b -> Int -> IO Gamma
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Gamma
pokeElemOff :: Ptr Gamma -> Int -> Gamma -> IO ()
$cpokeElemOff :: Ptr Gamma -> Int -> Gamma -> IO ()
peekElemOff :: Ptr Gamma -> Int -> IO Gamma
$cpeekElemOff :: Ptr Gamma -> Int -> IO Gamma
alignment :: Gamma -> Int
$calignment :: Gamma -> Int
sizeOf :: Gamma -> Int
$csizeOf :: Gamma -> Int
Storable)

newtype YearFrac = YearFrac {YearFrac -> Double
unYearFrac:: Double} deriving ((forall x. YearFrac -> Rep YearFrac x)
-> (forall x. Rep YearFrac x -> YearFrac) -> Generic YearFrac
forall x. Rep YearFrac x -> YearFrac
forall x. YearFrac -> Rep YearFrac x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep YearFrac x -> YearFrac
$cfrom :: forall x. YearFrac -> Rep YearFrac x
Generic, YearFrac -> YearFrac -> Bool
(YearFrac -> YearFrac -> Bool)
-> (YearFrac -> YearFrac -> Bool) -> Eq YearFrac
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: YearFrac -> YearFrac -> Bool
$c/= :: YearFrac -> YearFrac -> Bool
== :: YearFrac -> YearFrac -> Bool
$c== :: YearFrac -> YearFrac -> Bool
Eq, Int -> YearFrac -> ShowS
[YearFrac] -> ShowS
YearFrac -> String
(Int -> YearFrac -> ShowS)
-> (YearFrac -> String) -> ([YearFrac] -> ShowS) -> Show YearFrac
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [YearFrac] -> ShowS
$cshowList :: [YearFrac] -> ShowS
show :: YearFrac -> String
$cshow :: YearFrac -> String
showsPrec :: Int -> YearFrac -> ShowS
$cshowsPrec :: Int -> YearFrac -> ShowS
Show, ReadPrec [YearFrac]
ReadPrec YearFrac
Int -> ReadS YearFrac
ReadS [YearFrac]
(Int -> ReadS YearFrac)
-> ReadS [YearFrac]
-> ReadPrec YearFrac
-> ReadPrec [YearFrac]
-> Read YearFrac
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [YearFrac]
$creadListPrec :: ReadPrec [YearFrac]
readPrec :: ReadPrec YearFrac
$creadPrec :: ReadPrec YearFrac
readList :: ReadS [YearFrac]
$creadList :: ReadS [YearFrac]
readsPrec :: Int -> ReadS YearFrac
$creadsPrec :: Int -> ReadS YearFrac
Read, Eq YearFrac
Eq YearFrac
-> (YearFrac -> YearFrac -> Ordering)
-> (YearFrac -> YearFrac -> Bool)
-> (YearFrac -> YearFrac -> Bool)
-> (YearFrac -> YearFrac -> Bool)
-> (YearFrac -> YearFrac -> Bool)
-> (YearFrac -> YearFrac -> YearFrac)
-> (YearFrac -> YearFrac -> YearFrac)
-> Ord YearFrac
YearFrac -> YearFrac -> Bool
YearFrac -> YearFrac -> Ordering
YearFrac -> YearFrac -> YearFrac
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
min :: YearFrac -> YearFrac -> YearFrac
$cmin :: YearFrac -> YearFrac -> YearFrac
max :: YearFrac -> YearFrac -> YearFrac
$cmax :: YearFrac -> YearFrac -> YearFrac
>= :: YearFrac -> YearFrac -> Bool
$c>= :: YearFrac -> YearFrac -> Bool
> :: YearFrac -> YearFrac -> Bool
$c> :: YearFrac -> YearFrac -> Bool
<= :: YearFrac -> YearFrac -> Bool
$c<= :: YearFrac -> YearFrac -> Bool
< :: YearFrac -> YearFrac -> Bool
$c< :: YearFrac -> YearFrac -> Bool
compare :: YearFrac -> YearFrac -> Ordering
$ccompare :: YearFrac -> YearFrac -> Ordering
$cp1Ord :: Eq YearFrac
Ord, Integer -> YearFrac
YearFrac -> YearFrac
YearFrac -> YearFrac -> YearFrac
(YearFrac -> YearFrac -> YearFrac)
-> (YearFrac -> YearFrac -> YearFrac)
-> (YearFrac -> YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (Integer -> YearFrac)
-> Num YearFrac
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> YearFrac
$cfromInteger :: Integer -> YearFrac
signum :: YearFrac -> YearFrac
$csignum :: YearFrac -> YearFrac
abs :: YearFrac -> YearFrac
$cabs :: YearFrac -> YearFrac
negate :: YearFrac -> YearFrac
$cnegate :: YearFrac -> YearFrac
* :: YearFrac -> YearFrac -> YearFrac
$c* :: YearFrac -> YearFrac -> YearFrac
- :: YearFrac -> YearFrac -> YearFrac
$c- :: YearFrac -> YearFrac -> YearFrac
+ :: YearFrac -> YearFrac -> YearFrac
$c+ :: YearFrac -> YearFrac -> YearFrac
Num, Num YearFrac
Num YearFrac
-> (YearFrac -> YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (Rational -> YearFrac)
-> Fractional YearFrac
Rational -> YearFrac
YearFrac -> YearFrac
YearFrac -> YearFrac -> YearFrac
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> YearFrac
$cfromRational :: Rational -> YearFrac
recip :: YearFrac -> YearFrac
$crecip :: YearFrac -> YearFrac
/ :: YearFrac -> YearFrac -> YearFrac
$c/ :: YearFrac -> YearFrac -> YearFrac
$cp1Fractional :: Num YearFrac
Fractional, Num YearFrac
Ord YearFrac
Num YearFrac
-> Ord YearFrac -> (YearFrac -> Rational) -> Real YearFrac
YearFrac -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: YearFrac -> Rational
$ctoRational :: YearFrac -> Rational
$cp2Real :: Ord YearFrac
$cp1Real :: Num YearFrac
Real, Fractional YearFrac
Real YearFrac
Real YearFrac
-> Fractional YearFrac
-> (forall b. Integral b => YearFrac -> (b, YearFrac))
-> (forall b. Integral b => YearFrac -> b)
-> (forall b. Integral b => YearFrac -> b)
-> (forall b. Integral b => YearFrac -> b)
-> (forall b. Integral b => YearFrac -> b)
-> RealFrac YearFrac
YearFrac -> b
YearFrac -> b
YearFrac -> b
YearFrac -> b
YearFrac -> (b, YearFrac)
forall b. Integral b => YearFrac -> b
forall b. Integral b => YearFrac -> (b, YearFrac)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: YearFrac -> b
$cfloor :: forall b. Integral b => YearFrac -> b
ceiling :: YearFrac -> b
$cceiling :: forall b. Integral b => YearFrac -> b
round :: YearFrac -> b
$cround :: forall b. Integral b => YearFrac -> b
truncate :: YearFrac -> b
$ctruncate :: forall b. Integral b => YearFrac -> b
properFraction :: YearFrac -> (b, YearFrac)
$cproperFraction :: forall b. Integral b => YearFrac -> (b, YearFrac)
$cp2RealFrac :: Fractional YearFrac
$cp1RealFrac :: Real YearFrac
RealFrac, Floating YearFrac
RealFrac YearFrac
RealFrac YearFrac
-> Floating YearFrac
-> (YearFrac -> Integer)
-> (YearFrac -> Int)
-> (YearFrac -> (Int, Int))
-> (YearFrac -> (Integer, Int))
-> (Integer -> Int -> YearFrac)
-> (YearFrac -> Int)
-> (YearFrac -> YearFrac)
-> (Int -> YearFrac -> YearFrac)
-> (YearFrac -> Bool)
-> (YearFrac -> Bool)
-> (YearFrac -> Bool)
-> (YearFrac -> Bool)
-> (YearFrac -> Bool)
-> (YearFrac -> YearFrac -> YearFrac)
-> RealFloat YearFrac
Int -> YearFrac -> YearFrac
Integer -> Int -> YearFrac
YearFrac -> Bool
YearFrac -> Int
YearFrac -> Integer
YearFrac -> (Int, Int)
YearFrac -> (Integer, Int)
YearFrac -> YearFrac
YearFrac -> YearFrac -> YearFrac
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: YearFrac -> YearFrac -> YearFrac
$catan2 :: YearFrac -> YearFrac -> YearFrac
isIEEE :: YearFrac -> Bool
$cisIEEE :: YearFrac -> Bool
isNegativeZero :: YearFrac -> Bool
$cisNegativeZero :: YearFrac -> Bool
isDenormalized :: YearFrac -> Bool
$cisDenormalized :: YearFrac -> Bool
isInfinite :: YearFrac -> Bool
$cisInfinite :: YearFrac -> Bool
isNaN :: YearFrac -> Bool
$cisNaN :: YearFrac -> Bool
scaleFloat :: Int -> YearFrac -> YearFrac
$cscaleFloat :: Int -> YearFrac -> YearFrac
significand :: YearFrac -> YearFrac
$csignificand :: YearFrac -> YearFrac
exponent :: YearFrac -> Int
$cexponent :: YearFrac -> Int
encodeFloat :: Integer -> Int -> YearFrac
$cencodeFloat :: Integer -> Int -> YearFrac
decodeFloat :: YearFrac -> (Integer, Int)
$cdecodeFloat :: YearFrac -> (Integer, Int)
floatRange :: YearFrac -> (Int, Int)
$cfloatRange :: YearFrac -> (Int, Int)
floatDigits :: YearFrac -> Int
$cfloatDigits :: YearFrac -> Int
floatRadix :: YearFrac -> Integer
$cfloatRadix :: YearFrac -> Integer
$cp2RealFloat :: Floating YearFrac
$cp1RealFloat :: RealFrac YearFrac
RealFloat, Fractional YearFrac
YearFrac
Fractional YearFrac
-> YearFrac
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac -> YearFrac)
-> (YearFrac -> YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> (YearFrac -> YearFrac)
-> Floating YearFrac
YearFrac -> YearFrac
YearFrac -> YearFrac -> YearFrac
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: YearFrac -> YearFrac
$clog1mexp :: YearFrac -> YearFrac
log1pexp :: YearFrac -> YearFrac
$clog1pexp :: YearFrac -> YearFrac
expm1 :: YearFrac -> YearFrac
$cexpm1 :: YearFrac -> YearFrac
log1p :: YearFrac -> YearFrac
$clog1p :: YearFrac -> YearFrac
atanh :: YearFrac -> YearFrac
$catanh :: YearFrac -> YearFrac
acosh :: YearFrac -> YearFrac
$cacosh :: YearFrac -> YearFrac
asinh :: YearFrac -> YearFrac
$casinh :: YearFrac -> YearFrac
tanh :: YearFrac -> YearFrac
$ctanh :: YearFrac -> YearFrac
cosh :: YearFrac -> YearFrac
$ccosh :: YearFrac -> YearFrac
sinh :: YearFrac -> YearFrac
$csinh :: YearFrac -> YearFrac
atan :: YearFrac -> YearFrac
$catan :: YearFrac -> YearFrac
acos :: YearFrac -> YearFrac
$cacos :: YearFrac -> YearFrac
asin :: YearFrac -> YearFrac
$casin :: YearFrac -> YearFrac
tan :: YearFrac -> YearFrac
$ctan :: YearFrac -> YearFrac
cos :: YearFrac -> YearFrac
$ccos :: YearFrac -> YearFrac
sin :: YearFrac -> YearFrac
$csin :: YearFrac -> YearFrac
logBase :: YearFrac -> YearFrac -> YearFrac
$clogBase :: YearFrac -> YearFrac -> YearFrac
** :: YearFrac -> YearFrac -> YearFrac
$c** :: YearFrac -> YearFrac -> YearFrac
sqrt :: YearFrac -> YearFrac
$csqrt :: YearFrac -> YearFrac
log :: YearFrac -> YearFrac
$clog :: YearFrac -> YearFrac
exp :: YearFrac -> YearFrac
$cexp :: YearFrac -> YearFrac
pi :: YearFrac
$cpi :: YearFrac
$cp1Floating :: Fractional YearFrac
Floating, Ptr b -> Int -> IO YearFrac
Ptr b -> Int -> YearFrac -> IO ()
Ptr YearFrac -> IO YearFrac
Ptr YearFrac -> Int -> IO YearFrac
Ptr YearFrac -> Int -> YearFrac -> IO ()
Ptr YearFrac -> YearFrac -> IO ()
YearFrac -> Int
(YearFrac -> Int)
-> (YearFrac -> Int)
-> (Ptr YearFrac -> Int -> IO YearFrac)
-> (Ptr YearFrac -> Int -> YearFrac -> IO ())
-> (forall b. Ptr b -> Int -> IO YearFrac)
-> (forall b. Ptr b -> Int -> YearFrac -> IO ())
-> (Ptr YearFrac -> IO YearFrac)
-> (Ptr YearFrac -> YearFrac -> IO ())
-> Storable YearFrac
forall b. Ptr b -> Int -> IO YearFrac
forall b. Ptr b -> Int -> YearFrac -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr YearFrac -> YearFrac -> IO ()
$cpoke :: Ptr YearFrac -> YearFrac -> IO ()
peek :: Ptr YearFrac -> IO YearFrac
$cpeek :: Ptr YearFrac -> IO YearFrac
pokeByteOff :: Ptr b -> Int -> YearFrac -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> YearFrac -> IO ()
peekByteOff :: Ptr b -> Int -> IO YearFrac
$cpeekByteOff :: forall b. Ptr b -> Int -> IO YearFrac
pokeElemOff :: Ptr YearFrac -> Int -> YearFrac -> IO ()
$cpokeElemOff :: Ptr YearFrac -> Int -> YearFrac -> IO ()
peekElemOff :: Ptr YearFrac -> Int -> IO YearFrac
$cpeekElemOff :: Ptr YearFrac -> Int -> IO YearFrac
alignment :: YearFrac -> Int
$calignment :: YearFrac -> Int
sizeOf :: YearFrac -> Int
$csizeOf :: YearFrac -> Int
Storable)

newtype Rate     = Rate Double deriving ((forall x. Rate -> Rep Rate x)
-> (forall x. Rep Rate x -> Rate) -> Generic Rate
forall x. Rep Rate x -> Rate
forall x. Rate -> Rep Rate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Rate x -> Rate
$cfrom :: forall x. Rate -> Rep Rate x
Generic, Rate -> Rate -> Bool
(Rate -> Rate -> Bool) -> (Rate -> Rate -> Bool) -> Eq Rate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Rate -> Rate -> Bool
$c/= :: Rate -> Rate -> Bool
== :: Rate -> Rate -> Bool
$c== :: Rate -> Rate -> Bool
Eq, Int -> Rate -> ShowS
[Rate] -> ShowS
Rate -> String
(Int -> Rate -> ShowS)
-> (Rate -> String) -> ([Rate] -> ShowS) -> Show Rate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Rate] -> ShowS
$cshowList :: [Rate] -> ShowS
show :: Rate -> String
$cshow :: Rate -> String
showsPrec :: Int -> Rate -> ShowS
$cshowsPrec :: Int -> Rate -> ShowS
Show, ReadPrec [Rate]
ReadPrec Rate
Int -> ReadS Rate
ReadS [Rate]
(Int -> ReadS Rate)
-> ReadS [Rate] -> ReadPrec Rate -> ReadPrec [Rate] -> Read Rate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Rate]
$creadListPrec :: ReadPrec [Rate]
readPrec :: ReadPrec Rate
$creadPrec :: ReadPrec Rate
readList :: ReadS [Rate]
$creadList :: ReadS [Rate]
readsPrec :: Int -> ReadS Rate
$creadsPrec :: Int -> ReadS Rate
Read, Eq Rate
Eq Rate
-> (Rate -> Rate -> Ordering)
-> (Rate -> Rate -> Bool)
-> (Rate -> Rate -> Bool)
-> (Rate -> Rate -> Bool)
-> (Rate -> Rate -> Bool)
-> (Rate -> Rate -> Rate)
-> (Rate -> Rate -> Rate)
-> Ord Rate
Rate -> Rate -> Bool
Rate -> Rate -> Ordering
Rate -> Rate -> Rate
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
min :: Rate -> Rate -> Rate
$cmin :: Rate -> Rate -> Rate
max :: Rate -> Rate -> Rate
$cmax :: Rate -> Rate -> Rate
>= :: Rate -> Rate -> Bool
$c>= :: Rate -> Rate -> Bool
> :: Rate -> Rate -> Bool
$c> :: Rate -> Rate -> Bool
<= :: Rate -> Rate -> Bool
$c<= :: Rate -> Rate -> Bool
< :: Rate -> Rate -> Bool
$c< :: Rate -> Rate -> Bool
compare :: Rate -> Rate -> Ordering
$ccompare :: Rate -> Rate -> Ordering
$cp1Ord :: Eq Rate
Ord, Integer -> Rate
Rate -> Rate
Rate -> Rate -> Rate
(Rate -> Rate -> Rate)
-> (Rate -> Rate -> Rate)
-> (Rate -> Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Integer -> Rate)
-> Num Rate
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Rate
$cfromInteger :: Integer -> Rate
signum :: Rate -> Rate
$csignum :: Rate -> Rate
abs :: Rate -> Rate
$cabs :: Rate -> Rate
negate :: Rate -> Rate
$cnegate :: Rate -> Rate
* :: Rate -> Rate -> Rate
$c* :: Rate -> Rate -> Rate
- :: Rate -> Rate -> Rate
$c- :: Rate -> Rate -> Rate
+ :: Rate -> Rate -> Rate
$c+ :: Rate -> Rate -> Rate
Num, Num Rate
Num Rate
-> (Rate -> Rate -> Rate)
-> (Rate -> Rate)
-> (Rational -> Rate)
-> Fractional Rate
Rational -> Rate
Rate -> Rate
Rate -> Rate -> Rate
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Rate
$cfromRational :: Rational -> Rate
recip :: Rate -> Rate
$crecip :: Rate -> Rate
/ :: Rate -> Rate -> Rate
$c/ :: Rate -> Rate -> Rate
$cp1Fractional :: Num Rate
Fractional, Num Rate
Ord Rate
Num Rate -> Ord Rate -> (Rate -> Rational) -> Real Rate
Rate -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Rate -> Rational
$ctoRational :: Rate -> Rational
$cp2Real :: Ord Rate
$cp1Real :: Num Rate
Real, Fractional Rate
Real Rate
Real Rate
-> Fractional Rate
-> (forall b. Integral b => Rate -> (b, Rate))
-> (forall b. Integral b => Rate -> b)
-> (forall b. Integral b => Rate -> b)
-> (forall b. Integral b => Rate -> b)
-> (forall b. Integral b => Rate -> b)
-> RealFrac Rate
Rate -> b
Rate -> b
Rate -> b
Rate -> b
Rate -> (b, Rate)
forall b. Integral b => Rate -> b
forall b. Integral b => Rate -> (b, Rate)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Rate -> b
$cfloor :: forall b. Integral b => Rate -> b
ceiling :: Rate -> b
$cceiling :: forall b. Integral b => Rate -> b
round :: Rate -> b
$cround :: forall b. Integral b => Rate -> b
truncate :: Rate -> b
$ctruncate :: forall b. Integral b => Rate -> b
properFraction :: Rate -> (b, Rate)
$cproperFraction :: forall b. Integral b => Rate -> (b, Rate)
$cp2RealFrac :: Fractional Rate
$cp1RealFrac :: Real Rate
RealFrac, Floating Rate
RealFrac Rate
RealFrac Rate
-> Floating Rate
-> (Rate -> Integer)
-> (Rate -> Int)
-> (Rate -> (Int, Int))
-> (Rate -> (Integer, Int))
-> (Integer -> Int -> Rate)
-> (Rate -> Int)
-> (Rate -> Rate)
-> (Int -> Rate -> Rate)
-> (Rate -> Bool)
-> (Rate -> Bool)
-> (Rate -> Bool)
-> (Rate -> Bool)
-> (Rate -> Bool)
-> (Rate -> Rate -> Rate)
-> RealFloat Rate
Int -> Rate -> Rate
Integer -> Int -> Rate
Rate -> Bool
Rate -> Int
Rate -> Integer
Rate -> (Int, Int)
Rate -> (Integer, Int)
Rate -> Rate
Rate -> Rate -> Rate
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Rate -> Rate -> Rate
$catan2 :: Rate -> Rate -> Rate
isIEEE :: Rate -> Bool
$cisIEEE :: Rate -> Bool
isNegativeZero :: Rate -> Bool
$cisNegativeZero :: Rate -> Bool
isDenormalized :: Rate -> Bool
$cisDenormalized :: Rate -> Bool
isInfinite :: Rate -> Bool
$cisInfinite :: Rate -> Bool
isNaN :: Rate -> Bool
$cisNaN :: Rate -> Bool
scaleFloat :: Int -> Rate -> Rate
$cscaleFloat :: Int -> Rate -> Rate
significand :: Rate -> Rate
$csignificand :: Rate -> Rate
exponent :: Rate -> Int
$cexponent :: Rate -> Int
encodeFloat :: Integer -> Int -> Rate
$cencodeFloat :: Integer -> Int -> Rate
decodeFloat :: Rate -> (Integer, Int)
$cdecodeFloat :: Rate -> (Integer, Int)
floatRange :: Rate -> (Int, Int)
$cfloatRange :: Rate -> (Int, Int)
floatDigits :: Rate -> Int
$cfloatDigits :: Rate -> Int
floatRadix :: Rate -> Integer
$cfloatRadix :: Rate -> Integer
$cp2RealFloat :: Floating Rate
$cp1RealFloat :: RealFrac Rate
RealFloat, Fractional Rate
Rate
Fractional Rate
-> Rate
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate -> Rate)
-> (Rate -> Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> (Rate -> Rate)
-> Floating Rate
Rate -> Rate
Rate -> Rate -> Rate
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Rate -> Rate
$clog1mexp :: Rate -> Rate
log1pexp :: Rate -> Rate
$clog1pexp :: Rate -> Rate
expm1 :: Rate -> Rate
$cexpm1 :: Rate -> Rate
log1p :: Rate -> Rate
$clog1p :: Rate -> Rate
atanh :: Rate -> Rate
$catanh :: Rate -> Rate
acosh :: Rate -> Rate
$cacosh :: Rate -> Rate
asinh :: Rate -> Rate
$casinh :: Rate -> Rate
tanh :: Rate -> Rate
$ctanh :: Rate -> Rate
cosh :: Rate -> Rate
$ccosh :: Rate -> Rate
sinh :: Rate -> Rate
$csinh :: Rate -> Rate
atan :: Rate -> Rate
$catan :: Rate -> Rate
acos :: Rate -> Rate
$cacos :: Rate -> Rate
asin :: Rate -> Rate
$casin :: Rate -> Rate
tan :: Rate -> Rate
$ctan :: Rate -> Rate
cos :: Rate -> Rate
$ccos :: Rate -> Rate
sin :: Rate -> Rate
$csin :: Rate -> Rate
logBase :: Rate -> Rate -> Rate
$clogBase :: Rate -> Rate -> Rate
** :: Rate -> Rate -> Rate
$c** :: Rate -> Rate -> Rate
sqrt :: Rate -> Rate
$csqrt :: Rate -> Rate
log :: Rate -> Rate
$clog :: Rate -> Rate
exp :: Rate -> Rate
$cexp :: Rate -> Rate
pi :: Rate
$cpi :: Rate
$cp1Floating :: Fractional Rate
Floating, Ptr b -> Int -> IO Rate
Ptr b -> Int -> Rate -> IO ()
Ptr Rate -> IO Rate
Ptr Rate -> Int -> IO Rate
Ptr Rate -> Int -> Rate -> IO ()
Ptr Rate -> Rate -> IO ()
Rate -> Int
(Rate -> Int)
-> (Rate -> Int)
-> (Ptr Rate -> Int -> IO Rate)
-> (Ptr Rate -> Int -> Rate -> IO ())
-> (forall b. Ptr b -> Int -> IO Rate)
-> (forall b. Ptr b -> Int -> Rate -> IO ())
-> (Ptr Rate -> IO Rate)
-> (Ptr Rate -> Rate -> IO ())
-> Storable Rate
forall b. Ptr b -> Int -> IO Rate
forall b. Ptr b -> Int -> Rate -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Rate -> Rate -> IO ()
$cpoke :: Ptr Rate -> Rate -> IO ()
peek :: Ptr Rate -> IO Rate
$cpeek :: Ptr Rate -> IO Rate
pokeByteOff :: Ptr b -> Int -> Rate -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Rate -> IO ()
peekByteOff :: Ptr b -> Int -> IO Rate
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Rate
pokeElemOff :: Ptr Rate -> Int -> Rate -> IO ()
$cpokeElemOff :: Ptr Rate -> Int -> Rate -> IO ()
peekElemOff :: Ptr Rate -> Int -> IO Rate
$cpeekElemOff :: Ptr Rate -> Int -> IO Rate
alignment :: Rate -> Int
$calignment :: Rate -> Int
sizeOf :: Rate -> Int
$csizeOf :: Rate -> Int
Storable)
newtype DF       = DF   Double deriving ((forall x. DF -> Rep DF x)
-> (forall x. Rep DF x -> DF) -> Generic DF
forall x. Rep DF x -> DF
forall x. DF -> Rep DF x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DF x -> DF
$cfrom :: forall x. DF -> Rep DF x
Generic, DF -> DF -> Bool
(DF -> DF -> Bool) -> (DF -> DF -> Bool) -> Eq DF
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DF -> DF -> Bool
$c/= :: DF -> DF -> Bool
== :: DF -> DF -> Bool
$c== :: DF -> DF -> Bool
Eq, Int -> DF -> ShowS
[DF] -> ShowS
DF -> String
(Int -> DF -> ShowS)
-> (DF -> String) -> ([DF] -> ShowS) -> Show DF
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DF] -> ShowS
$cshowList :: [DF] -> ShowS
show :: DF -> String
$cshow :: DF -> String
showsPrec :: Int -> DF -> ShowS
$cshowsPrec :: Int -> DF -> ShowS
Show, ReadPrec [DF]
ReadPrec DF
Int -> ReadS DF
ReadS [DF]
(Int -> ReadS DF)
-> ReadS [DF] -> ReadPrec DF -> ReadPrec [DF] -> Read DF
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DF]
$creadListPrec :: ReadPrec [DF]
readPrec :: ReadPrec DF
$creadPrec :: ReadPrec DF
readList :: ReadS [DF]
$creadList :: ReadS [DF]
readsPrec :: Int -> ReadS DF
$creadsPrec :: Int -> ReadS DF
Read, Eq DF
Eq DF
-> (DF -> DF -> Ordering)
-> (DF -> DF -> Bool)
-> (DF -> DF -> Bool)
-> (DF -> DF -> Bool)
-> (DF -> DF -> Bool)
-> (DF -> DF -> DF)
-> (DF -> DF -> DF)
-> Ord DF
DF -> DF -> Bool
DF -> DF -> Ordering
DF -> DF -> DF
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
min :: DF -> DF -> DF
$cmin :: DF -> DF -> DF
max :: DF -> DF -> DF
$cmax :: DF -> DF -> DF
>= :: DF -> DF -> Bool
$c>= :: DF -> DF -> Bool
> :: DF -> DF -> Bool
$c> :: DF -> DF -> Bool
<= :: DF -> DF -> Bool
$c<= :: DF -> DF -> Bool
< :: DF -> DF -> Bool
$c< :: DF -> DF -> Bool
compare :: DF -> DF -> Ordering
$ccompare :: DF -> DF -> Ordering
$cp1Ord :: Eq DF
Ord, Integer -> DF
DF -> DF
DF -> DF -> DF
(DF -> DF -> DF)
-> (DF -> DF -> DF)
-> (DF -> DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (Integer -> DF)
-> Num DF
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> DF
$cfromInteger :: Integer -> DF
signum :: DF -> DF
$csignum :: DF -> DF
abs :: DF -> DF
$cabs :: DF -> DF
negate :: DF -> DF
$cnegate :: DF -> DF
* :: DF -> DF -> DF
$c* :: DF -> DF -> DF
- :: DF -> DF -> DF
$c- :: DF -> DF -> DF
+ :: DF -> DF -> DF
$c+ :: DF -> DF -> DF
Num, Num DF
Num DF
-> (DF -> DF -> DF)
-> (DF -> DF)
-> (Rational -> DF)
-> Fractional DF
Rational -> DF
DF -> DF
DF -> DF -> DF
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> DF
$cfromRational :: Rational -> DF
recip :: DF -> DF
$crecip :: DF -> DF
/ :: DF -> DF -> DF
$c/ :: DF -> DF -> DF
$cp1Fractional :: Num DF
Fractional, Num DF
Ord DF
Num DF -> Ord DF -> (DF -> Rational) -> Real DF
DF -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: DF -> Rational
$ctoRational :: DF -> Rational
$cp2Real :: Ord DF
$cp1Real :: Num DF
Real, Fractional DF
Real DF
Real DF
-> Fractional DF
-> (forall b. Integral b => DF -> (b, DF))
-> (forall b. Integral b => DF -> b)
-> (forall b. Integral b => DF -> b)
-> (forall b. Integral b => DF -> b)
-> (forall b. Integral b => DF -> b)
-> RealFrac DF
DF -> b
DF -> b
DF -> b
DF -> b
DF -> (b, DF)
forall b. Integral b => DF -> b
forall b. Integral b => DF -> (b, DF)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: DF -> b
$cfloor :: forall b. Integral b => DF -> b
ceiling :: DF -> b
$cceiling :: forall b. Integral b => DF -> b
round :: DF -> b
$cround :: forall b. Integral b => DF -> b
truncate :: DF -> b
$ctruncate :: forall b. Integral b => DF -> b
properFraction :: DF -> (b, DF)
$cproperFraction :: forall b. Integral b => DF -> (b, DF)
$cp2RealFrac :: Fractional DF
$cp1RealFrac :: Real DF
RealFrac, Floating DF
RealFrac DF
RealFrac DF
-> Floating DF
-> (DF -> Integer)
-> (DF -> Int)
-> (DF -> (Int, Int))
-> (DF -> (Integer, Int))
-> (Integer -> Int -> DF)
-> (DF -> Int)
-> (DF -> DF)
-> (Int -> DF -> DF)
-> (DF -> Bool)
-> (DF -> Bool)
-> (DF -> Bool)
-> (DF -> Bool)
-> (DF -> Bool)
-> (DF -> DF -> DF)
-> RealFloat DF
Int -> DF -> DF
Integer -> Int -> DF
DF -> Bool
DF -> Int
DF -> Integer
DF -> (Int, Int)
DF -> (Integer, Int)
DF -> DF
DF -> DF -> DF
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: DF -> DF -> DF
$catan2 :: DF -> DF -> DF
isIEEE :: DF -> Bool
$cisIEEE :: DF -> Bool
isNegativeZero :: DF -> Bool
$cisNegativeZero :: DF -> Bool
isDenormalized :: DF -> Bool
$cisDenormalized :: DF -> Bool
isInfinite :: DF -> Bool
$cisInfinite :: DF -> Bool
isNaN :: DF -> Bool
$cisNaN :: DF -> Bool
scaleFloat :: Int -> DF -> DF
$cscaleFloat :: Int -> DF -> DF
significand :: DF -> DF
$csignificand :: DF -> DF
exponent :: DF -> Int
$cexponent :: DF -> Int
encodeFloat :: Integer -> Int -> DF
$cencodeFloat :: Integer -> Int -> DF
decodeFloat :: DF -> (Integer, Int)
$cdecodeFloat :: DF -> (Integer, Int)
floatRange :: DF -> (Int, Int)
$cfloatRange :: DF -> (Int, Int)
floatDigits :: DF -> Int
$cfloatDigits :: DF -> Int
floatRadix :: DF -> Integer
$cfloatRadix :: DF -> Integer
$cp2RealFloat :: Floating DF
$cp1RealFloat :: RealFrac DF
RealFloat, Fractional DF
DF
Fractional DF
-> DF
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF -> DF)
-> (DF -> DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> (DF -> DF)
-> Floating DF
DF -> DF
DF -> DF -> DF
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: DF -> DF
$clog1mexp :: DF -> DF
log1pexp :: DF -> DF
$clog1pexp :: DF -> DF
expm1 :: DF -> DF
$cexpm1 :: DF -> DF
log1p :: DF -> DF
$clog1p :: DF -> DF
atanh :: DF -> DF
$catanh :: DF -> DF
acosh :: DF -> DF
$cacosh :: DF -> DF
asinh :: DF -> DF
$casinh :: DF -> DF
tanh :: DF -> DF
$ctanh :: DF -> DF
cosh :: DF -> DF
$ccosh :: DF -> DF
sinh :: DF -> DF
$csinh :: DF -> DF
atan :: DF -> DF
$catan :: DF -> DF
acos :: DF -> DF
$cacos :: DF -> DF
asin :: DF -> DF
$casin :: DF -> DF
tan :: DF -> DF
$ctan :: DF -> DF
cos :: DF -> DF
$ccos :: DF -> DF
sin :: DF -> DF
$csin :: DF -> DF
logBase :: DF -> DF -> DF
$clogBase :: DF -> DF -> DF
** :: DF -> DF -> DF
$c** :: DF -> DF -> DF
sqrt :: DF -> DF
$csqrt :: DF -> DF
log :: DF -> DF
$clog :: DF -> DF
exp :: DF -> DF
$cexp :: DF -> DF
pi :: DF
$cpi :: DF
$cp1Floating :: Fractional DF
Floating, Ptr b -> Int -> IO DF
Ptr b -> Int -> DF -> IO ()
Ptr DF -> IO DF
Ptr DF -> Int -> IO DF
Ptr DF -> Int -> DF -> IO ()
Ptr DF -> DF -> IO ()
DF -> Int
(DF -> Int)
-> (DF -> Int)
-> (Ptr DF -> Int -> IO DF)
-> (Ptr DF -> Int -> DF -> IO ())
-> (forall b. Ptr b -> Int -> IO DF)
-> (forall b. Ptr b -> Int -> DF -> IO ())
-> (Ptr DF -> IO DF)
-> (Ptr DF -> DF -> IO ())
-> Storable DF
forall b. Ptr b -> Int -> IO DF
forall b. Ptr b -> Int -> DF -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr DF -> DF -> IO ()
$cpoke :: Ptr DF -> DF -> IO ()
peek :: Ptr DF -> IO DF
$cpeek :: Ptr DF -> IO DF
pokeByteOff :: Ptr b -> Int -> DF -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> DF -> IO ()
peekByteOff :: Ptr b -> Int -> IO DF
$cpeekByteOff :: forall b. Ptr b -> Int -> IO DF
pokeElemOff :: Ptr DF -> Int -> DF -> IO ()
$cpokeElemOff :: Ptr DF -> Int -> DF -> IO ()
peekElemOff :: Ptr DF -> Int -> IO DF
$cpeekElemOff :: Ptr DF -> Int -> IO DF
alignment :: DF -> Int
$calignment :: DF -> Int
sizeOf :: DF -> Int
$csizeOf :: DF -> Int
Storable)

discountFactor :: YearFrac -> Rate -> DF
discountFactor (YearFrac Double
t) (Rate Double
r) = Double -> DF
DF (Double -> DF) -> Double -> DF
forall a b. (a -> b) -> a -> b
$ Double -> Double
forall a. Floating a => a -> a
exp ((-Double
r) Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
t)
discount :: DF -> Double -> Double
discount (DF Double
df) Double
p = Double
p Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
df
undiscount :: DF -> Double -> Double
undiscount (DF Double
df) Double
p = Double
p Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
df

rateFromDiscount :: YearFrac -> DF -> Rate
rateFromDiscount (YearFrac Double
t) (DF Double
df) = Double -> Rate
Rate (Double -> Rate) -> Double -> Rate
forall a b. (a -> b) -> a -> b
$ - (Double -> Double
forall a. Floating a => a -> a
log Double
df) Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
t

newtype Vol      = Vol       Double deriving ((forall x. Vol -> Rep Vol x)
-> (forall x. Rep Vol x -> Vol) -> Generic Vol
forall x. Rep Vol x -> Vol
forall x. Vol -> Rep Vol x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Vol x -> Vol
$cfrom :: forall x. Vol -> Rep Vol x
Generic, Vol -> Vol -> Bool
(Vol -> Vol -> Bool) -> (Vol -> Vol -> Bool) -> Eq Vol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Vol -> Vol -> Bool
$c/= :: Vol -> Vol -> Bool
== :: Vol -> Vol -> Bool
$c== :: Vol -> Vol -> Bool
Eq, Int -> Vol -> ShowS
[Vol] -> ShowS
Vol -> String
(Int -> Vol -> ShowS)
-> (Vol -> String) -> ([Vol] -> ShowS) -> Show Vol
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Vol] -> ShowS
$cshowList :: [Vol] -> ShowS
show :: Vol -> String
$cshow :: Vol -> String
showsPrec :: Int -> Vol -> ShowS
$cshowsPrec :: Int -> Vol -> ShowS
Show, ReadPrec [Vol]
ReadPrec Vol
Int -> ReadS Vol
ReadS [Vol]
(Int -> ReadS Vol)
-> ReadS [Vol] -> ReadPrec Vol -> ReadPrec [Vol] -> Read Vol
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Vol]
$creadListPrec :: ReadPrec [Vol]
readPrec :: ReadPrec Vol
$creadPrec :: ReadPrec Vol
readList :: ReadS [Vol]
$creadList :: ReadS [Vol]
readsPrec :: Int -> ReadS Vol
$creadsPrec :: Int -> ReadS Vol
Read, Eq Vol
Eq Vol
-> (Vol -> Vol -> Ordering)
-> (Vol -> Vol -> Bool)
-> (Vol -> Vol -> Bool)
-> (Vol -> Vol -> Bool)
-> (Vol -> Vol -> Bool)
-> (Vol -> Vol -> Vol)
-> (Vol -> Vol -> Vol)
-> Ord Vol
Vol -> Vol -> Bool
Vol -> Vol -> Ordering
Vol -> Vol -> Vol
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
min :: Vol -> Vol -> Vol
$cmin :: Vol -> Vol -> Vol
max :: Vol -> Vol -> Vol
$cmax :: Vol -> Vol -> Vol
>= :: Vol -> Vol -> Bool
$c>= :: Vol -> Vol -> Bool
> :: Vol -> Vol -> Bool
$c> :: Vol -> Vol -> Bool
<= :: Vol -> Vol -> Bool
$c<= :: Vol -> Vol -> Bool
< :: Vol -> Vol -> Bool
$c< :: Vol -> Vol -> Bool
compare :: Vol -> Vol -> Ordering
$ccompare :: Vol -> Vol -> Ordering
$cp1Ord :: Eq Vol
Ord, Integer -> Vol
Vol -> Vol
Vol -> Vol -> Vol
(Vol -> Vol -> Vol)
-> (Vol -> Vol -> Vol)
-> (Vol -> Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Integer -> Vol)
-> Num Vol
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Vol
$cfromInteger :: Integer -> Vol
signum :: Vol -> Vol
$csignum :: Vol -> Vol
abs :: Vol -> Vol
$cabs :: Vol -> Vol
negate :: Vol -> Vol
$cnegate :: Vol -> Vol
* :: Vol -> Vol -> Vol
$c* :: Vol -> Vol -> Vol
- :: Vol -> Vol -> Vol
$c- :: Vol -> Vol -> Vol
+ :: Vol -> Vol -> Vol
$c+ :: Vol -> Vol -> Vol
Num, Num Vol
Num Vol
-> (Vol -> Vol -> Vol)
-> (Vol -> Vol)
-> (Rational -> Vol)
-> Fractional Vol
Rational -> Vol
Vol -> Vol
Vol -> Vol -> Vol
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> Vol
$cfromRational :: Rational -> Vol
recip :: Vol -> Vol
$crecip :: Vol -> Vol
/ :: Vol -> Vol -> Vol
$c/ :: Vol -> Vol -> Vol
$cp1Fractional :: Num Vol
Fractional, Num Vol
Ord Vol
Num Vol -> Ord Vol -> (Vol -> Rational) -> Real Vol
Vol -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Vol -> Rational
$ctoRational :: Vol -> Rational
$cp2Real :: Ord Vol
$cp1Real :: Num Vol
Real, Fractional Vol
Real Vol
Real Vol
-> Fractional Vol
-> (forall b. Integral b => Vol -> (b, Vol))
-> (forall b. Integral b => Vol -> b)
-> (forall b. Integral b => Vol -> b)
-> (forall b. Integral b => Vol -> b)
-> (forall b. Integral b => Vol -> b)
-> RealFrac Vol
Vol -> b
Vol -> b
Vol -> b
Vol -> b
Vol -> (b, Vol)
forall b. Integral b => Vol -> b
forall b. Integral b => Vol -> (b, Vol)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: Vol -> b
$cfloor :: forall b. Integral b => Vol -> b
ceiling :: Vol -> b
$cceiling :: forall b. Integral b => Vol -> b
round :: Vol -> b
$cround :: forall b. Integral b => Vol -> b
truncate :: Vol -> b
$ctruncate :: forall b. Integral b => Vol -> b
properFraction :: Vol -> (b, Vol)
$cproperFraction :: forall b. Integral b => Vol -> (b, Vol)
$cp2RealFrac :: Fractional Vol
$cp1RealFrac :: Real Vol
RealFrac, Floating Vol
RealFrac Vol
RealFrac Vol
-> Floating Vol
-> (Vol -> Integer)
-> (Vol -> Int)
-> (Vol -> (Int, Int))
-> (Vol -> (Integer, Int))
-> (Integer -> Int -> Vol)
-> (Vol -> Int)
-> (Vol -> Vol)
-> (Int -> Vol -> Vol)
-> (Vol -> Bool)
-> (Vol -> Bool)
-> (Vol -> Bool)
-> (Vol -> Bool)
-> (Vol -> Bool)
-> (Vol -> Vol -> Vol)
-> RealFloat Vol
Int -> Vol -> Vol
Integer -> Int -> Vol
Vol -> Bool
Vol -> Int
Vol -> Integer
Vol -> (Int, Int)
Vol -> (Integer, Int)
Vol -> Vol
Vol -> Vol -> Vol
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: Vol -> Vol -> Vol
$catan2 :: Vol -> Vol -> Vol
isIEEE :: Vol -> Bool
$cisIEEE :: Vol -> Bool
isNegativeZero :: Vol -> Bool
$cisNegativeZero :: Vol -> Bool
isDenormalized :: Vol -> Bool
$cisDenormalized :: Vol -> Bool
isInfinite :: Vol -> Bool
$cisInfinite :: Vol -> Bool
isNaN :: Vol -> Bool
$cisNaN :: Vol -> Bool
scaleFloat :: Int -> Vol -> Vol
$cscaleFloat :: Int -> Vol -> Vol
significand :: Vol -> Vol
$csignificand :: Vol -> Vol
exponent :: Vol -> Int
$cexponent :: Vol -> Int
encodeFloat :: Integer -> Int -> Vol
$cencodeFloat :: Integer -> Int -> Vol
decodeFloat :: Vol -> (Integer, Int)
$cdecodeFloat :: Vol -> (Integer, Int)
floatRange :: Vol -> (Int, Int)
$cfloatRange :: Vol -> (Int, Int)
floatDigits :: Vol -> Int
$cfloatDigits :: Vol -> Int
floatRadix :: Vol -> Integer
$cfloatRadix :: Vol -> Integer
$cp2RealFloat :: Floating Vol
$cp1RealFloat :: RealFrac Vol
RealFloat, Fractional Vol
Vol
Fractional Vol
-> Vol
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol -> Vol)
-> (Vol -> Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> (Vol -> Vol)
-> Floating Vol
Vol -> Vol
Vol -> Vol -> Vol
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: Vol -> Vol
$clog1mexp :: Vol -> Vol
log1pexp :: Vol -> Vol
$clog1pexp :: Vol -> Vol
expm1 :: Vol -> Vol
$cexpm1 :: Vol -> Vol
log1p :: Vol -> Vol
$clog1p :: Vol -> Vol
atanh :: Vol -> Vol
$catanh :: Vol -> Vol
acosh :: Vol -> Vol
$cacosh :: Vol -> Vol
asinh :: Vol -> Vol
$casinh :: Vol -> Vol
tanh :: Vol -> Vol
$ctanh :: Vol -> Vol
cosh :: Vol -> Vol
$ccosh :: Vol -> Vol
sinh :: Vol -> Vol
$csinh :: Vol -> Vol
atan :: Vol -> Vol
$catan :: Vol -> Vol
acos :: Vol -> Vol
$cacos :: Vol -> Vol
asin :: Vol -> Vol
$casin :: Vol -> Vol
tan :: Vol -> Vol
$ctan :: Vol -> Vol
cos :: Vol -> Vol
$ccos :: Vol -> Vol
sin :: Vol -> Vol
$csin :: Vol -> Vol
logBase :: Vol -> Vol -> Vol
$clogBase :: Vol -> Vol -> Vol
** :: Vol -> Vol -> Vol
$c** :: Vol -> Vol -> Vol
sqrt :: Vol -> Vol
$csqrt :: Vol -> Vol
log :: Vol -> Vol
$clog :: Vol -> Vol
exp :: Vol -> Vol
$cexp :: Vol -> Vol
pi :: Vol
$cpi :: Vol
$cp1Floating :: Fractional Vol
Floating, Ptr b -> Int -> IO Vol
Ptr b -> Int -> Vol -> IO ()
Ptr Vol -> IO Vol
Ptr Vol -> Int -> IO Vol
Ptr Vol -> Int -> Vol -> IO ()
Ptr Vol -> Vol -> IO ()
Vol -> Int
(Vol -> Int)
-> (Vol -> Int)
-> (Ptr Vol -> Int -> IO Vol)
-> (Ptr Vol -> Int -> Vol -> IO ())
-> (forall b. Ptr b -> Int -> IO Vol)
-> (forall b. Ptr b -> Int -> Vol -> IO ())
-> (Ptr Vol -> IO Vol)
-> (Ptr Vol -> Vol -> IO ())
-> Storable Vol
forall b. Ptr b -> Int -> IO Vol
forall b. Ptr b -> Int -> Vol -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr Vol -> Vol -> IO ()
$cpoke :: Ptr Vol -> Vol -> IO ()
peek :: Ptr Vol -> IO Vol
$cpeek :: Ptr Vol -> IO Vol
pokeByteOff :: Ptr b -> Int -> Vol -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> Vol -> IO ()
peekByteOff :: Ptr b -> Int -> IO Vol
$cpeekByteOff :: forall b. Ptr b -> Int -> IO Vol
pokeElemOff :: Ptr Vol -> Int -> Vol -> IO ()
$cpokeElemOff :: Ptr Vol -> Int -> Vol -> IO ()
peekElemOff :: Ptr Vol -> Int -> IO Vol
$cpeekElemOff :: Ptr Vol -> Int -> IO Vol
alignment :: Vol -> Int
$calignment :: Vol -> Int
sizeOf :: Vol -> Int
$csizeOf :: Vol -> Int
Storable)
-- | (\w(S_0, K, T) = \sigma_{BS}(S_0, K, T)T \)
newtype TotalVar = TotalVar  Double deriving ((forall x. TotalVar -> Rep TotalVar x)
-> (forall x. Rep TotalVar x -> TotalVar) -> Generic TotalVar
forall x. Rep TotalVar x -> TotalVar
forall x. TotalVar -> Rep TotalVar x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TotalVar x -> TotalVar
$cfrom :: forall x. TotalVar -> Rep TotalVar x
Generic, TotalVar -> TotalVar -> Bool
(TotalVar -> TotalVar -> Bool)
-> (TotalVar -> TotalVar -> Bool) -> Eq TotalVar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TotalVar -> TotalVar -> Bool
$c/= :: TotalVar -> TotalVar -> Bool
== :: TotalVar -> TotalVar -> Bool
$c== :: TotalVar -> TotalVar -> Bool
Eq, Int -> TotalVar -> ShowS
[TotalVar] -> ShowS
TotalVar -> String
(Int -> TotalVar -> ShowS)
-> (TotalVar -> String) -> ([TotalVar] -> ShowS) -> Show TotalVar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TotalVar] -> ShowS
$cshowList :: [TotalVar] -> ShowS
show :: TotalVar -> String
$cshow :: TotalVar -> String
showsPrec :: Int -> TotalVar -> ShowS
$cshowsPrec :: Int -> TotalVar -> ShowS
Show, ReadPrec [TotalVar]
ReadPrec TotalVar
Int -> ReadS TotalVar
ReadS [TotalVar]
(Int -> ReadS TotalVar)
-> ReadS [TotalVar]
-> ReadPrec TotalVar
-> ReadPrec [TotalVar]
-> Read TotalVar
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TotalVar]
$creadListPrec :: ReadPrec [TotalVar]
readPrec :: ReadPrec TotalVar
$creadPrec :: ReadPrec TotalVar
readList :: ReadS [TotalVar]
$creadList :: ReadS [TotalVar]
readsPrec :: Int -> ReadS TotalVar
$creadsPrec :: Int -> ReadS TotalVar
Read, Eq TotalVar
Eq TotalVar
-> (TotalVar -> TotalVar -> Ordering)
-> (TotalVar -> TotalVar -> Bool)
-> (TotalVar -> TotalVar -> Bool)
-> (TotalVar -> TotalVar -> Bool)
-> (TotalVar -> TotalVar -> Bool)
-> (TotalVar -> TotalVar -> TotalVar)
-> (TotalVar -> TotalVar -> TotalVar)
-> Ord TotalVar
TotalVar -> TotalVar -> Bool
TotalVar -> TotalVar -> Ordering
TotalVar -> TotalVar -> TotalVar
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
min :: TotalVar -> TotalVar -> TotalVar
$cmin :: TotalVar -> TotalVar -> TotalVar
max :: TotalVar -> TotalVar -> TotalVar
$cmax :: TotalVar -> TotalVar -> TotalVar
>= :: TotalVar -> TotalVar -> Bool
$c>= :: TotalVar -> TotalVar -> Bool
> :: TotalVar -> TotalVar -> Bool
$c> :: TotalVar -> TotalVar -> Bool
<= :: TotalVar -> TotalVar -> Bool
$c<= :: TotalVar -> TotalVar -> Bool
< :: TotalVar -> TotalVar -> Bool
$c< :: TotalVar -> TotalVar -> Bool
compare :: TotalVar -> TotalVar -> Ordering
$ccompare :: TotalVar -> TotalVar -> Ordering
$cp1Ord :: Eq TotalVar
Ord, Integer -> TotalVar
TotalVar -> TotalVar
TotalVar -> TotalVar -> TotalVar
(TotalVar -> TotalVar -> TotalVar)
-> (TotalVar -> TotalVar -> TotalVar)
-> (TotalVar -> TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (Integer -> TotalVar)
-> Num TotalVar
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> TotalVar
$cfromInteger :: Integer -> TotalVar
signum :: TotalVar -> TotalVar
$csignum :: TotalVar -> TotalVar
abs :: TotalVar -> TotalVar
$cabs :: TotalVar -> TotalVar
negate :: TotalVar -> TotalVar
$cnegate :: TotalVar -> TotalVar
* :: TotalVar -> TotalVar -> TotalVar
$c* :: TotalVar -> TotalVar -> TotalVar
- :: TotalVar -> TotalVar -> TotalVar
$c- :: TotalVar -> TotalVar -> TotalVar
+ :: TotalVar -> TotalVar -> TotalVar
$c+ :: TotalVar -> TotalVar -> TotalVar
Num, Num TotalVar
Num TotalVar
-> (TotalVar -> TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (Rational -> TotalVar)
-> Fractional TotalVar
Rational -> TotalVar
TotalVar -> TotalVar
TotalVar -> TotalVar -> TotalVar
forall a.
Num a
-> (a -> a -> a) -> (a -> a) -> (Rational -> a) -> Fractional a
fromRational :: Rational -> TotalVar
$cfromRational :: Rational -> TotalVar
recip :: TotalVar -> TotalVar
$crecip :: TotalVar -> TotalVar
/ :: TotalVar -> TotalVar -> TotalVar
$c/ :: TotalVar -> TotalVar -> TotalVar
$cp1Fractional :: Num TotalVar
Fractional, Num TotalVar
Ord TotalVar
Num TotalVar
-> Ord TotalVar -> (TotalVar -> Rational) -> Real TotalVar
TotalVar -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: TotalVar -> Rational
$ctoRational :: TotalVar -> Rational
$cp2Real :: Ord TotalVar
$cp1Real :: Num TotalVar
Real, Fractional TotalVar
Real TotalVar
Real TotalVar
-> Fractional TotalVar
-> (forall b. Integral b => TotalVar -> (b, TotalVar))
-> (forall b. Integral b => TotalVar -> b)
-> (forall b. Integral b => TotalVar -> b)
-> (forall b. Integral b => TotalVar -> b)
-> (forall b. Integral b => TotalVar -> b)
-> RealFrac TotalVar
TotalVar -> b
TotalVar -> b
TotalVar -> b
TotalVar -> b
TotalVar -> (b, TotalVar)
forall b. Integral b => TotalVar -> b
forall b. Integral b => TotalVar -> (b, TotalVar)
forall a.
Real a
-> Fractional a
-> (forall b. Integral b => a -> (b, a))
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> (forall b. Integral b => a -> b)
-> RealFrac a
floor :: TotalVar -> b
$cfloor :: forall b. Integral b => TotalVar -> b
ceiling :: TotalVar -> b
$cceiling :: forall b. Integral b => TotalVar -> b
round :: TotalVar -> b
$cround :: forall b. Integral b => TotalVar -> b
truncate :: TotalVar -> b
$ctruncate :: forall b. Integral b => TotalVar -> b
properFraction :: TotalVar -> (b, TotalVar)
$cproperFraction :: forall b. Integral b => TotalVar -> (b, TotalVar)
$cp2RealFrac :: Fractional TotalVar
$cp1RealFrac :: Real TotalVar
RealFrac, Floating TotalVar
RealFrac TotalVar
RealFrac TotalVar
-> Floating TotalVar
-> (TotalVar -> Integer)
-> (TotalVar -> Int)
-> (TotalVar -> (Int, Int))
-> (TotalVar -> (Integer, Int))
-> (Integer -> Int -> TotalVar)
-> (TotalVar -> Int)
-> (TotalVar -> TotalVar)
-> (Int -> TotalVar -> TotalVar)
-> (TotalVar -> Bool)
-> (TotalVar -> Bool)
-> (TotalVar -> Bool)
-> (TotalVar -> Bool)
-> (TotalVar -> Bool)
-> (TotalVar -> TotalVar -> TotalVar)
-> RealFloat TotalVar
Int -> TotalVar -> TotalVar
Integer -> Int -> TotalVar
TotalVar -> Bool
TotalVar -> Int
TotalVar -> Integer
TotalVar -> (Int, Int)
TotalVar -> (Integer, Int)
TotalVar -> TotalVar
TotalVar -> TotalVar -> TotalVar
forall a.
RealFrac a
-> Floating a
-> (a -> Integer)
-> (a -> Int)
-> (a -> (Int, Int))
-> (a -> (Integer, Int))
-> (Integer -> Int -> a)
-> (a -> Int)
-> (a -> a)
-> (Int -> a -> a)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> Bool)
-> (a -> a -> a)
-> RealFloat a
atan2 :: TotalVar -> TotalVar -> TotalVar
$catan2 :: TotalVar -> TotalVar -> TotalVar
isIEEE :: TotalVar -> Bool
$cisIEEE :: TotalVar -> Bool
isNegativeZero :: TotalVar -> Bool
$cisNegativeZero :: TotalVar -> Bool
isDenormalized :: TotalVar -> Bool
$cisDenormalized :: TotalVar -> Bool
isInfinite :: TotalVar -> Bool
$cisInfinite :: TotalVar -> Bool
isNaN :: TotalVar -> Bool
$cisNaN :: TotalVar -> Bool
scaleFloat :: Int -> TotalVar -> TotalVar
$cscaleFloat :: Int -> TotalVar -> TotalVar
significand :: TotalVar -> TotalVar
$csignificand :: TotalVar -> TotalVar
exponent :: TotalVar -> Int
$cexponent :: TotalVar -> Int
encodeFloat :: Integer -> Int -> TotalVar
$cencodeFloat :: Integer -> Int -> TotalVar
decodeFloat :: TotalVar -> (Integer, Int)
$cdecodeFloat :: TotalVar -> (Integer, Int)
floatRange :: TotalVar -> (Int, Int)
$cfloatRange :: TotalVar -> (Int, Int)
floatDigits :: TotalVar -> Int
$cfloatDigits :: TotalVar -> Int
floatRadix :: TotalVar -> Integer
$cfloatRadix :: TotalVar -> Integer
$cp2RealFloat :: Floating TotalVar
$cp1RealFloat :: RealFrac TotalVar
RealFloat, Fractional TotalVar
TotalVar
Fractional TotalVar
-> TotalVar
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar -> TotalVar)
-> (TotalVar -> TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> (TotalVar -> TotalVar)
-> Floating TotalVar
TotalVar -> TotalVar
TotalVar -> TotalVar -> TotalVar
forall a.
Fractional a
-> a
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> Floating a
log1mexp :: TotalVar -> TotalVar
$clog1mexp :: TotalVar -> TotalVar
log1pexp :: TotalVar -> TotalVar
$clog1pexp :: TotalVar -> TotalVar
expm1 :: TotalVar -> TotalVar
$cexpm1 :: TotalVar -> TotalVar
log1p :: TotalVar -> TotalVar
$clog1p :: TotalVar -> TotalVar
atanh :: TotalVar -> TotalVar
$catanh :: TotalVar -> TotalVar
acosh :: TotalVar -> TotalVar
$cacosh :: TotalVar -> TotalVar
asinh :: TotalVar -> TotalVar
$casinh :: TotalVar -> TotalVar
tanh :: TotalVar -> TotalVar
$ctanh :: TotalVar -> TotalVar
cosh :: TotalVar -> TotalVar
$ccosh :: TotalVar -> TotalVar
sinh :: TotalVar -> TotalVar
$csinh :: TotalVar -> TotalVar
atan :: TotalVar -> TotalVar
$catan :: TotalVar -> TotalVar
acos :: TotalVar -> TotalVar
$cacos :: TotalVar -> TotalVar
asin :: TotalVar -> TotalVar
$casin :: TotalVar -> TotalVar
tan :: TotalVar -> TotalVar
$ctan :: TotalVar -> TotalVar
cos :: TotalVar -> TotalVar
$ccos :: TotalVar -> TotalVar
sin :: TotalVar -> TotalVar
$csin :: TotalVar -> TotalVar
logBase :: TotalVar -> TotalVar -> TotalVar
$clogBase :: TotalVar -> TotalVar -> TotalVar
** :: TotalVar -> TotalVar -> TotalVar
$c** :: TotalVar -> TotalVar -> TotalVar
sqrt :: TotalVar -> TotalVar
$csqrt :: TotalVar -> TotalVar
log :: TotalVar -> TotalVar
$clog :: TotalVar -> TotalVar
exp :: TotalVar -> TotalVar
$cexp :: TotalVar -> TotalVar
pi :: TotalVar
$cpi :: TotalVar
$cp1Floating :: Fractional TotalVar
Floating, Ptr b -> Int -> IO TotalVar
Ptr b -> Int -> TotalVar -> IO ()
Ptr TotalVar -> IO TotalVar
Ptr TotalVar -> Int -> IO TotalVar
Ptr TotalVar -> Int -> TotalVar -> IO ()
Ptr TotalVar -> TotalVar -> IO ()
TotalVar -> Int
(TotalVar -> Int)
-> (TotalVar -> Int)
-> (Ptr TotalVar -> Int -> IO TotalVar)
-> (Ptr TotalVar -> Int -> TotalVar -> IO ())
-> (forall b. Ptr b -> Int -> IO TotalVar)
-> (forall b. Ptr b -> Int -> TotalVar -> IO ())
-> (Ptr TotalVar -> IO TotalVar)
-> (Ptr TotalVar -> TotalVar -> IO ())
-> Storable TotalVar
forall b. Ptr b -> Int -> IO TotalVar
forall b. Ptr b -> Int -> TotalVar -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
poke :: Ptr TotalVar -> TotalVar -> IO ()
$cpoke :: Ptr TotalVar -> TotalVar -> IO ()
peek :: Ptr TotalVar -> IO TotalVar
$cpeek :: Ptr TotalVar -> IO TotalVar
pokeByteOff :: Ptr b -> Int -> TotalVar -> IO ()
$cpokeByteOff :: forall b. Ptr b -> Int -> TotalVar -> IO ()
peekByteOff :: Ptr b -> Int -> IO TotalVar
$cpeekByteOff :: forall b. Ptr b -> Int -> IO TotalVar
pokeElemOff :: Ptr TotalVar -> Int -> TotalVar -> IO ()
$cpokeElemOff :: Ptr TotalVar -> Int -> TotalVar -> IO ()
peekElemOff :: Ptr TotalVar -> Int -> IO TotalVar
$cpeekElemOff :: Ptr TotalVar -> Int -> IO TotalVar
alignment :: TotalVar -> Int
$calignment :: TotalVar -> Int
sizeOf :: TotalVar -> Int
$csizeOf :: TotalVar -> Int
Storable)

totalVarToVol :: TotalVar -> YearFrac -> Vol
totalVarToVol (TotalVar Double
v) (YearFrac Double
t) = Double -> Vol
Vol (Double -> Vol) -> Double -> Vol
forall a b. (a -> b) -> a -> b
$ Double -> Double
forall a. Floating a => a -> a
sqrt (Double
v Double -> Double -> Double
forall a. Fractional a => a -> a -> a
/ Double
t)
volToTotalVar :: Vol -> YearFrac -> TotalVar
volToTotalVar (Vol Double
sigma) (YearFrac Double
t) = Double -> TotalVar
TotalVar (Double -> TotalVar) -> Double -> TotalVar
forall a b. (a -> b) -> a -> b
$ Double
sigma Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
sigma Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
t

instance FromField OptionType where
  parseField :: Field -> Parser OptionType
parseField Field
s | (Field
s Field -> Field -> Bool
forall a. Eq a => a -> a -> Bool
== Field
"C" Bool -> Bool -> Bool
|| Field
s Field -> Field -> Bool
forall a. Eq a => a -> a -> Bool
== Field
"c") = OptionType -> Parser OptionType
forall (f :: * -> *) a. Applicative f => a -> f a
pure OptionType
Call
               | (Field
s Field -> Field -> Bool
forall a. Eq a => a -> a -> Bool
== Field
"P" Bool -> Bool -> Bool
|| Field
s Field -> Field -> Bool
forall a. Eq a => a -> a -> Bool
== Field
"p")  = OptionType -> Parser OptionType
forall (f :: * -> *) a. Applicative f => a -> f a
pure OptionType
Put
instance ToField OptionType where
  toField :: OptionType -> Field
toField OptionType
Call = Field -> Field
forall a. ToField a => a -> Field
toField (Field
"C"::B.ByteString)
  toField OptionType
Put  = Field -> Field
forall a. ToField a => a -> Field
toField (Field
"P"::B.ByteString)

instance FromField Spot where
  parseField :: Field -> Parser Spot
parseField Field
s = Double -> Spot
Spot (Double -> Spot) -> Parser Double -> Parser Spot
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField Spot where
  toField :: Spot -> Field
toField (Spot Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k

instance FromField Cash where
  parseField :: Field -> Parser Cash
parseField Field
s = Double -> Cash
Cash (Double -> Cash) -> Parser Double -> Parser Cash
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField Cash where
  toField :: Cash -> Field
toField (Cash Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k


instance FromField Strike where
  parseField :: Field -> Parser Strike
parseField Field
s = Double -> Strike
Strike (Double -> Strike) -> Parser Double -> Parser Strike
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField Strike where
  toField :: Strike -> Field
toField (Strike Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k

instance FromField Expiry where
  parseField :: Field -> Parser Expiry
parseField Field
s = Day -> Expiry
Expiry (Day -> Expiry) -> Parser Day -> Parser Expiry
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Day
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField   Expiry where
  toField :: Expiry -> Field
toField (Expiry Day
k) = Day -> Field
forall a. ToField a => a -> Field
toField Day
k

instance FromField Premium where
    parseField :: Field -> Parser Premium
parseField Field
s = Double -> Premium
Premium (Double -> Premium) -> Parser Double -> Parser Premium
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField   Premium  where
  toField :: Premium -> Field
toField (Premium Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k

instance FromField Delta where
    parseField :: Field -> Parser Delta
parseField Field
s = Double -> Delta
Delta (Double -> Delta) -> Parser Double -> Parser Delta
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField   Delta  where
  toField :: Delta -> Field
toField (Delta Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k

instance FromField Vega where
    parseField :: Field -> Parser Vega
parseField Field
s =  Double -> Vega
Vega (Double -> Vega) -> Parser Double -> Parser Vega
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField   Vega  where
  toField :: Vega -> Field
toField (Vega Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k

instance FromField Gamma where
    parseField :: Field -> Parser Gamma
parseField Field
s =  Double -> Gamma
Gamma (Double -> Gamma) -> Parser Double -> Parser Gamma
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField   Gamma  where
  toField :: Gamma -> Field
toField (Gamma Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k

instance FromField YearFrac where
    parseField :: Field -> Parser YearFrac
parseField Field
s =  Double -> YearFrac
YearFrac (Double -> YearFrac) -> Parser Double -> Parser YearFrac
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField   YearFrac  where
  toField :: YearFrac -> Field
toField (YearFrac Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k

instance FromField Rate where
    parseField :: Field -> Parser Rate
parseField Field
s =  Double -> Rate
Rate (Double -> Rate) -> Parser Double -> Parser Rate
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField   Rate  where
  toField :: Rate -> Field
toField (Rate Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k


instance FromField Vol where
    parseField :: Field -> Parser Vol
parseField Field
s =  Double -> Vol
Vol (Double -> Vol) -> Parser Double -> Parser Vol
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Field -> Parser Double
forall a. FromField a => Field -> Parser a
parseField Field
s
instance ToField   Vol  where
  toField :: Vol -> Field
toField (Vol Double
k) = Double -> Field
forall a. ToField a => a -> Field
toField Double
k

-- | Represents concepts that scale as a function of time such as 'Vol'
class TimeScaleable a where
  scale :: YearFrac -> a -> a

instance TimeScaleable Double where
  scale :: YearFrac -> Double -> Double
scale (YearFrac Double
t) Double
y = Double
y Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
t
  
instance TimeScaleable Rate where
  scale :: YearFrac -> Rate -> Rate
scale (YearFrac Double
t) (Rate Double
r)  = Double -> Rate
Rate (Double -> Rate) -> Double -> Rate
forall a b. (a -> b) -> a -> b
$ Double
r Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double
t
instance TimeScaleable Vol where
  scale :: YearFrac -> Vol -> Vol
scale (YearFrac Double
t) (Vol Double
sigma)  = Double -> Vol
Vol (Double -> Vol) -> Double -> Vol
forall a b. (a -> b) -> a -> b
$ Double
sigma Double -> Double -> Double
forall a. Num a => a -> a -> a
* Double -> Double
forall a. Floating a => a -> a
sqrt Double
t


-- | Single-observable container.
data Observables1 = Observables1 {-# UNPACK #-} !Double
-- | Two observable container.
data Observables2 = Observables2 {-# UNPACK #-} !Double {-# UNPACK #-} !Double
-- | Three observable container.
data Observables3 = Observables3 {-# UNPACK #-} !Double {-# UNPACK #-} !Double
                                 {-# UNPACK #-} !Double
-- | Four observable container.
data Observables4 = Observables4 {-# UNPACK #-} !Double {-# UNPACK #-} !Double
                                 {-# UNPACK #-} !Double {-# UNPACK #-} !Double
-- | Five observable container.
data Observables5 = Observables5 {-# UNPACK #-} !Double {-# UNPACK #-} !Double
                                 {-# UNPACK #-} !Double {-# UNPACK #-} !Double
                                 {-# UNPACK #-} !Double

class Obs1 a where
    get1 :: a -> Double

class (Obs1 a) => Obs2 a where
    get2 :: a -> Double

class (Obs2 a) => Obs3 a where
    get3 :: a -> Double

class (Obs3 a) => Obs4 a where
    get4 :: a -> Double

class (Obs4 a) => Obs5 a where
    get5 :: a -> Double

instance Obs1 Observables1 where
    get1 :: Observables1 -> Double
get1 (Observables1 Double
x) = Double
x
    {-# INLINE get1 #-}

instance Obs1 Observables2 where
    get1 :: Observables2 -> Double
get1 (Observables2 Double
x Double
_) = Double
x
    {-# INLINE get1 #-}

instance Obs1 Observables3 where
    get1 :: Observables3 -> Double
get1 (Observables3 Double
x Double
_ Double
_) = Double
x
    {-# INLINE get1 #-}

instance Obs1 Observables4 where
    get1 :: Observables4 -> Double
get1 (Observables4 Double
x Double
_ Double
_ Double
_) = Double
x
    {-# INLINE get1 #-}

instance Obs1 Observables5 where
    get1 :: Observables5 -> Double
get1 (Observables5 Double
x Double
_ Double
_ Double
_ Double
_) = Double
x
    {-# INLINE get1 #-}

instance Obs2 Observables2 where
    get2 :: Observables2 -> Double
get2 (Observables2 Double
_ Double
x) = Double
x
    {-# INLINE get2 #-}

instance Obs2 Observables3 where
    get2 :: Observables3 -> Double
get2 (Observables3 Double
_ Double
x Double
_) = Double
x
    {-# INLINE get2 #-}

instance Obs2 Observables4 where
    get2 :: Observables4 -> Double
get2 (Observables4 Double
_ Double
x Double
_ Double
_) = Double
x
    {-# INLINE get2 #-}

instance Obs2 Observables5 where
    get2 :: Observables5 -> Double
get2 (Observables5 Double
_ Double
x Double
_ Double
_ Double
_) = Double
x
    {-# INLINE get2 #-}

instance Obs3 Observables3 where
    get3 :: Observables3 -> Double
get3 (Observables3 Double
_ Double
_ Double
x) = Double
x
    {-# INLINE get3 #-}

instance Obs3 Observables4 where
    get3 :: Observables4 -> Double
get3 (Observables4 Double
_ Double
_ Double
x Double
_) = Double
x
    {-# INLINE get3 #-}

instance Obs3 Observables5 where
    get3 :: Observables5 -> Double
get3 (Observables5 Double
_ Double
_ Double
x Double
_ Double
_) = Double
x
    {-# INLINE get3 #-}

instance Obs4 Observables4 where
    get4 :: Observables4 -> Double
get4 (Observables4 Double
_ Double
_ Double
_ Double
x) = Double
x
    {-# INLINE get4 #-}

instance Obs4 Observables5 where
    get4 :: Observables5 -> Double
get4 (Observables5 Double
_ Double
_ Double
_ Double
x Double
_) = Double
x
    {-# INLINE get4 #-}

instance Obs5 Observables5 where
    get5 :: Observables5 -> Double
get5 (Observables5 Double
_ Double
_ Double
_ Double
_ Double
x) = Double
x
    {-# INLINE get5 #-}