| 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 | Safe |
| Language | Haskell2010 |
GHC.Float
Description
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
- 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 Source #
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 bexp (fromInteger 0)=fromInteger 1
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Methods
(**) :: a -> a -> a infixr 8 Source #
logBase :: a -> a -> a Source #
log1p xlog (1 + x)x if possible.
@since base-4.9.0.0
expm1 xexp x - 1x if possible.
@since base-4.9.0.0
Instances
class (RealFrac a, Floating a) => RealFloat a where Source #
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 Source #
a constant function, returning the radix of the representation
(often 2)
floatDigits :: a -> Int Source #
a constant function, returning the number of digits of
floatRadix in the significand
floatRange :: a -> (Int, Int) Source #
a constant function, returning the lowest and highest values the exponent may assume
decodeFloat :: a -> (Integer, Int) Source #
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(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) <= , where abs m < b^dd is
the value of floatDigits xdecodeFloat 0 = (0,0)decodeFloat (-0.0) = (0,0)decodeFloat xisNaN xisInfinite xTrue.
encodeFloat :: Integer -> Int -> a Source #
encodeFloat performs the inverse of decodeFloat in the
sense that for finite x with the exception of -0.0,
uncurry encodeFloat (decodeFloat x) = xencodeFloat m nm*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 corresponds to the second component of decodeFloat.
exponent 0 = 0x,
exponent x = snd (decodeFloat x) + floatDigits xx is a finite floating-point number, it is equal in value to
significand x * b ^^ exponent xb is the
floating-point radix.
The behaviour is unspecified on infinite or NaN values.
significand :: a -> a Source #
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 Source #
multiplies a floating-point number by an integer power of the radix
True if the argument is an IEEE "not-a-number" (NaN) value
isInfinite :: a -> Bool Source #
True if the argument is an IEEE infinity or negative infinity
isDenormalized :: a -> Bool Source #
True if the argument is too small to be represented in
normalized format
isNegativeZero :: a -> Bool Source #
True if the argument is an IEEE negative zero
True if the argument is an IEEE floating point number
a version of arctangent taking two real floating-point arguments.
For real floating x and y, atan2 y x(x,y). atan2 y x-pi,
pi]. It follows the Common Lisp semantics for the origin when
signed zeroes are supported. atan2 y 1y in a type
that is RealFloat, should return the same value as atan yatan2 is provided, but implementors
can provide a more accurate implementation.
Instances
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.
Instances
| PrintfArg Float Source # | Since: base-2.1 | ||||
Defined in Text.Printf | |||||
| Data Float | @since base-4.0.0.0 | ||||
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 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float Source # toConstr :: Float -> Constr Source # dataTypeOf :: Float -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) Source # gmapT :: (forall b. Data b => b -> b) -> Float -> Float Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source # | |||||
| Floating Float | @since base-2.01 | ||||
Defined in GHC.Internal.Float Methods exp :: Float -> Float Source # log :: Float -> Float Source # sqrt :: Float -> Float Source # (**) :: Float -> Float -> Float Source # logBase :: Float -> Float -> Float Source # sin :: Float -> Float Source # cos :: Float -> Float Source # tan :: Float -> Float Source # asin :: Float -> Float Source # acos :: Float -> Float Source # atan :: Float -> Float Source # sinh :: Float -> Float Source # cosh :: Float -> Float Source # tanh :: Float -> Float Source # asinh :: Float -> Float Source # acosh :: Float -> Float Source # atanh :: Float -> Float Source # log1p :: Float -> Float Source # expm1 :: Float -> Float Source # | |||||
| RealFloat Float | @since base-2.01 | ||||
Defined in GHC.Internal.Float Methods floatRadix :: Float -> Integer Source # floatDigits :: Float -> Int Source # floatRange :: Float -> (Int, Int) Source # decodeFloat :: Float -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Float Source # exponent :: Float -> Int Source # significand :: Float -> Float Source # scaleFloat :: Int -> Float -> Float Source # isNaN :: Float -> Bool Source # isInfinite :: Float -> Bool Source # isDenormalized :: Float -> Bool Source # isNegativeZero :: Float -> Bool Source # | |||||
| Storable Float | @since base-2.01 | ||||
Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Float -> Int Source # alignment :: Float -> Int Source # peekElemOff :: Ptr Float -> Int -> IO Float Source # pokeElemOff :: Ptr Float -> Int -> Float -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Float Source # pokeByteOff :: Ptr b -> Int -> Float -> IO () Source # | |||||
| Read Float | @since base-2.01 | ||||
| Eq Float | Note that due to the presence of
Also note that
| ||||
| Ord Float | See | ||||
Defined in GHC.Classes | |||||
| Generic1 (URec Float :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Foldable (UFloat :: Type -> Type) | @since base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UFloat m -> m Source # foldMap :: Monoid m => (a -> m) -> UFloat a -> m Source # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m Source # foldr :: (a -> b -> b) -> b -> UFloat a -> b Source # foldr' :: (a -> b -> b) -> b -> UFloat a -> b Source # foldl :: (b -> a -> b) -> b -> UFloat a -> b Source # foldl' :: (b -> a -> b) -> b -> UFloat a -> b Source # foldr1 :: (a -> a -> a) -> UFloat a -> a Source # foldl1 :: (a -> a -> a) -> UFloat a -> a Source # toList :: UFloat a -> [a] Source # null :: UFloat a -> Bool Source # length :: UFloat a -> Int Source # elem :: Eq a => a -> UFloat a -> Bool Source # maximum :: Ord a => UFloat a -> a Source # minimum :: Ord a => UFloat a -> a Source # | |||||
| Traversable (UFloat :: Type -> Type) | @since base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Traversable | |||||
| Functor (URec Float :: Type -> Type) | @since base-4.9.0.0 | ||||
| Generic (URec Float p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Show (URec Float p) | |||||
| Eq (URec Float p) | |||||
| Ord (URec Float p) | |||||
Defined in GHC.Internal.Generics Methods compare :: URec Float p -> URec Float p -> Ordering Source # (<) :: URec Float p -> URec Float p -> Bool Source # (<=) :: URec Float p -> URec Float p -> Bool Source # (>) :: URec Float p -> URec Float p -> Bool Source # (>=) :: URec Float p -> URec Float p -> Bool Source # max :: URec Float p -> URec Float p -> URec Float p Source # min :: URec Float p -> URec Float p -> URec Float p Source # | |||||
| data URec Float (p :: k) | Used for marking occurrences of @since base-4.9.0.0 | ||||
| type Rep1 (URec Float :: k -> Type) | @since base-4.9.0.0 | ||||
Defined in GHC.Internal.Generics | |||||
| type Rep (URec Float p) | |||||
Defined in GHC.Internal.Generics | |||||
Conversion
word2Float :: Word -> Float Source #
integerToFloat# :: Integer -> Float# Source #
Convert an Integer to a Float#
naturalToFloat# :: Natural -> Float# Source #
Convert a Natural to a Float#
castWord32ToFloat :: Word32 -> Float Source #
castWord32ToFloat w
@since base-4.11.0.0
castFloatToWord32 :: Float -> Word32 Source #
castFloatToWord32 f
@since base-4.11.0.0
float2Double :: Float -> Double Source #
Operations
floorFloat :: Integral b => Float -> b Source #
ceilingFloat :: Integral b => Float -> b Source #
truncateFloat :: Integral b => Float -> b Source #
roundFloat :: Integral b => Float -> b Source #
Predicate
isFloatDenormalized :: Float -> Int Source #
isFloatFinite :: Float -> Int Source #
isFloatInfinite :: Float -> Int Source #
isFloatNaN :: Float -> Int Source #
isFloatNegativeZero :: Float -> Int Source #
Comparison
Arithmetic
negateFloat :: Float -> Float Source #
expm1Float :: Float -> Float Source #
log1pFloat :: Float -> Float Source #
asinhFloat :: Float -> Float Source #
acoshFloat :: Float -> Float Source #
atanhFloat :: Float -> Float Source #
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.
Instances
| PrintfArg Double Source # | Since: base-2.1 | ||||
Defined in Text.Printf Methods formatArg :: Double -> FieldFormatter Source # parseFormat :: Double -> ModifierParser Source # | |||||
| Data Double | @since base-4.0.0.0 | ||||
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 Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double Source # toConstr :: Double -> Constr Source # dataTypeOf :: Double -> DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) Source # gmapT :: (forall b. Data b => b -> b) -> Double -> Double Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source # | |||||
| Floating Double | @since base-2.01 | ||||
Defined in GHC.Internal.Float Methods exp :: Double -> Double Source # log :: Double -> Double Source # sqrt :: Double -> Double Source # (**) :: Double -> Double -> Double Source # logBase :: Double -> Double -> Double Source # sin :: Double -> Double Source # cos :: Double -> Double Source # tan :: Double -> Double Source # asin :: Double -> Double Source # acos :: Double -> Double Source # atan :: Double -> Double Source # sinh :: Double -> Double Source # cosh :: Double -> Double Source # tanh :: Double -> Double Source # asinh :: Double -> Double Source # acosh :: Double -> Double Source # atanh :: Double -> Double Source # log1p :: Double -> Double Source # expm1 :: Double -> Double Source # | |||||
| RealFloat Double | @since base-2.01 | ||||
Defined in GHC.Internal.Float Methods floatRadix :: Double -> Integer Source # floatDigits :: Double -> Int Source # floatRange :: Double -> (Int, Int) Source # decodeFloat :: Double -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Double Source # exponent :: Double -> Int Source # significand :: Double -> Double Source # scaleFloat :: Int -> Double -> Double Source # isNaN :: Double -> Bool Source # isInfinite :: Double -> Bool Source # isDenormalized :: Double -> Bool Source # isNegativeZero :: Double -> Bool Source # | |||||
| Storable Double | @since base-2.01 | ||||
Defined in GHC.Internal.Foreign.Storable Methods sizeOf :: Double -> Int Source # alignment :: Double -> Int Source # peekElemOff :: Ptr Double -> Int -> IO Double Source # pokeElemOff :: Ptr Double -> Int -> Double -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Double Source # pokeByteOff :: Ptr b -> Int -> Double -> IO () Source # | |||||
| Read Double | @since base-2.01 | ||||
| Eq Double | Note that due to the presence of
Also note that
| ||||
| Ord Double | IEEE 754 IEEE 754-2008, section 5.11 requires that if at least one of arguments of
IEEE 754-2008, section 5.10 defines Thus, users must be extremely cautious when using Moving further, the behaviour of IEEE 754-2008 compliant | ||||
| Generic1 (URec Double :: k -> Type) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Foldable (UDouble :: Type -> Type) | @since base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Foldable Methods fold :: Monoid m => UDouble m -> m Source # foldMap :: Monoid m => (a -> m) -> UDouble a -> m Source # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m Source # foldr :: (a -> b -> b) -> b -> UDouble a -> b Source # foldr' :: (a -> b -> b) -> b -> UDouble a -> b Source # foldl :: (b -> a -> b) -> b -> UDouble a -> b Source # foldl' :: (b -> a -> b) -> b -> UDouble a -> b Source # foldr1 :: (a -> a -> a) -> UDouble a -> a Source # foldl1 :: (a -> a -> a) -> UDouble a -> a Source # toList :: UDouble a -> [a] Source # null :: UDouble a -> Bool Source # length :: UDouble a -> Int Source # elem :: Eq a => a -> UDouble a -> Bool Source # maximum :: Ord a => UDouble a -> a Source # minimum :: Ord a => UDouble a -> a Source # | |||||
| Traversable (UDouble :: Type -> Type) | @since base-4.9.0.0 | ||||
Defined in GHC.Internal.Data.Traversable | |||||
| Functor (URec Double :: Type -> Type) | @since base-4.9.0.0 | ||||
| Generic (URec Double p) | |||||
Defined in GHC.Internal.Generics Associated Types
| |||||
| Show (URec Double p) | @since base-4.9.0.0 | ||||
| Eq (URec Double p) | @since base-4.9.0.0 | ||||
| Ord (URec Double p) | @since base-4.9.0.0 | ||||
Defined in GHC.Internal.Generics Methods compare :: URec Double p -> URec Double p -> Ordering Source # (<) :: URec Double p -> URec Double p -> Bool Source # (<=) :: URec Double p -> URec Double p -> Bool Source # (>) :: URec Double p -> URec Double p -> Bool Source # (>=) :: URec Double p -> URec Double p -> Bool Source # max :: URec Double p -> URec Double p -> URec Double p Source # min :: URec Double p -> URec Double p -> URec Double p Source # | |||||
| data URec Double (p :: k) | Used for marking occurrences of @since base-4.9.0.0 | ||||
| type Rep1 (URec Double :: k -> Type) | @since base-4.9.0.0 | ||||
Defined in GHC.Internal.Generics | |||||
| type Rep (URec Double p) | @since base-4.9.0.0 | ||||
Defined in GHC.Internal.Generics | |||||
Conversion
double2Int :: Double -> Int Source #
int2Double :: Int -> Double Source #
word2Double :: Word -> Double Source #
integerToDouble# :: Integer -> Double# Source #
Convert an Integer to a Double#
naturalToDouble# :: Natural -> Double# Source #
Encode a Natural (mantissa) into a Double#
castWord64ToDouble :: Word64 -> Double Source #
castWord64ToDouble w
@since base-4.11.0.0
castDoubleToWord64 :: Double -> Word64 Source #
castDoubleToWord64 f
@since base-4.11.0.0
double2Float :: Double -> Float Source #
Operations
floorDouble :: Integral b => Double -> b Source #
ceilingDouble :: Integral b => Double -> b Source #
truncateDouble :: Integral b => Double -> b Source #
roundDouble :: Integral b => Double -> b Source #
Predicate
isDoubleDenormalized :: Double -> Int Source #
isDoubleFinite :: Double -> Int Source #
isDoubleInfinite :: Double -> Int Source #
isDoubleNaN :: Double -> Int Source #
isDoubleNegativeZero :: Double -> Int Source #
Comparison
Arithmetic
negateDouble :: Double -> Double Source #
expm1Double :: Double -> Double Source #
log1pDouble :: Double -> Double Source #
sqrtDouble :: Double -> Double Source #
fabsDouble :: Double -> Double Source #
asinDouble :: Double -> Double Source #
acosDouble :: Double -> Double Source #
atanDouble :: Double -> Double Source #
sinhDouble :: Double -> Double Source #
coshDouble :: Double -> Double Source #
tanhDouble :: Double -> Double Source #
asinhDouble :: Double -> Double Source #
acoshDouble :: Double -> Double Source #
atanhDouble :: Double -> Double Source #
Formatting
showFloat :: RealFloat a => a -> ShowS Source #
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.
Operations
log1mexpOrd :: (Ord a, Floating a) => a -> a Source #
floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int) Source #
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 Source #
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.
Monomorphic equality operators
See GHC.Classes#matching_overloaded_methods_in_rules
Internal
These may vanish in a future release
clamp :: Int -> Int -> Int Source #
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
>>>clamp (-10) 510
@since base-4.13.0.0
stgDoubleToWord64 :: Double# -> Word64# Source #
stgFloatToWord32 :: Float# -> Word32# Source #
stgWord64ToDouble :: Word64# -> Double# Source #
stgWord32ToFloat :: Word32# -> Float# Source #