extra-1.8: Extra functions I use.
Safe HaskellSafe-Inferred
LanguageHaskell2010

Numeric.Extra

Description

Extra numeric functions - formatting and specialised conversions.

Synopsis

Documentation

class Fractional a => Floating a where #

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 #

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 #

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 
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 
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 a => Floating (Complex a) 
Instance details

Defined in Data.Complex

Methods

pi :: Complex a #

exp :: Complex a -> Complex a #

log :: Complex a -> Complex a #

sqrt :: Complex a -> Complex a #

(**) :: Complex a -> Complex a -> Complex a #

logBase :: Complex a -> Complex a -> Complex a #

sin :: Complex a -> Complex a #

cos :: Complex a -> Complex a #

tan :: Complex a -> Complex a #

asin :: Complex a -> Complex a #

acos :: Complex a -> Complex a #

atan :: Complex a -> Complex a #

sinh :: Complex a -> Complex a #

cosh :: Complex a -> Complex a #

tanh :: Complex a -> Complex a #

asinh :: Complex a -> Complex a #

acosh :: Complex a -> Complex a #

atanh :: Complex a -> Complex a #

log1p :: Complex a -> Complex a #

expm1 :: Complex a -> Complex a #

log1pexp :: Complex a -> Complex a #

log1mexp :: Complex a -> Complex a #

Floating a => Floating (Identity a) 
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 (Op a b) 
Instance details

Defined in Data.Functor.Contravariant

Methods

pi :: Op a b #

exp :: Op a b -> Op a b #

log :: Op a b -> Op a b #

sqrt :: Op a b -> Op a b #

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

logBase :: Op a b -> Op a b -> Op a b #

sin :: Op a b -> Op a b #

cos :: Op a b -> Op a b #

tan :: Op a b -> Op a b #

asin :: Op a b -> Op a b #

acos :: Op a b -> Op a b #

atan :: Op a b -> Op a b #

sinh :: Op a b -> Op a b #

cosh :: Op a b -> Op a b #

tanh :: Op a b -> Op a b #

asinh :: Op a b -> Op a b #

acosh :: Op a b -> Op a b #

atanh :: Op a b -> Op a b #

log1p :: Op a b -> Op a b #

expm1 :: Op a b -> Op a b #

log1pexp :: Op a b -> Op a b #

log1mexp :: Op a b -> Op a b #

Floating a => Floating (Const a b) 
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 #

Floating (f (g a)) => Floating (Compose f g a) 
Instance details

Defined in Data.Functor.Compose

Methods

pi :: Compose f g a #

exp :: Compose f g a -> Compose f g a #

log :: Compose f g a -> Compose f g a #

sqrt :: Compose f g a -> Compose f g a #

(**) :: Compose f g a -> Compose f g a -> Compose f g a #

logBase :: Compose f g a -> Compose f g a -> Compose f g a #

sin :: Compose f g a -> Compose f g a #

cos :: Compose f g a -> Compose f g a #

tan :: Compose f g a -> Compose f g a #

asin :: Compose f g a -> Compose f g a #

acos :: Compose f g a -> Compose f g a #

atan :: Compose f g a -> Compose f g a #

sinh :: Compose f g a -> Compose f g a #

cosh :: Compose f g a -> Compose f g a #

tanh :: Compose f g a -> Compose f g a #

asinh :: Compose f g a -> Compose f g a #

acosh :: Compose f g a -> Compose f g a #

atanh :: Compose f g a -> Compose f g a #

log1p :: Compose f g a -> Compose f g a #

expm1 :: Compose f g a -> Compose f g a #

log1pexp :: Compose f g a -> Compose f g a #

log1mexp :: Compose f g a -> Compose f g a #

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

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

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

showFFloat :: RealFloat a => Maybe Int -> a -> ShowS #

readBin :: (Eq a, Num a) => ReadS a #

readDec :: (Eq a, Num a) => ReadS a #

readFloat :: RealFrac a => ReadS a #

readHex :: (Eq a, Num a) => ReadS a #

readInt :: Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a #

readOct :: (Eq a, Num a) => ReadS a #

readSigned :: Real a => ReadS a -> ReadS a #

showBin :: Integral a => a -> ShowS #

showEFloat :: RealFloat a => Maybe Int -> a -> ShowS #

showFFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS #

showGFloat :: RealFloat a => Maybe Int -> a -> ShowS #

showGFloatAlt :: RealFloat a => Maybe Int -> a -> ShowS #

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

showHex :: Integral a => a -> ShowS #

showInt :: Integral a => a -> ShowS #

showIntAtBase :: Integral a => a -> (Int -> Char) -> a -> ShowS #

showOct :: Integral a => a -> ShowS #

lexDigits :: ReadS String #

showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS #

showDP :: RealFloat a => Int -> a -> String Source #

Show a number to a fixed number of decimal places.

showDP 4 pi == "3.1416"
showDP 0 pi == "3"
showDP 2 3  == "3.00"

intToDouble :: Int -> Double Source #

Specialised numeric conversion, type restricted version of fromIntegral.

intToFloat :: Int -> Float Source #

Specialised numeric conversion, type restricted version of fromIntegral.

floatToDouble :: Float -> Double Source #

Specialised numeric conversion, type restricted version of realToFrac.

doubleToFloat :: Double -> Float Source #

Specialised numeric conversion, type restricted version of realToFrac.