Copyright	(c) The University of Glasgow 1994-2002 Portions obtained from hbc (c) Lennart Augusstson
License	see libraries/base/LICENSE
Maintainer	ghc-devs@haskell.org
Stability	internal
Portability	non-portable (GHC Extensions)
Safe Haskell	Trustworthy
Language	Haskell2010

GHC.Internal.Float

Contents

Classes
Float
Double
Formatting
Operations
Monomorphic equality operators
Internal
Orphan instances

Description

The types Float and Double, the classes Floating and RealFloat and casting between Word32 and Float and Word64 and Double.

Synopsis

class Fractional a => Floating a where
- pi :: a
- exp :: a -> a
- log :: a -> a
- sqrt :: a -> a
- (**) :: a -> a -> a
- logBase :: a -> a -> a
- sin :: a -> a
- cos :: a -> a
- tan :: a -> a
- asin :: a -> a
- acos :: a -> a
- atan :: a -> a
- sinh :: a -> a
- cosh :: a -> a
- tanh :: a -> a
- asinh :: a -> a
- acosh :: a -> a
- atanh :: a -> a
- log1p :: a -> a
- expm1 :: a -> a
- log1pexp :: a -> a
- log1mexp :: a -> a
class (RealFrac a, Floating a) => RealFloat a where
- floatRadix :: a -> Integer
- floatDigits :: a -> Int
- floatRange :: a -> (Int, Int)
- decodeFloat :: a -> (Integer, Int)
- encodeFloat :: Integer -> Int -> a
- exponent :: a -> Int
- significand :: a -> a
- scaleFloat :: Int -> a -> a
- isNaN :: a -> Bool
- isInfinite :: a -> Bool
- isDenormalized :: a -> Bool
- isNegativeZero :: a -> Bool
- isIEEE :: a -> Bool
- atan2 :: a -> a -> a
data Float = F# Float#
data Float# :: TYPE 'FloatRep
float2Int :: Float -> Int
int2Float :: Int -> Float
word2Float :: Word -> Float
integerToFloat# :: Integer -> Float#
naturalToFloat# :: Natural -> Float#
rationalToFloat :: Integer -> Integer -> Float
castWord32ToFloat :: Word32 -> Float
castFloatToWord32 :: Float -> Word32
castWord32ToFloat# :: Word32# -> Float#
castFloatToWord32# :: Float# -> Word32#
float2Double :: Float -> Double
floorFloat :: Integral b => Float -> b
ceilingFloat :: Integral b => Float -> b
truncateFloat :: Integral b => Float -> b
roundFloat :: Integral b => Float -> b
properFractionFloat :: Integral b => Float -> (b, Float)
isFloatDenormalized :: Float -> Int
isFloatFinite :: Float -> Int
isFloatInfinite :: Float -> Int
isFloatNaN :: Float -> Int
isFloatNegativeZero :: Float -> Int
gtFloat :: Float -> Float -> Bool
geFloat :: Float -> Float -> Bool
leFloat :: Float -> Float -> Bool
ltFloat :: Float -> Float -> Bool
plusFloat :: Float -> Float -> Float
minusFloat :: Float -> Float -> Float
timesFloat :: Float -> Float -> Float
divideFloat :: Float -> Float -> Float
negateFloat :: Float -> Float
expFloat :: Float -> Float
expm1Float :: Float -> Float
logFloat :: Float -> Float
log1pFloat :: Float -> Float
sqrtFloat :: Float -> Float
fabsFloat :: Float -> Float
sinFloat :: Float -> Float
cosFloat :: Float -> Float
tanFloat :: Float -> Float
asinFloat :: Float -> Float
acosFloat :: Float -> Float
atanFloat :: Float -> Float
sinhFloat :: Float -> Float
coshFloat :: Float -> Float
tanhFloat :: Float -> Float
asinhFloat :: Float -> Float
acoshFloat :: Float -> Float
atanhFloat :: Float -> Float
data Double = D# Double#
data Double# :: TYPE 'DoubleRep
double2Int :: Double -> Int
int2Double :: Int -> Double
word2Double :: Word -> Double
integerToDouble# :: Integer -> Double#
naturalToDouble# :: Natural -> Double#
rationalToDouble :: Integer -> Integer -> Double
castWord64ToDouble :: Word64 -> Double
castDoubleToWord64 :: Double -> Word64
castWord64ToDouble# :: Word64# -> Double#
castDoubleToWord64# :: Double# -> Word64#
double2Float :: Double -> Float
floorDouble :: Integral b => Double -> b
ceilingDouble :: Integral b => Double -> b
truncateDouble :: Integral b => Double -> b
roundDouble :: Integral b => Double -> b
properFractionDouble :: Integral b => Double -> (b, Double)
isDoubleDenormalized :: Double -> Int
isDoubleFinite :: Double -> Int
isDoubleInfinite :: Double -> Int
isDoubleNaN :: Double -> Int
isDoubleNegativeZero :: Double -> Int
gtDouble :: Double -> Double -> Bool
geDouble :: Double -> Double -> Bool
leDouble :: Double -> Double -> Bool
ltDouble :: Double -> Double -> Bool
plusDouble :: Double -> Double -> Double
minusDouble :: Double -> Double -> Double
timesDouble :: Double -> Double -> Double
divideDouble :: Double -> Double -> Double
negateDouble :: Double -> Double
expDouble :: Double -> Double
expm1Double :: Double -> Double
logDouble :: Double -> Double
log1pDouble :: Double -> Double
sqrtDouble :: Double -> Double
fabsDouble :: Double -> Double
sinDouble :: Double -> Double
cosDouble :: Double -> Double
tanDouble :: Double -> Double
asinDouble :: Double -> Double
acosDouble :: Double -> Double
atanDouble :: Double -> Double
sinhDouble :: Double -> Double
coshDouble :: Double -> Double
tanhDouble :: Double -> Double
asinhDouble :: Double -> Double
acoshDouble :: Double -> Double
atanhDouble :: Double -> Double
showFloat :: RealFloat a => a -> ShowS
data FFFormat
- = FFExponent
- | FFFixed
- | FFGeneric
formatRealFloat :: RealFloat a => FFFormat -> Maybe Int -> a -> String
formatRealFloatAlt :: RealFloat a => FFFormat -> Maybe Int -> Bool -> a -> String
showSignedFloat :: RealFloat a => (a -> ShowS) -> Int -> a -> ShowS
log1mexpOrd :: (Ord a, Floating a) => a -> a
roundTo :: Int -> Int -> [Int] -> (Int, [Int])
floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int)
integerToBinaryFloat' :: RealFloat a => Integer -> a
fromRat :: RealFloat a => Rational -> a
fromRat' :: RealFloat a => Rational -> a
roundingMode# :: Integer -> Int# -> Int#
eqFloat :: Float -> Float -> Bool
eqDouble :: Double -> Double -> Bool
clamp :: Int -> Int -> Int
expt :: Integer -> Int -> Integer
expts :: Array Int Integer
expts10 :: Array Int Integer
fromRat'' :: RealFloat a => Int -> Int -> Integer -> Integer -> a
maxExpt :: Int
maxExpt10 :: Int
minExpt :: Int
powerDouble :: Double -> Double -> Double
powerFloat :: Float -> Float -> Float
stgDoubleToWord64 :: Double# -> Word64#
stgFloatToWord32 :: Float# -> Word32#
stgWord64ToDouble :: Word64# -> Double#
stgWord32ToFloat :: Word32# -> Float#

Classes

class Fractional a => Floating a where #

Trigonometric and hyperbolic functions and related functions.

The Haskell Report defines no laws for Floating. However, (+), (*) and exp are customarily expected to define an exponential field and have the following properties:

exp (a + b) = exp a * exp b
exp (fromInteger 0) = fromInteger 1

Minimal complete definition

pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh

Methods

pi :: a #

exp :: a -> a #

log :: a -> a #

sqrt :: a -> a #

(**) :: a -> a -> a infixr 8 #

logBase :: a -> a -> a #

sin :: a -> a #

cos :: a -> a #

tan :: a -> a #

asin :: a -> a #

acos :: a -> a #

atan :: a -> a #

sinh :: a -> a #

cosh :: a -> a #

tanh :: a -> a #

asinh :: a -> a #

acosh :: a -> a #

atanh :: a -> a #

log1p :: a -> a #

log1p x computes log (1 + x), but provides more precise results for small (absolute) values of x if possible.

Since: base-4.9.0.0

expm1 :: a -> a #

expm1 x computes exp x - 1, but provides more precise results for small (absolute) values of x if possible.

Since: base-4.9.0.0

log1pexp :: a -> a #

log1pexp x computes log (1 + exp x), but provides more precise results if possible.

Examples:

if x is a large negative number, log (1 + exp x) will be imprecise for the reasons given in log1p.
if exp x is close to -1, log (1 + exp x) will be imprecise for the reasons given in expm1.

Since: base-4.9.0.0

log1mexp :: a -> a #

log1mexp x computes log (1 - exp x), but provides more precise results if possible.

Examples:

if x is a large negative number, log (1 - exp x) will be imprecise for the reasons given in log1p.
if exp x is close to 1, log (1 - exp x) will be imprecise for the reasons given in expm1.

Since: base-4.9.0.0

Instances

Instances details

Floating CDouble #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods pi :: CDouble # exp :: CDouble -> CDouble # log :: CDouble -> CDouble # sqrt :: CDouble -> CDouble # (**) :: CDouble -> CDouble -> CDouble # logBase :: CDouble -> CDouble -> CDouble # sin :: CDouble -> CDouble # cos :: CDouble -> CDouble # tan :: CDouble -> CDouble # asin :: CDouble -> CDouble # acos :: CDouble -> CDouble # atan :: CDouble -> CDouble # sinh :: CDouble -> CDouble # cosh :: CDouble -> CDouble # tanh :: CDouble -> CDouble # asinh :: CDouble -> CDouble # acosh :: CDouble -> CDouble # atanh :: CDouble -> CDouble # log1p :: CDouble -> CDouble # expm1 :: CDouble -> CDouble # log1pexp :: CDouble -> CDouble # log1mexp :: CDouble -> CDouble #
Floating CFloat #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods pi :: CFloat # exp :: CFloat -> CFloat # log :: CFloat -> CFloat # sqrt :: CFloat -> CFloat # (**) :: CFloat -> CFloat -> CFloat # logBase :: CFloat -> CFloat -> CFloat # sin :: CFloat -> CFloat # cos :: CFloat -> CFloat # tan :: CFloat -> CFloat # asin :: CFloat -> CFloat # acos :: CFloat -> CFloat # atan :: CFloat -> CFloat # sinh :: CFloat -> CFloat # cosh :: CFloat -> CFloat # tanh :: CFloat -> CFloat # asinh :: CFloat -> CFloat # acosh :: CFloat -> CFloat # atanh :: CFloat -> CFloat # log1p :: CFloat -> CFloat # expm1 :: CFloat -> CFloat # log1pexp :: CFloat -> CFloat # log1mexp :: CFloat -> CFloat #
Floating Double #	Since: base-2.1
Instance details Defined in GHC.Internal.Float Methods pi :: Double # exp :: Double -> Double # log :: Double -> Double # sqrt :: Double -> Double # (**) :: Double -> Double -> Double # logBase :: Double -> Double -> Double # sin :: Double -> Double # cos :: Double -> Double # tan :: Double -> Double # asin :: Double -> Double # acos :: Double -> Double # atan :: Double -> Double # sinh :: Double -> Double # cosh :: Double -> Double # tanh :: Double -> Double # asinh :: Double -> Double # acosh :: Double -> Double # atanh :: Double -> Double # log1p :: Double -> Double # expm1 :: Double -> Double # log1pexp :: Double -> Double # log1mexp :: Double -> Double #
Floating Float #	Since: base-2.1
Instance details Defined in GHC.Internal.Float Methods pi :: Float # exp :: Float -> Float # log :: Float -> Float # sqrt :: Float -> Float # (**) :: Float -> Float -> Float # logBase :: Float -> Float -> Float # sin :: Float -> Float # cos :: Float -> Float # tan :: Float -> Float # asin :: Float -> Float # acos :: Float -> Float # atan :: Float -> Float # sinh :: Float -> Float # cosh :: Float -> Float # tanh :: Float -> Float # asinh :: Float -> Float # acosh :: Float -> Float # atanh :: Float -> Float # log1p :: Float -> Float # expm1 :: Float -> Float # log1pexp :: Float -> Float # log1mexp :: Float -> Float #
Floating a => Floating (Identity a) #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Identity Methods pi :: Identity a # exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a # expm1 :: Identity a -> Identity a # log1pexp :: Identity a -> Identity a # log1mexp :: Identity a -> Identity a #
Floating a => Floating (Down a) #	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Data.Ord Methods pi :: Down a # exp :: Down a -> Down a # log :: Down a -> Down a # sqrt :: Down a -> Down a # (**) :: Down a -> Down a -> Down a # logBase :: Down a -> Down a -> Down a # sin :: Down a -> Down a # cos :: Down a -> Down a # tan :: Down a -> Down a # asin :: Down a -> Down a # acos :: Down a -> Down a # atan :: Down a -> Down a # sinh :: Down a -> Down a # cosh :: Down a -> Down a # tanh :: Down a -> Down a # asinh :: Down a -> Down a # acosh :: Down a -> Down a # atanh :: Down a -> Down a # log1p :: Down a -> Down a # expm1 :: Down a -> Down a # log1pexp :: Down a -> Down a # log1mexp :: Down a -> Down a #
Floating a => Floating (Const a b) #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods pi :: Const a b # exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b # expm1 :: Const a b -> Const a b # log1pexp :: Const a b -> Const a b # log1mexp :: Const a b -> Const a b #

class (RealFrac a, Floating a) => RealFloat a where #

Efficient, machine-independent access to the components of a floating-point number.

Minimal complete definition

floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE

Methods

floatRadix :: a -> Integer #

a constant function, returning the radix of the representation (often 2)

floatDigits :: a -> Int #

a constant function, returning the number of digits of floatRadix in the significand

floatRange :: a -> (Int, Int) #

A constant function, returning the lowest and highest values that exponent x may assume for a normal x. The relation to IEEE emin and emax is floatRange x = (emin + 1, emax + 1).

decodeFloat :: a -> (Integer, Int) #

The function decodeFloat applied to a real floating-point number returns the significand expressed as an Integer and an appropriately scaled exponent (an Int). If decodeFloat x yields (m,n), then x is equal in value to m*b^^n, where b is the floating-point radix, and furthermore, either m and n are both zero or else b^(d-1) <= abs m < b^d, where d is the value of floatDigits x. In particular, decodeFloat 0 = (0,0). If the type contains a negative zero, also decodeFloat (-0.0) = (0,0). The result of decodeFloat x is unspecified if either of isNaN x or isInfinite x is True.

encodeFloat :: Integer -> Int -> a #

encodeFloat performs the inverse of decodeFloat in the sense that for finite x with the exception of -0.0, uncurry encodeFloat (decodeFloat x) = x. encodeFloat m n is one of the two closest representable floating-point numbers to m*b^^n (or ±Infinity if overflow occurs); usually the closer, but if m contains too many bits, the result may be rounded in the wrong direction.

exponent :: a -> Int #

exponent corresponds to the second component of decodeFloat. exponent 0 = 0 and for finite nonzero x, exponent x = snd (decodeFloat x) + floatDigits x. If x is a finite floating-point number, it is equal in value to significand x * b ^^ exponent x, where b is the floating-point radix. The behaviour is unspecified on infinite or NaN values.

significand :: a -> a #

The first component of decodeFloat, scaled to lie in the open interval (-1,1), either 0.0 or of absolute value >= 1/b, where b is the floating-point radix. The behaviour is unspecified on infinite or NaN values.

scaleFloat :: Int -> a -> a #

multiplies a floating-point number by an integer power of the radix

isNaN :: a -> Bool #

True if the argument is an IEEE "not-a-number" (NaN) value

isInfinite :: a -> Bool #

True if the argument is an IEEE infinity or negative infinity

isDenormalized :: a -> Bool #

True if the argument is too small to be represented in normalized format

isNegativeZero :: a -> Bool #

True if the argument is an IEEE negative zero

isIEEE :: a -> Bool #

True if the argument is an IEEE floating point number

atan2 :: a -> a -> a #

a version of arctangent taking two real floating-point arguments. For real floating x and y, atan2 y x computes the angle (from the positive x-axis) of the vector from the origin to the point (x,y). atan2 y x returns a value in the range [-pi, pi]. It follows the Common Lisp semantics for the origin when signed zeroes are supported. atan2 y 1, with y in a type that is RealFloat, should return the same value as atan y. A default definition of atan2 is provided, but implementors can provide a more accurate implementation.

Instances

Instances details

RealFloat CDouble #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods floatRadix :: CDouble -> Integer # floatDigits :: CDouble -> Int # floatRange :: CDouble -> (Int, Int) # decodeFloat :: CDouble -> (Integer, Int) # encodeFloat :: Integer -> Int -> CDouble # exponent :: CDouble -> Int # significand :: CDouble -> CDouble # scaleFloat :: Int -> CDouble -> CDouble # isNaN :: CDouble -> Bool # isInfinite :: CDouble -> Bool # isDenormalized :: CDouble -> Bool # isNegativeZero :: CDouble -> Bool # isIEEE :: CDouble -> Bool # atan2 :: CDouble -> CDouble -> CDouble #
RealFloat CFloat #
Instance details Defined in GHC.Internal.Foreign.C.Types Methods floatRadix :: CFloat -> Integer # floatDigits :: CFloat -> Int # floatRange :: CFloat -> (Int, Int) # decodeFloat :: CFloat -> (Integer, Int) # encodeFloat :: Integer -> Int -> CFloat # exponent :: CFloat -> Int # significand :: CFloat -> CFloat # scaleFloat :: Int -> CFloat -> CFloat # isNaN :: CFloat -> Bool # isInfinite :: CFloat -> Bool # isDenormalized :: CFloat -> Bool # isNegativeZero :: CFloat -> Bool # isIEEE :: CFloat -> Bool # atan2 :: CFloat -> CFloat -> CFloat #
RealFloat Double #	Since: base-2.1
Instance details Defined in GHC.Internal.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # exponent :: Double -> Int # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isNaN :: Double -> Bool # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # isIEEE :: Double -> Bool # atan2 :: Double -> Double -> Double #
RealFloat Float #	Since: base-2.1
Instance details Defined in GHC.Internal.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # exponent :: Float -> Int # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isNaN :: Float -> Bool # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # isIEEE :: Float -> Bool # atan2 :: Float -> Float -> Float #
RealFloat a => RealFloat (Identity a) #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Identity Methods floatRadix :: Identity a -> Integer # floatDigits :: Identity a -> Int # floatRange :: Identity a -> (Int, Int) # decodeFloat :: Identity a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Identity a # exponent :: Identity a -> Int # significand :: Identity a -> Identity a # scaleFloat :: Int -> Identity a -> Identity a # isNaN :: Identity a -> Bool # isInfinite :: Identity a -> Bool # isDenormalized :: Identity a -> Bool # isNegativeZero :: Identity a -> Bool # isIEEE :: Identity a -> Bool # atan2 :: Identity a -> Identity a -> Identity a #
RealFloat a => RealFloat (Down a) #	Since: base-4.14.0.0
Instance details Defined in GHC.Internal.Data.Ord Methods floatRadix :: Down a -> Integer # floatDigits :: Down a -> Int # floatRange :: Down a -> (Int, Int) # decodeFloat :: Down a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Down a # exponent :: Down a -> Int # significand :: Down a -> Down a # scaleFloat :: Int -> Down a -> Down a # isNaN :: Down a -> Bool # isInfinite :: Down a -> Bool # isDenormalized :: Down a -> Bool # isNegativeZero :: Down a -> Bool # isIEEE :: Down a -> Bool # atan2 :: Down a -> Down a -> Down a #
RealFloat a => RealFloat (Const a b) #	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Data.Functor.Const Methods floatRadix :: Const a b -> Integer # floatDigits :: Const a b -> Int # floatRange :: Const a b -> (Int, Int) # decodeFloat :: Const a b -> (Integer, Int) # encodeFloat :: Integer -> Int -> Const a b # exponent :: Const a b -> Int # significand :: Const a b -> Const a b # scaleFloat :: Int -> Const a b -> Const a b # isNaN :: Const a b -> Bool # isInfinite :: Const a b -> Bool # isDenormalized :: Const a b -> Bool # isNegativeZero :: Const a b -> Bool # isIEEE :: Const a b -> Bool # atan2 :: Const a b -> Const a b -> Const a b #

`Float`

data Float #

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Constructors

F# Float#

Instances

Instances details

Eq Float #

Note that due to the presence of NaN, Float's Eq instance does not satisfy reflexivity.

>>> 0/0 == (0/0 :: Float)
False

Also note that Float's Eq instance does not satisfy extensionality:

>>> 0 == (-0 :: Float)
True
>>> recip 0 == recip (-0 :: Float)
False

Instance details

Defined in GHC.Internal.Classes

Methods

(==) :: Float -> Float -> Bool #

(/=) :: Float -> Float -> Bool #

Ord Float #

See instance Ord Double for discussion of deviations from IEEE 754 standard.

Instance details

Defined in GHC.Internal.Classes

Methods

compare :: Float -> Float -> Ordering #

(<) :: Float -> Float -> Bool #

(<=) :: Float -> Float -> Bool #

(>) :: Float -> Float -> Bool #

(>=) :: Float -> Float -> Bool #

max :: Float -> Float -> Float #

min :: Float -> Float -> Float #

Data Float #

Since: base-4.0.0.0

Instance details

Defined in GHC.Internal.Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float #

toConstr :: Float -> Constr #

dataTypeOf :: Float -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) #

gmapT :: (forall b. Data b => b -> b) -> Float -> Float #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r #

gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float #

Enum Float #

fromEnum just truncates its argument, beware of all sorts of overflows.

List generators have extremely peculiar behavior, mandated by Haskell Report 2010:

>>> [0..1.5 :: Float]
[0.0,1.0,2.0]

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

succ :: Float -> Float #

pred :: Float -> Float #

toEnum :: Int -> Float #

fromEnum :: Float -> Int #

enumFrom :: Float -> [Float] #

enumFromThen :: Float -> Float -> [Float] #

enumFromTo :: Float -> Float -> [Float] #

enumFromThenTo :: Float -> Float -> Float -> [Float] #

Floating Float #

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

pi :: Float #

exp :: Float -> Float #

log :: Float -> Float #

sqrt :: Float -> Float #

(**) :: Float -> Float -> Float #

logBase :: Float -> Float -> Float #

sin :: Float -> Float #

cos :: Float -> Float #

tan :: Float -> Float #

asin :: Float -> Float #

acos :: Float -> Float #

atan :: Float -> Float #

sinh :: Float -> Float #

cosh :: Float -> Float #

tanh :: Float -> Float #

asinh :: Float -> Float #

acosh :: Float -> Float #

atanh :: Float -> Float #

log1p :: Float -> Float #

expm1 :: Float -> Float #

log1pexp :: Float -> Float #

log1mexp :: Float -> Float #

RealFloat Float #

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

floatRadix :: Float -> Integer #

floatDigits :: Float -> Int #

floatRange :: Float -> (Int, Int) #

decodeFloat :: Float -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Float #

exponent :: Float -> Int #

significand :: Float -> Float #

scaleFloat :: Int -> Float -> Float #

isNaN :: Float -> Bool #

isInfinite :: Float -> Bool #

isDenormalized :: Float -> Bool #

isNegativeZero :: Float -> Bool #

isIEEE :: Float -> Bool #

atan2 :: Float -> Float -> Float #

Storable Float #

Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Float -> Int #

alignment :: Float -> Int #

peekElemOff :: Ptr Float -> Int -> IO Float #

pokeElemOff :: Ptr Float -> Int -> Float -> IO () #

peekByteOff :: Ptr b -> Int -> IO Float #

pokeByteOff :: Ptr b -> Int -> Float -> IO () #

peek :: Ptr Float -> IO Float #

poke :: Ptr Float -> Float -> IO () #

Num Float #

This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero. Neither addition nor multiplication are associative or distributive:

>>> (0.1 + 0.1 :: Float) + 0.5 == 0.1 + (0.1 + 0.5)
False
>>> (0.1 + 0.2 :: Float) * 0.9 == 0.1 * 0.9 + 0.2 * 0.9
False
>>> (0.1 * 0.1 :: Float) * 0.9 == 0.1 * (0.1 * 0.9)
False

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

(+) :: Float -> Float -> Float #

(-) :: Float -> Float -> Float #

(*) :: Float -> Float -> Float #

negate :: Float -> Float #

abs :: Float -> Float #

signum :: Float -> Float #

fromInteger :: Integer -> Float #

Read Float #

Since: base-2.1

Instance details

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Float #

readList :: ReadS [Float] #

readPrec :: ReadPrec Float #

readListPrec :: ReadPrec [Float] #

Fractional Float #

This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero.

>>> 0 == (-0 :: Float)
True
>>> recip 0 == recip (-0 :: Float)
False
>>> map (/ 0) [-1, 0, 1 :: Float]
[-Infinity,NaN,Infinity]
>>> map (* 0) $ map (/ 0) [-1, 0, 1 :: Float]
[NaN,NaN,NaN]

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

(/) :: Float -> Float -> Float #

recip :: Float -> Float #

fromRational :: Rational -> Float #

Real Float #

Beware that toRational generates garbage for non-finite arguments:

>>> toRational (1/0 :: Float)
340282366920938463463374607431768211456 % 1
>>> toRational (0/0 :: Float)
510423550381407695195061911147652317184 % 1

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

toRational :: Float -> Rational #

RealFrac Float #

Beware that results for non-finite arguments are garbage:

>>> [ f x | f <- [round, floor, ceiling], x <- [-1/0, 0/0, 1/0 :: Float] ] :: [Int]
[0,0,0,0,0,0,0,0,0]
>>> map properFraction [-1/0, 0/0, 1/0] :: [(Int, Float)]
[(0,0.0),(0,0.0),(0,0.0)]

and get even more non-sensical if you ask for Integer instead of Int.

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

properFraction :: Integral b => Float -> (b, Float) #

truncate :: Integral b => Float -> b #

round :: Integral b => Float -> b #

ceiling :: Integral b => Float -> b #

floor :: Integral b => Float -> b #

Show Float #

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

showsPrec :: Int -> Float -> ShowS #

show :: Float -> String #

showList :: [Float] -> ShowS #

Lift Float #

Instance details

Defined in GHC.Internal.TH.Lift

Methods

lift :: Quote m => Float -> m Exp #

liftTyped :: forall (m :: Type -> Type). Quote m => Float -> Code m Float #

Generic1 (URec Float :: k -> Type) #

Instance details

Defined in GHC.Internal.Generics

Associated Types

type Rep1 (URec Float :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))

Methods

from1 :: forall (a :: k). URec Float a -> Rep1 (URec Float :: k -> Type) a #

to1 :: forall (a :: k). Rep1 (URec Float :: k -> Type) a -> URec Float a #

Foldable (UFloat :: Type -> Type) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => UFloat m -> m #

foldMap :: Monoid m => (a -> m) -> UFloat a -> m #

foldMap' :: Monoid m => (a -> m) -> UFloat a -> m #

foldr :: (a -> b -> b) -> b -> UFloat a -> b #

foldr' :: (a -> b -> b) -> b -> UFloat a -> b #

foldl :: (b -> a -> b) -> b -> UFloat a -> b #

foldl' :: (b -> a -> b) -> b -> UFloat a -> b #

foldr1 :: (a -> a -> a) -> UFloat a -> a #

foldl1 :: (a -> a -> a) -> UFloat a -> a #

toList :: UFloat a -> [a] #

null :: UFloat a -> Bool #

length :: UFloat a -> Int #

elem :: Eq a => a -> UFloat a -> Bool #

maximum :: Ord a => UFloat a -> a #

minimum :: Ord a => UFloat a -> a #

sum :: Num a => UFloat a -> a #

product :: Num a => UFloat a -> a #

Traversable (UFloat :: Type -> Type) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) #

sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) #

mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) #

sequence :: Monad m => UFloat (m a) -> m (UFloat a) #

Functor (URec Float :: Type -> Type) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b #

(<$) :: a -> URec Float b -> URec Float a #

Eq (URec Float p) #

Instance details

Defined in GHC.Internal.Generics

Methods

(==) :: URec Float p -> URec Float p -> Bool #

(/=) :: URec Float p -> URec Float p -> Bool #

Ord (URec Float p) #

Instance details

Defined in GHC.Internal.Generics

Methods

compare :: URec Float p -> URec Float p -> Ordering #

(<) :: URec Float p -> URec Float p -> Bool #

(<=) :: URec Float p -> URec Float p -> Bool #

(>) :: URec Float p -> URec Float p -> Bool #

(>=) :: URec Float p -> URec Float p -> Bool #

max :: URec Float p -> URec Float p -> URec Float p #

min :: URec Float p -> URec Float p -> URec Float p #

Generic (URec Float p) #

Instance details

Defined in GHC.Internal.Generics

Associated Types

type Rep (URec Float p)
Instance details Defined in GHC.Internal.Generics type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))

Methods

from :: URec Float p -> Rep (URec Float p) x #

to :: Rep (URec Float p) x -> URec Float p #

Show (URec Float p) #

Instance details

Defined in GHC.Internal.Generics

Methods

showsPrec :: Int -> URec Float p -> ShowS #

show :: URec Float p -> String #

showList :: [URec Float p] -> ShowS #

data URec Float (p :: k) #

Used for marking occurrences of Float#

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

data URec Float (p :: k) = UFloat {

uFloat# :: Float#

}

type Rep1 (URec Float :: k -> Type) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))

type Rep (URec Float p) #

Instance details

Defined in GHC.Internal.Generics

type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))

data Float# :: TYPE 'FloatRep #

Instances

Instances details

Lift Float# #	Since: template-haskell-2.16.0.0
Instance details Defined in GHC.Internal.TH.Lift Methods lift :: Quote m => Float# -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Float# -> Code m Float# #

Conversion

float2Int :: Float -> Int #

int2Float :: Int -> Float #

word2Float :: Word -> Float #

integerToFloat# :: Integer -> Float# #

Convert an Integer to a Float#

naturalToFloat# :: Natural -> Float# #

Convert a Natural to a Float#

rationalToFloat :: Integer -> Integer -> Float #

castWord32ToFloat :: Word32 -> Float #

castWord32ToFloat w does a bit-for-bit copy from an integral value to a floating-point value.

Since: base-4.11.0.0

castFloatToWord32 :: Float -> Word32 #

castFloatToWord32 f does a bit-for-bit copy from a floating-point value to an integral value.

Since: base-4.11.0.0

castWord32ToFloat# :: Word32# -> Float# #

Bitcast a Word32# into a Float#

castFloatToWord32# :: Float# -> Word32# #

Bitcast a Float# into a Word32#

float2Double :: Float -> Double #

Operations

floorFloat :: Integral b => Float -> b #

ceilingFloat :: Integral b => Float -> b #

truncateFloat :: Integral b => Float -> b #

roundFloat :: Integral b => Float -> b #

properFractionFloat :: Integral b => Float -> (b, Float) #

Predicate

isFloatDenormalized :: Float -> Int #

isFloatFinite :: Float -> Int #

isFloatInfinite :: Float -> Int #

isFloatNaN :: Float -> Int #

isFloatNegativeZero :: Float -> Int #

Comparison

gtFloat :: Float -> Float -> Bool #

geFloat :: Float -> Float -> Bool #

leFloat :: Float -> Float -> Bool #

ltFloat :: Float -> Float -> Bool #

Arithmetic

plusFloat :: Float -> Float -> Float #

minusFloat :: Float -> Float -> Float #

timesFloat :: Float -> Float -> Float #

divideFloat :: Float -> Float -> Float #

negateFloat :: Float -> Float #

expFloat :: Float -> Float #

expm1Float :: Float -> Float #

logFloat :: Float -> Float #

log1pFloat :: Float -> Float #

sqrtFloat :: Float -> Float #

fabsFloat :: Float -> Float #

sinFloat :: Float -> Float #

cosFloat :: Float -> Float #

tanFloat :: Float -> Float #

asinFloat :: Float -> Float #

acosFloat :: Float -> Float #

atanFloat :: Float -> Float #

sinhFloat :: Float -> Float #

coshFloat :: Float -> Float #

tanhFloat :: Float -> Float #

asinhFloat :: Float -> Float #

acoshFloat :: Float -> Float #

atanhFloat :: Float -> Float #

`Double`

data Double #

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Constructors

D# Double#

Instances

Instances details

Eq Double #

Note that due to the presence of NaN, Double's Eq instance does not satisfy reflexivity.

>>> 0/0 == (0/0 :: Double)
False

Also note that Double's Eq instance does not satisfy substitutivity:

>>> 0 == (-0 :: Double)
True
>>> recip 0 == recip (-0 :: Double)
False

Instance details

Defined in GHC.Internal.Classes

Methods

(==) :: Double -> Double -> Bool #

(/=) :: Double -> Double -> Bool #

Ord Double #

IEEE 754 Double-precision type includes not only numbers, but also positive and negative infinities and a special element called NaN (which can be quiet or signal).

IEEE 754-2008, section 5.11 requires that if at least one of arguments of <=, <, >, >= is NaN then the result of the comparison is False, and instance Ord Double complies with this requirement. This violates the reflexivity: both NaN <= NaN and NaN >= NaN are False.

IEEE 754-2008, section 5.10 defines totalOrder predicate. Unfortunately, compare on Doubles violates the IEEE standard and does not define a total order. More specifically, both compare NaN x and compare x NaN always return GT.

Thus, users must be extremely cautious when using instance Ord Double. For instance, one should avoid ordered containers with keys represented by Double, because data loss and corruption may happen. An IEEE-compliant compare is available in fp-ieee package as TotallyOrdered newtype.

Moving further, the behaviour of min and max with regards to NaN is also non-compliant. IEEE 754-2008, section 5.3.1 defines that quiet NaN should be treated as a missing data by minNum and maxNum functions, for example, minNum(NaN, 1) = minNum(1, NaN) = 1. Some languages such as Java deviate from the standard implementing minNum(NaN, 1) = minNum(1, NaN) = NaN. However, min / max in base are even worse: min NaN 1 is 1, but min 1 NaN is NaN.

IEEE 754-2008 compliant min / max can be found in ieee754 package under minNum / maxNum names. Implementations compliant with minimumNumber / maximumNumber from a newer IEEE 754-2019, section 9.6 are available from fp-ieee package.

Instance details

Defined in GHC.Internal.Classes

Methods

compare :: Double -> Double -> Ordering #

(<) :: Double -> Double -> Bool #

(<=) :: Double -> Double -> Bool #

(>) :: Double -> Double -> Bool #

(>=) :: Double -> Double -> Bool #

max :: Double -> Double -> Double #

min :: Double -> Double -> Double #

Data Double #

Since: base-4.0.0.0

Instance details

Defined in GHC.Internal.Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double #

toConstr :: Double -> Constr #

dataTypeOf :: Double -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) #

gmapT :: (forall b. Data b => b -> b) -> Double -> Double #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r #

gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double #

Enum Double #

fromEnum just truncates its argument, beware of all sorts of overflows.

List generators have extremely peculiar behavior, mandated by Haskell Report 2010:

>>> [0..1.5]
[0.0,1.0,2.0]

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

succ :: Double -> Double #

pred :: Double -> Double #

toEnum :: Int -> Double #

fromEnum :: Double -> Int #

enumFrom :: Double -> [Double] #

enumFromThen :: Double -> Double -> [Double] #

enumFromTo :: Double -> Double -> [Double] #

enumFromThenTo :: Double -> Double -> Double -> [Double] #

Floating Double #

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

pi :: Double #

exp :: Double -> Double #

log :: Double -> Double #

sqrt :: Double -> Double #

(**) :: Double -> Double -> Double #

logBase :: Double -> Double -> Double #

sin :: Double -> Double #

cos :: Double -> Double #

tan :: Double -> Double #

asin :: Double -> Double #

acos :: Double -> Double #

atan :: Double -> Double #

sinh :: Double -> Double #

cosh :: Double -> Double #

tanh :: Double -> Double #

asinh :: Double -> Double #

acosh :: Double -> Double #

atanh :: Double -> Double #

log1p :: Double -> Double #

expm1 :: Double -> Double #

log1pexp :: Double -> Double #

log1mexp :: Double -> Double #

RealFloat Double #

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

floatRadix :: Double -> Integer #

floatDigits :: Double -> Int #

floatRange :: Double -> (Int, Int) #

decodeFloat :: Double -> (Integer, Int) #

encodeFloat :: Integer -> Int -> Double #

exponent :: Double -> Int #

significand :: Double -> Double #

scaleFloat :: Int -> Double -> Double #

isNaN :: Double -> Bool #

isInfinite :: Double -> Bool #

isDenormalized :: Double -> Bool #

isNegativeZero :: Double -> Bool #

isIEEE :: Double -> Bool #

atan2 :: Double -> Double -> Double #

Storable Double #

Since: base-2.1

Instance details

Defined in GHC.Internal.Foreign.Storable

Methods

sizeOf :: Double -> Int #

alignment :: Double -> Int #

peekElemOff :: Ptr Double -> Int -> IO Double #

pokeElemOff :: Ptr Double -> Int -> Double -> IO () #

peekByteOff :: Ptr b -> Int -> IO Double #

pokeByteOff :: Ptr b -> Int -> Double -> IO () #

peek :: Ptr Double -> IO Double #

poke :: Ptr Double -> Double -> IO () #

Num Double #

This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero. Neither addition nor multiplication are associative or distributive:

>>> (0.1 + 0.1) + 0.4 == 0.1 + (0.1 + 0.4)
False
>>> (0.1 + 0.2) * 0.3 == 0.1 * 0.3 + 0.2 * 0.3
False
>>> (0.1 * 0.1) * 0.3 == 0.1 * (0.1 * 0.3)
False

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

(+) :: Double -> Double -> Double #

(-) :: Double -> Double -> Double #

(*) :: Double -> Double -> Double #

negate :: Double -> Double #

abs :: Double -> Double #

signum :: Double -> Double #

fromInteger :: Integer -> Double #

Read Double #

Since: base-2.1

Instance details

Defined in GHC.Internal.Read

Methods

readsPrec :: Int -> ReadS Double #

readList :: ReadS [Double] #

readPrec :: ReadPrec Double #

readListPrec :: ReadPrec [Double] #

Fractional Double #

This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero.

>>> 0 == (-0 :: Double)
True
>>> recip 0 == recip (-0 :: Double)
False
>>> map (/ 0) [-1, 0, 1]
[-Infinity,NaN,Infinity]
>>> map (* 0) $ map (/ 0) [-1, 0, 1]
[NaN,NaN,NaN]

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

(/) :: Double -> Double -> Double #

recip :: Double -> Double #

fromRational :: Rational -> Double #

Real Double #

Beware that toRational generates garbage for non-finite arguments:

>>> toRational (1/0)
179769313 (and 300 more digits...) % 1
>>> toRational (0/0)
269653970 (and 300 more digits...) % 1

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

toRational :: Double -> Rational #

RealFrac Double #

Beware that results for non-finite arguments are garbage:

>>> [ f x | f <- [round, floor, ceiling], x <- [-1/0, 0/0, 1/0] ] :: [Int]
[0,0,0,0,0,0,0,0,0]
>>> map properFraction [-1/0, 0/0, 1/0] :: [(Int, Double)]
[(0,0.0),(0,0.0),(0,0.0)]

and get even more non-sensical if you ask for Integer instead of Int.

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

properFraction :: Integral b => Double -> (b, Double) #

truncate :: Integral b => Double -> b #

round :: Integral b => Double -> b #

ceiling :: Integral b => Double -> b #

floor :: Integral b => Double -> b #

Show Double #

Since: base-2.1

Instance details

Defined in GHC.Internal.Float

Methods

showsPrec :: Int -> Double -> ShowS #

show :: Double -> String #

showList :: [Double] -> ShowS #

Lift Double #

Instance details

Defined in GHC.Internal.TH.Lift

Methods

lift :: Quote m => Double -> m Exp #

liftTyped :: forall (m :: Type -> Type). Quote m => Double -> Code m Double #

Generic1 (URec Double :: k -> Type) #

Instance details

Defined in GHC.Internal.Generics

Associated Types

type Rep1 (URec Double :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))

Methods

from1 :: forall (a :: k). URec Double a -> Rep1 (URec Double :: k -> Type) a #

to1 :: forall (a :: k). Rep1 (URec Double :: k -> Type) a -> URec Double a #

Foldable (UDouble :: Type -> Type) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Foldable

Methods

fold :: Monoid m => UDouble m -> m #

foldMap :: Monoid m => (a -> m) -> UDouble a -> m #

foldMap' :: Monoid m => (a -> m) -> UDouble a -> m #

foldr :: (a -> b -> b) -> b -> UDouble a -> b #

foldr' :: (a -> b -> b) -> b -> UDouble a -> b #

foldl :: (b -> a -> b) -> b -> UDouble a -> b #

foldl' :: (b -> a -> b) -> b -> UDouble a -> b #

foldr1 :: (a -> a -> a) -> UDouble a -> a #

foldl1 :: (a -> a -> a) -> UDouble a -> a #

toList :: UDouble a -> [a] #

null :: UDouble a -> Bool #

length :: UDouble a -> Int #

elem :: Eq a => a -> UDouble a -> Bool #

maximum :: Ord a => UDouble a -> a #

minimum :: Ord a => UDouble a -> a #

sum :: Num a => UDouble a -> a #

product :: Num a => UDouble a -> a #

Traversable (UDouble :: Type -> Type) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) #

sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) #

mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b) #

sequence :: Monad m => UDouble (m a) -> m (UDouble a) #

Functor (URec Double :: Type -> Type) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b #

(<$) :: a -> URec Double b -> URec Double a #

Eq (URec Double p) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

Methods

(==) :: URec Double p -> URec Double p -> Bool #

(/=) :: URec Double p -> URec Double p -> Bool #

Ord (URec Double p) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

Methods

compare :: URec Double p -> URec Double p -> Ordering #

(<) :: URec Double p -> URec Double p -> Bool #

(<=) :: URec Double p -> URec Double p -> Bool #

(>) :: URec Double p -> URec Double p -> Bool #

(>=) :: URec Double p -> URec Double p -> Bool #

max :: URec Double p -> URec Double p -> URec Double p #

min :: URec Double p -> URec Double p -> URec Double p #

Generic (URec Double p) #

Instance details

Defined in GHC.Internal.Generics

Associated Types

type Rep (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Internal.Generics type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))

Methods

from :: URec Double p -> Rep (URec Double p) x #

to :: Rep (URec Double p) x -> URec Double p #

Show (URec Double p) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

Methods

showsPrec :: Int -> URec Double p -> ShowS #

show :: URec Double p -> String #

showList :: [URec Double p] -> ShowS #

data URec Double (p :: k) #

Used for marking occurrences of Double#

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

data URec Double (p :: k) = UDouble {

uDouble# :: Double#

}

type Rep1 (URec Double :: k -> Type) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))

type Rep (URec Double p) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Internal.Generics

type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Internal.Generics" "ghc-internal" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))

data Double# :: TYPE 'DoubleRep #

Instances

Instances details

Lift Double# #	Since: template-haskell-2.16.0.0
Instance details Defined in GHC.Internal.TH.Lift Methods lift :: Quote m => Double# -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Double# -> Code m Double# #

Conversion

double2Int :: Double -> Int #

int2Double :: Int -> Double #

word2Double :: Word -> Double #

integerToDouble# :: Integer -> Double# #

Convert an Integer to a Double#

naturalToDouble# :: Natural -> Double# #

Encode a Natural (mantissa) into a Double#

rationalToDouble :: Integer -> Integer -> Double #

castWord64ToDouble :: Word64 -> Double #

castWord64ToDouble w does a bit-for-bit copy from an integral value to a floating-point value.

Since: base-4.11.0.0

castDoubleToWord64 :: Double -> Word64 #

castDoubleToWord64 f does a bit-for-bit copy from a floating-point value to an integral value.

Since: base-4.11.0.0

castWord64ToDouble# :: Word64# -> Double# #

Bitcast a Word64# into a Double#

castDoubleToWord64# :: Double# -> Word64# #

Bitcast a Double# into a Word64#

double2Float :: Double -> Float #

Operations

floorDouble :: Integral b => Double -> b #

ceilingDouble :: Integral b => Double -> b #

truncateDouble :: Integral b => Double -> b #

roundDouble :: Integral b => Double -> b #

properFractionDouble :: Integral b => Double -> (b, Double) #

Predicate

isDoubleDenormalized :: Double -> Int #

isDoubleFinite :: Double -> Int #

isDoubleInfinite :: Double -> Int #

isDoubleNaN :: Double -> Int #

isDoubleNegativeZero :: Double -> Int #

Comparison

gtDouble :: Double -> Double -> Bool #

geDouble :: Double -> Double -> Bool #

leDouble :: Double -> Double -> Bool #

ltDouble :: Double -> Double -> Bool #

Arithmetic

plusDouble :: Double -> Double -> Double #

minusDouble :: Double -> Double -> Double #

timesDouble :: Double -> Double -> Double #

divideDouble :: Double -> Double -> Double #

negateDouble :: Double -> Double #

expDouble :: Double -> Double #

expm1Double :: Double -> Double #

logDouble :: Double -> Double #

log1pDouble :: Double -> Double #

sqrtDouble :: Double -> Double #

fabsDouble :: Double -> Double #

sinDouble :: Double -> Double #

cosDouble :: Double -> Double #

tanDouble :: Double -> Double #

asinDouble :: Double -> Double #

acosDouble :: Double -> Double #

atanDouble :: Double -> Double #

sinhDouble :: Double -> Double #

coshDouble :: Double -> Double #

tanhDouble :: Double -> Double #

asinhDouble :: Double -> Double #

acoshDouble :: Double -> Double #

atanhDouble :: Double -> Double #

Formatting

showFloat :: RealFloat a => a -> ShowS #

Show a signed RealFloat value to full precision using standard decimal notation for arguments whose absolute value lies between 0.1 and 9,999,999, and scientific notation otherwise.

data FFFormat #

Constructors

FFExponent
FFFixed
FFGeneric

formatRealFloat :: RealFloat a => FFFormat -> Maybe Int -> a -> String #

formatRealFloatAlt :: RealFloat a => FFFormat -> Maybe Int -> Bool -> a -> String #

showSignedFloat #

Arguments

:: RealFloat a
=> (a -> ShowS)	a function that can show unsigned values
-> Int	the precedence of the enclosing context
-> a	the value to show
-> ShowS

Operations

log1mexpOrd :: (Ord a, Floating a) => a -> a #

Default implementation for log1mexp requiring Ord to test against a threshold to decide which implementation variant to use.

roundTo :: Int -> Int -> [Int] -> (Int, [Int]) #

floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int) #

floatToDigits takes a base and a non-negative RealFloat number, and returns a list of digits and an exponent. In particular, if x>=0, and

floatToDigits base x = ([d1,d2,...,dn], e)

then

```
n >= 1
```
```
x = 0.d1d2...dn * (base**e)
```
```
0 <= di <= base-1
```

integerToBinaryFloat' :: RealFloat a => Integer -> a #

Converts a positive integer to a floating-point value.

The value nearest to the argument will be returned. If there are two such values, the one with an even significand will be returned (i.e. IEEE roundTiesToEven).

The argument must be strictly positive, and floatRadix (undefined :: a) must be 2.

fromRat :: RealFloat a => Rational -> a #

Converts a Rational value into any type in class RealFloat.

fromRat' :: RealFloat a => Rational -> a #

roundingMode# :: Integer -> Int# -> Int# #

Monomorphic equality operators

See GHC.Internal.Classes#matching_overloaded_methods_in_rules

eqFloat :: Float -> Float -> Bool #

eqDouble :: Double -> Double -> Bool #

Internal

These may vanish in a future release

clamp :: Int -> Int -> Int #

Used to prevent exponent over/underflow when encoding floating point numbers. This is also the same as

\(x,y) -> max (-x) (min x y)

Example

Expand

>>> clamp (-10) 5
10

Since: base-4.13.0.0

expt :: Integer -> Int -> Integer #

expts :: Array Int Integer #

expts10 :: Array Int Integer #

fromRat'' :: RealFloat a => Int -> Int -> Integer -> Integer -> a #

maxExpt :: Int #

maxExpt10 :: Int #

minExpt :: Int #

powerDouble :: Double -> Double -> Double #

powerFloat :: Float -> Float -> Float #

stgDoubleToWord64 :: Double# -> Word64# #

Deprecated: Use castDoubleToWord64# instead

stgFloatToWord32 :: Float# -> Word32# #

Deprecated: Use castFloatToWord32# instead

stgWord64ToDouble :: Word64# -> Double# #

Deprecated: Use castWord64ToDouble# instead

stgWord32ToFloat :: Word32# -> Float# #

Deprecated: Use castWord32ToFloat# instead

Orphan instances

Enum Double #	`fromEnum` just truncates its argument, beware of all sorts of overflows. List generators have extremely peculiar behavior, mandated by Haskell Report 2010: `>>>` `[0..1.5]`[0.0,1.0,2.0] Since: base-2.1
Instance details Methods succ :: Double -> Double # pred :: Double -> Double # toEnum :: Int -> Double # fromEnum :: Double -> Int # enumFrom :: Double -> [Double] # enumFromThen :: Double -> Double -> [Double] # enumFromTo :: Double -> Double -> [Double] # enumFromThenTo :: Double -> Double -> Double -> [Double] #
Enum Float #	`fromEnum` just truncates its argument, beware of all sorts of overflows. List generators have extremely peculiar behavior, mandated by Haskell Report 2010: `>>>` `[0..1.5 :: Float]`[0.0,1.0,2.0] Since: base-2.1
Instance details Methods succ :: Float -> Float # pred :: Float -> Float # toEnum :: Int -> Float # fromEnum :: Float -> Int # enumFrom :: Float -> [Float] # enumFromThen :: Float -> Float -> [Float] # enumFromTo :: Float -> Float -> [Float] # enumFromThenTo :: Float -> Float -> Float -> [Float] #
Num Double #	This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero. Neither addition nor multiplication are associative or distributive: `>>>` `(0.1 + 0.1) + 0.4 == 0.1 + (0.1 + 0.4)`False `>>>` *`(0.1 + 0.2) 0.3 == 0.1 * 0.3 + 0.2 * 0.3`False `>>>` `(0.1 * 0.1) * 0.3 == 0.1 * (0.1 * 0.3)`*False Since: base-2.1*
Instance details Methods (+) :: Double -> Double -> Double # (-) :: Double -> Double -> Double # (*) :: Double -> Double -> Double # negate :: Double -> Double # abs :: Double -> Double # signum :: Double -> Double # fromInteger :: Integer -> Double #
Num Float #	This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero. Neither addition nor multiplication are associative or distributive: `>>>` `(0.1 + 0.1 :: Float) + 0.5 == 0.1 + (0.1 + 0.5)`False `>>>` *`(0.1 + 0.2 :: Float) 0.9 == 0.1 * 0.9 + 0.2 * 0.9`False `>>>` `(0.1 * 0.1 :: Float) * 0.9 == 0.1 * (0.1 * 0.9)`*False Since: base-2.1*
Instance details Methods (+) :: Float -> Float -> Float # (-) :: Float -> Float -> Float # (*) :: Float -> Float -> Float # negate :: Float -> Float # abs :: Float -> Float # signum :: Float -> Float # fromInteger :: Integer -> Float #
Fractional Double #	This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero. `>>>` `0 == (-0 :: Double)`True `>>>` `recip 0 == recip (-0 :: Double)`False `>>>` `map (/ 0) [-1, 0, 1]`[-Infinity,NaN,Infinity] `>>>` *`map ( 0) $ map (/ 0) [-1, 0, 1]`*[NaN,NaN,NaN] Since: base-2.1*
Instance details Methods (/) :: Double -> Double -> Double # recip :: Double -> Double # fromRational :: Rational -> Double #
Fractional Float #	This instance implements IEEE 754 standard with all its usual pitfalls about NaN, infinities and negative zero. `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False `>>>` `map (/ 0) [-1, 0, 1 :: Float]`[-Infinity,NaN,Infinity] `>>>` *`map ( 0) $ map (/ 0) [-1, 0, 1 :: Float]`*[NaN,NaN,NaN] Since: base-2.1*
Instance details Methods (/) :: Float -> Float -> Float # recip :: Float -> Float # fromRational :: Rational -> Float #
Real Double #	Beware that `toRational` generates garbage for non-finite arguments: `>>>` `toRational (1/0)`179769313 (and 300 more digits...) % 1 `>>>` `toRational (0/0)`269653970 (and 300 more digits...) % 1 Since: base-2.1
Instance details Methods toRational :: Double -> Rational #
Real Float #	Beware that `toRational` generates garbage for non-finite arguments: `>>>` `toRational (1/0 :: Float)`340282366920938463463374607431768211456 % 1 `>>>` `toRational (0/0 :: Float)`510423550381407695195061911147652317184 % 1 Since: base-2.1
Instance details Methods toRational :: Float -> Rational #
RealFrac Double #	Beware that results for non-finite arguments are garbage: `>>>` `[ f x \| f <- [round, floor, ceiling], x <- [-1/0, 0/0, 1/0] ] :: [Int]`[0,0,0,0,0,0,0,0,0] `>>>` `map properFraction [-1/0, 0/0, 1/0] :: [(Int, Double)]`[(0,0.0),(0,0.0),(0,0.0)] and get even more non-sensical if you ask for `Integer` instead of `Int`. Since: base-2.1
Instance details Methods properFraction :: Integral b => Double -> (b, Double) # truncate :: Integral b => Double -> b # round :: Integral b => Double -> b # ceiling :: Integral b => Double -> b # floor :: Integral b => Double -> b #
RealFrac Float #	Beware that results for non-finite arguments are garbage: `>>>` `[ f x \| f <- [round, floor, ceiling], x <- [-1/0, 0/0, 1/0 :: Float] ] :: [Int]`[0,0,0,0,0,0,0,0,0] `>>>` `map properFraction [-1/0, 0/0, 1/0] :: [(Int, Float)]`[(0,0.0),(0,0.0),(0,0.0)] and get even more non-sensical if you ask for `Integer` instead of `Int`. Since: base-2.1
Instance details Methods properFraction :: Integral b => Float -> (b, Float) # truncate :: Integral b => Float -> b # round :: Integral b => Float -> b # ceiling :: Integral b => Float -> b # floor :: Integral b => Float -> b #
Show Double #	Since: base-2.1
Instance details Methods showsPrec :: Int -> Double -> ShowS # show :: Double -> String # showList :: [Double] -> ShowS #
Show Float #	Since: base-2.1
Instance details Methods showsPrec :: Int -> Float -> ShowS # show :: Float -> String # showList :: [Float] -> ShowS #