W3cubDocs

/Haskell 8

GHC.Float

Copyright (c) The University of Glasgow 1994-2002
Portions obtained from hbc (c) Lennart Augusstson
License see libraries/base/LICENSE
Maintainer [email protected]
Stability internal
Portability non-portable (GHC Extensions)
Safe Haskell Trustworthy
Language Haskell2010

Description

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

rationalToFloat :: Integer -> Integer -> Float Source

rationalToDouble :: Integer -> Integer -> Double Source

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

exp :: a -> a Source

log :: a -> a Source

sqrt :: a -> a Source

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

logBase :: a -> a -> a Source

sin :: a -> a Source

cos :: a -> a Source

tan :: a -> a Source

asin :: a -> a Source

acos :: a -> a Source

atan :: a -> a Source

sinh :: a -> a Source

cosh :: a -> a Source

tanh :: a -> a Source

asinh :: a -> a Source

acosh :: a -> a Source

atanh :: a -> a Source

log1p :: a -> a Source

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 Source

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 Source

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 Source

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 Double

Since: base-2.1

Instance details

Defined in GHC.Float

Floating Float

Since: base-2.1

Instance details

Defined in GHC.Float

Floating CDouble
Instance details

Defined in Foreign.C.Types

Floating CFloat
Instance details

Defined in Foreign.C.Types

Floating a => Floating (Identity a)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Identity

RealFloat a => Floating (Complex a)

Since: base-2.1

Instance details

Defined in Data.Complex

Floating a => Floating (Op a b)
Instance details

Defined in Data.Functor.Contravariant

Methods

pi :: Op a b Source

exp :: Op a b -> Op a b Source

log :: Op a b -> Op a b Source

sqrt :: Op a b -> Op a b Source

(**) :: Op a b -> Op a b -> Op a b Source

logBase :: Op a b -> Op a b -> Op a b Source

sin :: Op a b -> Op a b Source

cos :: Op a b -> Op a b Source

tan :: Op a b -> Op a b Source

asin :: Op a b -> Op a b Source

acos :: Op a b -> Op a b Source

atan :: Op a b -> Op a b Source

sinh :: Op a b -> Op a b Source

cosh :: Op a b -> Op a b Source

tanh :: Op a b -> Op a b Source

asinh :: Op a b -> Op a b Source

acosh :: Op a b -> Op a b Source

atanh :: Op a b -> Op a b Source

log1p :: Op a b -> Op a b Source

expm1 :: Op a b -> Op a b Source

log1pexp :: Op a b -> Op a b Source

log1mexp :: Op a b -> Op a b Source

Floating a => Floating (Const a b)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Const

Methods

pi :: Const a b Source

exp :: Const a b -> Const a b Source

log :: Const a b -> Const a b Source

sqrt :: Const a b -> Const a b Source

(**) :: Const a b -> Const a b -> Const a b Source

logBase :: Const a b -> Const a b -> Const a b Source

sin :: Const a b -> Const a b Source

cos :: Const a b -> Const a b Source

tan :: Const a b -> Const a b Source

asin :: Const a b -> Const a b Source

acos :: Const a b -> Const a b Source

atan :: Const a b -> Const a b Source

sinh :: Const a b -> Const a b Source

cosh :: Const a b -> Const a b Source

tanh :: Const a b -> Const a b Source

asinh :: Const a b -> Const a b Source

acosh :: Const a b -> Const a b Source

atanh :: Const a b -> Const a b Source

log1p :: Const a b -> Const a b Source

expm1 :: Const a b -> Const a b Source

log1pexp :: Const a b -> Const a b Source

log1mexp :: Const a b -> Const a b Source

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

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

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

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 Source

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

isNaN :: a -> Bool Source

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

isIEEE :: a -> Bool Source

True if the argument is an IEEE floating point number

atan2 :: a -> a -> a Source

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 Double

Since: base-2.1

Instance details

Defined in GHC.Float

RealFloat Float

Since: base-2.1

Instance details

Defined in GHC.Float

RealFloat CDouble
Instance details

Defined in Foreign.C.Types

RealFloat CFloat
Instance details

Defined in Foreign.C.Types

RealFloat a => RealFloat (Identity a)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Identity

RealFloat a => RealFloat (Const a b)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Const

data FFFormat Source

stgDoubleToWord64 :: Double# -> Word# Source

stgWord64ToDouble :: Word# -> Double# Source

stgFloatToWord32 :: Float# -> Word# Source

stgWord32ToFloat :: Word# -> Float# Source

expm1Float :: Float -> Float Source

log1pFloat :: Float -> Float Source

expm1Double :: Double -> Double Source

log1pDouble :: Double -> Double Source

isDoubleFinite :: Double -> Int Source

isDoubleNegativeZero :: Double -> Int Source

isDoubleDenormalized :: Double -> Int Source

isDoubleInfinite :: Double -> Int Source

isDoubleNaN :: Double -> Int Source

isFloatFinite :: Float -> Int Source

isFloatNegativeZero :: Float -> Int Source

isFloatDenormalized :: Float -> Int Source

isFloatInfinite :: Float -> Int Source

isFloatNaN :: Float -> Int Source

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.

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

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

roundTo :: Int -> Int -> [Int] -> (Int, [Int]) 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

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

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

Converts a Rational value into any type in class RealFloat.

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

minExpt :: Int Source

maxExpt :: Int Source

expt :: Integer -> Int -> Integer Source

expts :: Array Int Integer Source

maxExpt10 :: Int Source

expts10 :: Array Int Integer Source

integerLogBase :: Integer -> Integer -> Int Source

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

plusFloat :: Float -> Float -> Float Source

minusFloat :: Float -> Float -> Float Source

timesFloat :: Float -> Float -> Float Source

divideFloat :: Float -> Float -> Float Source

negateFloat :: Float -> Float Source

gtFloat :: Float -> Float -> Bool Source

geFloat :: Float -> Float -> Bool Source

ltFloat :: Float -> Float -> Bool Source

leFloat :: Float -> Float -> Bool Source

expFloat :: Float -> Float Source

logFloat :: Float -> Float Source

sqrtFloat :: Float -> Float Source

fabsFloat :: Float -> Float Source

sinFloat :: Float -> Float Source

cosFloat :: Float -> Float Source

tanFloat :: Float -> Float Source

asinFloat :: Float -> Float Source

acosFloat :: Float -> Float Source

atanFloat :: Float -> Float Source

sinhFloat :: Float -> Float Source

coshFloat :: Float -> Float Source

tanhFloat :: Float -> Float Source

asinhFloat :: Float -> Float Source

acoshFloat :: Float -> Float Source

atanhFloat :: Float -> Float Source

powerFloat :: Float -> Float -> Float Source

plusDouble :: Double -> Double -> Double Source

minusDouble :: Double -> Double -> Double Source

timesDouble :: Double -> Double -> Double Source

divideDouble :: Double -> Double -> Double Source

negateDouble :: Double -> Double Source

gtDouble :: Double -> Double -> Bool Source

geDouble :: Double -> Double -> Bool Source

ltDouble :: Double -> Double -> Bool Source

leDouble :: Double -> Double -> Bool Source

double2Float :: Double -> Float Source

float2Double :: Float -> Double Source

expDouble :: Double -> Double Source

logDouble :: Double -> Double Source

sqrtDouble :: Double -> Double Source

fabsDouble :: Double -> Double Source

sinDouble :: Double -> Double Source

cosDouble :: Double -> Double Source

tanDouble :: 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

powerDouble :: Double -> Double -> Double Source

word2Double :: Word -> Double Source

word2Float :: Word -> Float Source

showSignedFloat Source

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

clamp :: Int -> Int -> Int Source

castWord32ToFloat :: Word32 -> Float Source

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

Since: base-4.10.0.0

castFloatToWord32 :: Float -> Word32 Source

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

Since: base-4.10.0.0

castWord64ToDouble :: Word64 -> Double Source

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

Since: base-4.10.0.0

castDoubleToWord64 :: Double -> Word64 Source

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

Since: base-4.10.0.0

data Float Source

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
Enum Float

Since: base-2.1

Instance details

Defined in GHC.Float

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 substitutivity:

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

Defined in GHC.Classes

Methods

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

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

Floating Float

Since: base-2.1

Instance details

Defined in GHC.Float

Fractional Float

Note that due to the presence of NaN, not all elements of Float have an multiplicative inverse.

>>> 0/0 * (recip 0/0 :: Float)
NaN

Since: base-2.1

Instance details

Defined in GHC.Float

Data Float

Since: base-4.0.0.0

Instance details

Defined in 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

Num Float

Note that due to the presence of NaN, not all elements of Float have an additive inverse.

>>> 0/0 + (negate 0/0 :: Float)
NaN

Also note that due to the presence of -0, Float's Num instance doesn't have an additive identity

>>> 0 + (-0 :: Float)
0.0

Since: base-2.1

Instance details

Defined in GHC.Float

Ord Float

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

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

Also note that, due to the same, Ord's operator interactions are not respected by Float's instance:

>>> (0/0 :: Float) > 1
False
>>> compare (0/0 :: Float) 1
GT
Instance details

Defined in GHC.Classes

Read Float

Since: base-2.1

Instance details

Defined in GHC.Read

Real Float

Since: base-2.1

Instance details

Defined in GHC.Float

RealFloat Float

Since: base-2.1

Instance details

Defined in GHC.Float

RealFrac Float

Since: base-2.1

Instance details

Defined in GHC.Float

Methods

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

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

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

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

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

Show Float

Since: base-2.1

Instance details

Defined in GHC.Float

Storable Float

Since: base-2.1

Instance details

Defined in Foreign.Storable

PrintfArg Float

Since: base-2.1

Instance details

Defined in Text.Printf

Generic1 (URec Float :: k -> Type)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Associated Types

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

Methods

from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a Source

to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a Source

Functor (URec Float :: Type -> Type)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Methods

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

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

Foldable (URec Float :: Type -> Type)

Since: base-4.9.0.0

Instance details

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Float m -> m Source

foldMap :: Monoid m => (a -> m) -> URec Float a -> m Source

foldMap' :: Monoid m => (a -> m) -> URec Float a -> m Source

foldr :: (a -> b -> b) -> b -> URec Float a -> b Source

foldr' :: (a -> b -> b) -> b -> URec Float a -> b Source

foldl :: (b -> a -> b) -> b -> URec Float a -> b Source

foldl' :: (b -> a -> b) -> b -> URec Float a -> b Source

foldr1 :: (a -> a -> a) -> URec Float a -> a Source

foldl1 :: (a -> a -> a) -> URec Float a -> a Source

toList :: URec Float a -> [a] Source

null :: URec Float a -> Bool Source

length :: URec Float a -> Int Source

elem :: Eq a => a -> URec Float a -> Bool Source

maximum :: Ord a => URec Float a -> a Source

minimum :: Ord a => URec Float a -> a Source

sum :: Num a => URec Float a -> a Source

product :: Num a => URec Float a -> a Source

Traversable (URec Float :: Type -> Type)

Since: base-4.9.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b) Source

sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a) Source

mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b) Source

sequence :: Monad m => URec Float (m a) -> m (URec Float a) Source

Eq (URec Float p)
Instance details

Defined in GHC.Generics

Methods

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

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

Ord (URec Float p)
Instance details

Defined in GHC.Generics

Show (URec Float p)
Instance details

Defined in GHC.Generics

Generic (URec Float p)
Instance details

Defined in GHC.Generics

Associated Types

type Rep (URec Float p) :: Type -> Type Source

Methods

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

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

data URec Float (p :: k)

Used for marking occurrences of Float#

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

data URec Float (p :: k) = UFloat {}
type Rep1 (URec Float :: k -> Type)
Instance details

Defined in GHC.Generics

type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" '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.Generics

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

data Double Source

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
Enum Double

Since: base-2.1

Instance details

Defined in GHC.Float

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.Classes

Methods

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

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

Floating Double

Since: base-2.1

Instance details

Defined in GHC.Float

Fractional Double

Note that due to the presence of NaN, not all elements of Double have an multiplicative inverse.

>>> 0/0 * (recip 0/0 :: Double)
NaN

Since: base-2.1

Instance details

Defined in GHC.Float

Data Double

Since: base-4.0.0.0

Instance details

Defined in 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

Num Double

Note that due to the presence of NaN, not all elements of Double have an additive inverse.

>>> 0/0 + (negate 0/0 :: Double)
NaN

Also note that due to the presence of -0, Double's Num instance doesn't have an additive identity

>>> 0 + (-0 :: Double)
0.0

Since: base-2.1

Instance details

Defined in GHC.Float

Ord Double

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

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

Also note that, due to the same, Ord's operator interactions are not respected by Double's instance:

>>> (0/0 :: Double) > 1
False
>>> compare (0/0 :: Double) 1
GT
Instance details

Defined in GHC.Classes

Read Double

Since: base-2.1

Instance details

Defined in GHC.Read

Real Double

Since: base-2.1

Instance details

Defined in GHC.Float

RealFloat Double

Since: base-2.1

Instance details

Defined in GHC.Float

RealFrac Double

Since: base-2.1

Instance details

Defined in GHC.Float

Methods

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

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

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

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

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

Show Double

Since: base-2.1

Instance details

Defined in GHC.Float

Storable Double

Since: base-2.1

Instance details

Defined in Foreign.Storable

PrintfArg Double

Since: base-2.1

Instance details

Defined in Text.Printf

Generic1 (URec Double :: k -> Type)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Associated Types

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

Methods

from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a Source

to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a Source

Functor (URec Double :: Type -> Type)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Methods

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

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

Foldable (URec Double :: Type -> Type)

Since: base-4.9.0.0

Instance details

Defined in Data.Foldable

Methods

fold :: Monoid m => URec Double m -> m Source

foldMap :: Monoid m => (a -> m) -> URec Double a -> m Source

foldMap' :: Monoid m => (a -> m) -> URec Double a -> m Source

foldr :: (a -> b -> b) -> b -> URec Double a -> b Source

foldr' :: (a -> b -> b) -> b -> URec Double a -> b Source

foldl :: (b -> a -> b) -> b -> URec Double a -> b Source

foldl' :: (b -> a -> b) -> b -> URec Double a -> b Source

foldr1 :: (a -> a -> a) -> URec Double a -> a Source

foldl1 :: (a -> a -> a) -> URec Double a -> a Source

toList :: URec Double a -> [a] Source

null :: URec Double a -> Bool Source

length :: URec Double a -> Int Source

elem :: Eq a => a -> URec Double a -> Bool Source

maximum :: Ord a => URec Double a -> a Source

minimum :: Ord a => URec Double a -> a Source

sum :: Num a => URec Double a -> a Source

product :: Num a => URec Double a -> a Source

Traversable (URec Double :: Type -> Type)

Since: base-4.9.0.0

Instance details

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b) Source

sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a) Source

mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b) Source

sequence :: Monad m => URec Double (m a) -> m (URec Double a) Source

Eq (URec Double p)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Methods

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

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

Ord (URec Double p)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Show (URec Double p)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Generic (URec Double p)

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Associated Types

type Rep (URec Double p) :: Type -> Type Source

Methods

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

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

data URec Double (p :: k)

Used for marking occurrences of Double#

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

data URec Double (p :: k) = UDouble {}
type Rep1 (URec Double :: k -> Type)
Instance details

Defined in GHC.Generics

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

Defined in GHC.Generics

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

data Float# :: TYPE 'FloatRep Source

data Double# :: TYPE 'DoubleRep Source

double2Int :: Double -> Int Source

int2Double :: Int -> Double Source

float2Int :: Float -> Int Source

int2Float :: Int -> Float Source

Monomorphic equality operators

See GHC.Classes#matching_overloaded_methods_in_rules

eqFloat :: Float -> Float -> Bool Source

eqDouble :: Double -> Double -> Bool Source

Orphan instances

Enum Double

Since: base-2.1

Instance details
Enum Float

Since: base-2.1

Instance details
Fractional Double

Note that due to the presence of NaN, not all elements of Double have an multiplicative inverse.

>>> 0/0 * (recip 0/0 :: Double)
NaN

Since: base-2.1

Instance details
Fractional Float

Note that due to the presence of NaN, not all elements of Float have an multiplicative inverse.

>>> 0/0 * (recip 0/0 :: Float)
NaN

Since: base-2.1

Instance details
Num Double

Note that due to the presence of NaN, not all elements of Double have an additive inverse.

>>> 0/0 + (negate 0/0 :: Double)
NaN

Also note that due to the presence of -0, Double's Num instance doesn't have an additive identity

>>> 0 + (-0 :: Double)
0.0

Since: base-2.1

Instance details
Num Float

Note that due to the presence of NaN, not all elements of Float have an additive inverse.

>>> 0/0 + (negate 0/0 :: Float)
NaN

Also note that due to the presence of -0, Float's Num instance doesn't have an additive identity

>>> 0 + (-0 :: Float)
0.0

Since: base-2.1

Instance details
Real Double

Since: base-2.1

Instance details
Real Float

Since: base-2.1

Instance details
RealFrac Double

Since: base-2.1

Instance details

Methods

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

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

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

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

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

RealFrac Float

Since: base-2.1

Instance details

Methods

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

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

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

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

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

Show Double

Since: base-2.1

Instance details
Show Float

Since: base-2.1

Instance details

┬ę The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.8.3/docs/html/libraries/base-4.13.0.0/GHC-Float.html