Copyright	(C) 2012-2014 Edward Kmett Daniel Peebles (C) 2013-2018 Claude Heiland-Allen
License	LGPL
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 Source #

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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
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) Source #
Instance details Defined in Numeric.Rounded.Internal Methods toRational :: Rounded r p -> Rational #
(Rounding r, Precision p) => RealFloat (Rounded r p) Source #
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) Source #
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) Source #
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 Source #

Construct a properly rounded floating point number from an Int.

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

Construct a rounded floating point number directly from a Double.

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

Construct a rounded floating point number directly from a LongDouble.

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

Round to Double with the given rounding mode.

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

Round to LongDouble with the given rounding mode.

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

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 Source #

Round to a different precision with the given rounding mode.

Precision

class Precision p where Source #

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 Source #

Instances

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

data Bytes (n :: Nat) Source #

Instances

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

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

Rounding

class Rounding (r :: RoundingMode) where Source #

Methods

rounding :: Proxy r -> RoundingMode Source #

Instances

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

data RoundingMode Source #

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 Source #
Instance details Defined in Numeric.Rounded.Rounding Methods minBound :: RoundingMode # maxBound :: RoundingMode #
Enum RoundingMode Source #
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 Source #
Instance details Defined in Numeric.Rounded.Rounding Methods (==) :: RoundingMode -> RoundingMode -> Bool # (/=) :: RoundingMode -> RoundingMode -> Bool #
Data RoundingMode Source #
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 Source #
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 Source #
Instance details Defined in Numeric.Rounded.Rounding Methods readsPrec :: Int -> ReadS RoundingMode # readList :: ReadS [RoundingMode] # readPrec :: ReadPrec RoundingMode # readListPrec :: ReadPrec [RoundingMode] #
Show RoundingMode Source #
Instance details Defined in Numeric.Rounded.Rounding Methods showsPrec :: Int -> RoundingMode -> ShowS # show :: RoundingMode -> String # showList :: [RoundingMode] -> ShowS #
SingI TowardNearestWithTiesAwayFromZero Source #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardNearestWithTiesAwayFromZero #
SingI TowardNearest Source #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardNearest #
SingI TowardZero Source #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardZero #
SingI TowardInf Source #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardInf #
SingI TowardNegInf Source #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing TowardNegInf #
SingI AwayFromZero Source #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing AwayFromZero #
SingI Faithfully Source #
Instance details Defined in Numeric.Rounded.Rounding Methods sing :: Sing Faithfully #
data Sing (m :: RoundingMode) Source #
Instance details Defined in Numeric.Rounded.Rounding data Sing (m :: RoundingMode) = SRounding RoundingMode

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

Useful Constants

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

Natural logarithm of 2

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

577...

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

915...

Combinators that are oblivious to precision

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

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

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

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

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

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

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

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

Mixed-precision operations

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Foreign Function Interface

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

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) Source #

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)) Source #

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) Source #

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)) Source #

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) Source #

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)) Source #

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 Source #

Peek an mpfr_t at its actual precision, reified.