| Safe Haskell | Safe |
|---|
Numeric
Contents
- showSigned :: Real a => (a -> ShowS) -> Int -> a -> ShowS
- showIntAtBase :: (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
- showInt :: Integral a => a -> ShowS
- showHex :: (Integral a, Show a) => a -> ShowS
- showOct :: (Integral a, Show a) => a -> ShowS
- showEFloat :: RealFloat a => Maybe Int -> a -> ShowS
- showFFloat :: RealFloat a => Maybe Int -> a -> ShowS
- showGFloat :: RealFloat a => Maybe Int -> a -> ShowS
- showFloat :: RealFloat a => a -> ShowS
- floatToDigits :: RealFloat a => Integer -> a -> ([Int], Int)
- readSigned :: Real a => ReadS a -> ReadS a
- readInt :: Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
- readDec :: (Eq a, Num a) => ReadS a
- readOct :: (Eq a, Num a) => ReadS a
- readHex :: (Eq a, Num a) => ReadS a
- readFloat :: RealFrac a => ReadS a
- lexDigits :: ReadS String
- fromRat :: RealFloat a => Rational -> a
Showing
Arguments
| :: Real a | |
| => (a -> ShowS) | a function that can show unsigned values |
| -> Int | the precedence of the enclosing context |
| -> a | the value to show |
| -> ShowS |
Converts a possibly-negative Real value to a string.
showIntAtBase :: (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowSSource
Shows a non-negative Integral number using the base specified by the
first argument, and the character representation specified by the second.
showEFloat :: RealFloat a => Maybe Int -> a -> ShowSSource
Show a signed RealFloat value
using scientific (exponential) notation (e.g. 2.45e2, 1.5e-3).
In the call , if showEFloat digs valdigs is Nothing,
the value is shown to full precision; if digs is ,
then at most Just dd digits after the decimal point are shown.
showFFloat :: RealFloat a => Maybe Int -> a -> ShowSSource
Show a signed RealFloat value
using standard decimal notation (e.g. 245000, 0.0015).
In the call , if showFFloat digs valdigs is Nothing,
the value is shown to full precision; if digs is ,
then at most Just dd digits after the decimal point are shown.
showGFloat :: RealFloat a => Maybe Int -> a -> ShowSSource
Show a signed RealFloat value
using standard decimal notation for arguments whose absolute value lies
between 0.1 and 9,999,999, and scientific notation otherwise.
In the call , if showGFloat digs valdigs is Nothing,
the value is shown to full precision; if digs is ,
then at most Just dd digits after the decimal point are shown.
showFloat :: RealFloat a => a -> ShowSSource
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.
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
Reading
NB: readInt is the 'dual' of showIntAtBase,
and readDec is the `dual' of showInt.
The inconsistent naming is a historical accident.
readSigned :: Real a => ReadS a -> ReadS aSource
Reads a signed Real value, given a reader for an unsigned value.
Arguments
| :: Num a | |
| => a | the base |
| -> (Char -> Bool) | a predicate distinguishing valid digits in this base |
| -> (Char -> Int) | a function converting a valid digit character to an |
| -> ReadS a |
Reads an unsigned Integral value in an arbitrary base.
readHex :: (Eq a, Num a) => ReadS aSource
Read an unsigned number in hexadecimal notation. Both upper or lower case letters are allowed.
readFloat :: RealFrac a => ReadS aSource
Reads an unsigned RealFrac value,
expressed in decimal scientific notation.