Copyright	(C) 2012-2014 Edward Kmett Daniel Peebles (C) 2013-2018 Claude Heiland-Allen
License	BSD3
Maintainer	Claude Heiland-Allen <claude@mathr.co.uk>
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Numeric.Rounded

Contents

Floating point numbers with a specified rounding mode and precision
Precision
Rounding
Useful Constants
Combinators that are oblivious to precision
Mixed-precision operations
Foreign Function Interface

Description

Synopsis

data Rounded (r :: RoundingMode) p
fromInt :: (Rounding r, Precision p) => Int -> Rounded r p
fromDouble :: (Rounding r, Precision p) => Double -> Rounded r p
fromLongDouble :: (Rounding r, Precision p) => LongDouble -> Rounded r p
toDouble :: (Rounding r, Precision p) => Rounded r p -> Double
toLongDouble :: (Rounding r, Precision p) => Rounded r p -> LongDouble
toInteger' :: (Rounding r, Precision p) => Rounded r p -> Integer
precRound :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
class Precision p where
- precision :: proxy p -> Int
data Bytes (n :: Nat)
reifyPrecision :: Int -> (forall (p :: *). Precision p => Proxy p -> a) -> a
class Rounding (r :: RoundingMode) where
- rounding :: Proxy r -> RoundingMode
data RoundingMode
- = TowardNearestWithTiesAwayFromZero
- | TowardNearest
- | TowardZero
- | TowardInf
- | TowardNegInf
- | AwayFromZero
- | Faithfully
reifyRounding :: RoundingMode -> (forall s. Rounding s => Proxy s -> r) -> r
kLog2 :: (Rounding r, Precision p) => Rounded r p
kEuler :: (Rounding r, Precision p) => Rounded r p
kCatalan :: (Rounding r, Precision p) => Rounded r p
(.+.) :: Rounding r => Rounded r p -> Rounded r p -> Rounded r p
(.-.) :: Rounding r => Rounded r p -> Rounded r p -> Rounded r p
(.*.) :: Rounding r => Rounded r p -> Rounded r p -> Rounded r p
abs' :: Rounded r p -> Rounded r p
negate' :: Rounded r p -> Rounded r p
decodeFloat' :: Rounded r p -> (Integer, Int)
succUlp :: Rounded r p -> Rounded r p
predUlp :: Rounded r p -> Rounded r p
(!+!) :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3
(!-!) :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3
(!*!) :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3
(!/!) :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3
abs_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
negate_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
compare_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Ordering
(!==!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool
(!/=!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool
(!>=!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool
(!<=!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool
(!>!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool
(!<!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool
min_ :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3
max_ :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3
sqrt_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
exp_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
expm1_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
log_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
log1p_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
sin_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
cos_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
tan_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
asin_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
acos_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
atan_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
atan2_ :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3
sinh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
cosh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
tanh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
asinh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
acosh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
atanh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
truncate_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
round_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
ceiling_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
floor_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2
withInRounded :: Rounded r p -> (Ptr MPFR -> IO a) -> IO a
withInOutRounded :: Precision p => Rounded r p -> (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p), a)
withInOutRounded_ :: Precision p => Rounded r p -> (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p))
withOutRounded :: Precision p => (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p), a)
withOutRounded_ :: Precision p => (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p))
unsafeWithOutRounded :: Precision p => (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p), a)
unsafeWithOutRounded_ :: Precision p => (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p))
peekRounded :: Rounding r => Ptr MPFR -> (forall (p :: *). Precision p => Rounded r p -> IO a) -> IO a

Floating point numbers with a specified rounding mode and precision

data Rounded (r :: RoundingMode) p #

A properly rounded floating-point number with a given rounding mode and precision.

You can coerce to change rounding modes, but not precision.

Instances

Eq (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods (==) :: Rounded r p -> Rounded r p -> Bool # (/=) :: Rounded r p -> Rounded r p -> Bool #
(Rounding r, Precision p) => Floating (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods pi :: Rounded r p # exp :: Rounded r p -> Rounded r p # log :: Rounded r p -> Rounded r p # sqrt :: Rounded r p -> Rounded r p # (**) :: Rounded r p -> Rounded r p -> Rounded r p # logBase :: Rounded r p -> Rounded r p -> Rounded r p # sin :: Rounded r p -> Rounded r p # cos :: Rounded r p -> Rounded r p # tan :: Rounded r p -> Rounded r p # asin :: Rounded r p -> Rounded r p # acos :: Rounded r p -> Rounded r p # atan :: Rounded r p -> Rounded r p # sinh :: Rounded r p -> Rounded r p # cosh :: Rounded r p -> Rounded r p # tanh :: Rounded r p -> Rounded r p # asinh :: Rounded r p -> Rounded r p # acosh :: Rounded r p -> Rounded r p # atanh :: Rounded r p -> Rounded r p # log1p :: Rounded r p -> Rounded r p # expm1 :: Rounded r p -> Rounded r p # log1pexp :: Rounded r p -> Rounded r p # log1mexp :: Rounded r p -> Rounded r p #
(Rounding r, Precision p) => Fractional (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods (/) :: Rounded r p -> Rounded r p -> Rounded r p # recip :: Rounded r p -> Rounded r p # fromRational :: Rational -> Rounded r p #
(Rounding r, Precision p) => Num (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods (+) :: Rounded r p -> Rounded r p -> Rounded r p # (-) :: Rounded r p -> Rounded r p -> Rounded r p # (*) :: Rounded r p -> Rounded r p -> Rounded r p # negate :: Rounded r p -> Rounded r p # abs :: Rounded r p -> Rounded r p # signum :: Rounded r p -> Rounded r p # fromInteger :: Integer -> Rounded r p #
Rounding r => Ord (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods compare :: Rounded r p -> Rounded r p -> Ordering # (<) :: Rounded r p -> Rounded r p -> Bool # (<=) :: Rounded r p -> Rounded r p -> Bool # (>) :: Rounded r p -> Rounded r p -> Bool # (>=) :: Rounded r p -> Rounded r p -> Bool # max :: Rounded r p -> Rounded r p -> Rounded r p # min :: Rounded r p -> Rounded r p -> Rounded r p #
(Rounding r, Precision p) => Read (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods readsPrec :: Int -> ReadS (Rounded r p) # readList :: ReadS [Rounded r p] # readPrec :: ReadPrec (Rounded r p) # readListPrec :: ReadPrec [Rounded r p] #
(Rounding r, Precision p) => Real (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods toRational :: Rounded r p -> Rational #
(Rounding r, Precision p) => RealFloat (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods floatRadix :: Rounded r p -> Integer # floatDigits :: Rounded r p -> Int # floatRange :: Rounded r p -> (Int, Int) # decodeFloat :: Rounded r p -> (Integer, Int) # encodeFloat :: Integer -> Int -> Rounded r p # exponent :: Rounded r p -> Int # significand :: Rounded r p -> Rounded r p # scaleFloat :: Int -> Rounded r p -> Rounded r p # isNaN :: Rounded r p -> Bool # isInfinite :: Rounded r p -> Bool # isDenormalized :: Rounded r p -> Bool # isNegativeZero :: Rounded r p -> Bool # isIEEE :: Rounded r p -> Bool # atan2 :: Rounded r p -> Rounded r p -> Rounded r p #
(Rounding r, Precision p) => RealFrac (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods properFraction :: Integral b => Rounded r p -> (b, Rounded r p) # truncate :: Integral b => Rounded r p -> b # round :: Integral b => Rounded r p -> b # ceiling :: Integral b => Rounded r p -> b # floor :: Integral b => Rounded r p -> b #
(Rounding r, Precision p) => Show (Rounded r p) #
Instance details Defined in Numeric.Rounded.Internal Methods showsPrec :: Int -> Rounded r p -> ShowS # show :: Rounded r p -> String # showList :: [Rounded r p] -> ShowS #

fromInt :: (Rounding r, Precision p) => Int -> Rounded r p #

Construct a properly rounded floating point number from an Int.

fromDouble :: (Rounding r, Precision p) => Double -> Rounded r p #

Construct a rounded floating point number directly from a Double.

fromLongDouble :: (Rounding r, Precision p) => LongDouble -> Rounded r p #

Construct a rounded floating point number directly from a LongDouble.

toDouble :: (Rounding r, Precision p) => Rounded r p -> Double #

Round to Double with the given rounding mode.

toLongDouble :: (Rounding r, Precision p) => Rounded r p -> LongDouble #

Round to LongDouble with the given rounding mode.

toInteger' :: (Rounding r, Precision p) => Rounded r p -> Integer #

Round to Integer using the specified rounding mode. Throws Overflow if the result cannot be represented (for example, infinities or NaN).

precRound :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

Round to a different precision with the given rounding mode.

Precision

class Precision p where #

This class is used to specify the number of bits of precision that are maintained in the significand of a properly Rounded floating point number.

Methods

precision :: proxy p -> Int #

Instances

KnownNat n => Precision (n :: Nat) #
Instance details Defined in Numeric.Rounded.Precision Methods precision :: proxy n -> Int #
Precision Double #
Instance details Defined in Numeric.Rounded.Precision Methods precision :: proxy Double -> Int #
Precision Float #
Instance details Defined in Numeric.Rounded.Precision Methods precision :: proxy Float -> Int #
Precision CFloat #
Instance details Defined in Numeric.Rounded.Precision Methods precision :: proxy CFloat -> Int #
Precision CDouble #
Instance details Defined in Numeric.Rounded.Precision Methods precision :: proxy CDouble -> Int #
Precision LongDouble #
Instance details Defined in Numeric.Rounded.Precision Methods precision :: proxy LongDouble -> Int #
KnownNat n => Precision (Bytes n :: Type) #
Instance details Defined in Numeric.Rounded.Precision Methods precision :: proxy (Bytes n) -> Int #

data Bytes (n :: Nat) #

Instances

KnownNat n => Precision (Bytes n :: Type) #
Instance details Defined in Numeric.Rounded.Precision Methods precision :: proxy (Bytes n) -> Int #

reifyPrecision :: Int -> (forall (p :: *). Precision p => Proxy p -> a) -> a #

Rounding

class Rounding (r :: RoundingMode) where #

Methods

rounding :: Proxy r -> RoundingMode #

Instances

Rounding TowardNearestWithTiesAwayFromZero #
Instance details Defined in Numeric.Rounded.Rounding Methods rounding :: Proxy TowardNearestWithTiesAwayFromZero -> RoundingMode #
Rounding TowardNearest #
Instance details Defined in Numeric.Rounded.Rounding Methods rounding :: Proxy TowardNearest -> RoundingMode #
Rounding TowardZero #
Instance details Defined in Numeric.Rounded.Rounding Methods rounding :: Proxy TowardZero -> RoundingMode #
Rounding TowardInf #
Instance details Defined in Numeric.Rounded.Rounding Methods rounding :: Proxy TowardInf -> RoundingMode #
Rounding TowardNegInf #
Instance details Defined in Numeric.Rounded.Rounding Methods rounding :: Proxy TowardNegInf -> RoundingMode #
Rounding AwayFromZero #
Instance details Defined in Numeric.Rounded.Rounding Methods rounding :: Proxy AwayFromZero -> RoundingMode #
Rounding Faithfully #
Instance details Defined in Numeric.Rounded.Rounding Methods rounding :: Proxy Faithfully -> RoundingMode #

data RoundingMode #

Constructors

TowardNearestWithTiesAwayFromZero	currently unsupported placeholder
TowardNearest	roundTiesToEven in IEEE 754-2008
TowardZero	roundTowardZero in IEEE 754-2008
TowardInf	roundTowardPositive in IEEE 754-2008
TowardNegInf	roundTowardNegative in IEEE 754-2008
AwayFromZero	round away from zero
Faithfully	currently unsupported placeholder

Instances

Bounded RoundingMode #
Instance details Defined in Numeric.Rounded.Rounding Methods minBound :: RoundingMode # maxBound :: RoundingMode #
Enum RoundingMode #
Instance details Defined in Numeric.Rounded.Rounding Methods succ :: RoundingMode -> RoundingMode # pred :: RoundingMode -> RoundingMode # toEnum :: Int -> RoundingMode # fromEnum :: RoundingMode -> Int # enumFrom :: RoundingMode -> [RoundingMode] # enumFromThen :: RoundingMode -> RoundingMode -> [RoundingMode] # enumFromTo :: RoundingMode -> RoundingMode -> [RoundingMode] # enumFromThenTo :: RoundingMode -> RoundingMode -> RoundingMode -> [RoundingMode] #
Eq RoundingMode #
Instance details Defined in Numeric.Rounded.Rounding Methods (==) :: RoundingMode -> RoundingMode -> Bool # (/=) :: RoundingMode -> RoundingMode -> Bool #
Data RoundingMode #
Instance details Defined in Numeric.Rounded.Rounding Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RoundingMode -> c RoundingMode # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RoundingMode # toConstr :: RoundingMode -> Constr # dataTypeOf :: RoundingMode -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RoundingMode) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RoundingMode) # gmapT :: (forall b. Data b => b -> b) -> RoundingMode -> RoundingMode # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RoundingMode -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RoundingMode -> r # gmapQ :: (forall d. Data d => d -> u) -> RoundingMode -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RoundingMode -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RoundingMode -> m RoundingMode # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RoundingMode -> m RoundingMode # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RoundingMode -> m RoundingMode #
Ord RoundingMode #
Instance details Defined in Numeric.Rounded.Rounding Methods compare :: RoundingMode -> RoundingMode -> Ordering # (<) :: RoundingMode -> RoundingMode -> Bool # (<=) :: RoundingMode -> RoundingMode -> Bool # (>) :: RoundingMode -> RoundingMode -> Bool # (>=) :: RoundingMode -> RoundingMode -> Bool # max :: RoundingMode -> RoundingMode -> RoundingMode # min :: RoundingMode -> RoundingMode -> RoundingMode #
Read RoundingMode #
Instance details Defined in Numeric.Rounded.Rounding Methods readsPrec :: Int -> ReadS RoundingMode # readList :: ReadS [RoundingMode] # readPrec :: ReadPrec RoundingMode # readListPrec :: ReadPrec [RoundingMode] #
Show RoundingMode #
Instance details Defined in Numeric.Rounded.Rounding Methods showsPrec :: Int -> RoundingMode -> ShowS # show :: RoundingMode -> String # showList :: [RoundingMode] -> ShowS #
SingI TowardNearestWithTiesAwayFromZero #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardNearestWithTiesAwayFromZero #
SingI TowardNearest #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardNearest #
SingI TowardZero #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardZero #
SingI TowardInf #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardInf #
SingI TowardNegInf #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardNegInf #
SingI AwayFromZero #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing AwayFromZero #
SingI Faithfully #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing Faithfully #
newtype Sing (m :: RoundingMode) #
Instance details Defined in Numeric.Rounded.Rounding newtype Sing (m :: RoundingMode) = SRounding RoundingMode

reifyRounding :: RoundingMode -> (forall s. Rounding s => Proxy s -> r) -> r #

Useful Constants

kLog2 :: (Rounding r, Precision p) => Rounded r p #

Natural logarithm of 2

kEuler :: (Rounding r, Precision p) => Rounded r p #

577...

kCatalan :: (Rounding r, Precision p) => Rounded r p #

915...

Combinators that are oblivious to precision

(.+.) :: Rounding r => Rounded r p -> Rounded r p -> Rounded r p infixl 6 #

(.-.) :: Rounding r => Rounded r p -> Rounded r p -> Rounded r p infixl 6 #

(.*.) :: Rounding r => Rounded r p -> Rounded r p -> Rounded r p infixl 7 #

abs' :: Rounded r p -> Rounded r p #

negate' :: Rounded r p -> Rounded r p #

decodeFloat' :: Rounded r p -> (Integer, Int) #

succUlp :: Rounded r p -> Rounded r p #

predUlp :: Rounded r p -> Rounded r p #

Mixed-precision operations

(!+!) :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3 infixl 6 #

(!-!) :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3 infixl 6 #

(!*!) :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3 infixl 7 #

(!/!) :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3 infixl 7 #

abs_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

negate_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

compare_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Ordering #

(!==!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool infix 4 #

(!/=!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool infix 4 #

(!>=!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool infix 4 #

(!<=!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool infix 4 #

(!>!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool infix 4 #

(!<!) :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 -> Bool infix 4 #

min_ :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3 #

max_ :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3 #

sqrt_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

exp_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

expm1_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

log_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

log1p_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

sin_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

cos_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

tan_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

asin_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

acos_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

atan_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

atan2_ :: (Rounding r, Precision p1, Precision p2, Precision p3) => Rounded r p1 -> Rounded r p2 -> Rounded r p3 #

sinh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

cosh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

tanh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

asinh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

acosh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

atanh_ :: (Rounding r, Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

truncate_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

round_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

ceiling_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

floor_ :: (Precision p1, Precision p2) => Rounded r p1 -> Rounded r p2 #

Foreign Function Interface

withInRounded :: Rounded r p -> (Ptr MPFR -> IO a) -> IO a #

Use a value as a constant mpfr_t (attempts to modify it may explode, changing the precision will explode).

withInOutRounded :: Precision p => Rounded r p -> (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p), a) #

Allocates and initializes a new mpfr_t to the value. If the precision matches after the action then it is peeked and returned. Otherwise you get Nothing.

withInOutRounded_ :: Precision p => Rounded r p -> (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p)) #

Allocates and initializes a new mpfr_t to the value. If the precision matches after the action then it is peeked and returned. Otherwise you get Nothing. The result ot the action is ignored.

withOutRounded :: Precision p => (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p), a) #

Allocates and initializes a new mpfr_t, if the precision matches after the action then it is peeked and returned. Otherwise you get Nothing.

withOutRounded_ :: Precision p => (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p)) #

Allocates and initializes a new mpfr_t, if the precision matches after the action then it is peeked and returned. Otherwise you get Nothing. The result of the action is ignored.

unsafeWithOutRounded :: Precision p => (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p), a) #

Like withOutRounded but with the limbs allocated by GHC, which should be slightly faster. However, it will crash if MPFR tries to reallocate the limbs, so the action must not try to change the precision or clear it, etc.

unsafeWithOutRounded_ :: Precision p => (Ptr MPFR -> IO a) -> IO (Maybe (Rounded r p)) #

Like withOutRounded_ but with the limbs allocated by GHC, which should be slightly faster. However, it will crash if MPFR tries to reallocate the limbs, so the action must not try to change the precision or clear it, etc.

peekRounded :: Rounding r => Ptr MPFR -> (forall (p :: *). Precision p => Rounded r p -> IO a) -> IO a #

Peek an mpfr_t at its actual precision, reified.