Numeric

Contents

Synopsis

# Showing

showSigned

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

Shows a non-negative `Integral` number using the base specified by the first argument, and the character representation specified by the second.

showInt :: Integral a => a -> ShowS

Show non-negative `Integral` numbers in base 10.

showHex :: (Integral a, Show a) => a -> ShowS

Show non-negative `Integral` numbers in base 16.

showOct :: (Integral a, Show a) => a -> ShowS

Show non-negative `Integral` numbers in base 8.

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

Show a signed `RealFloat` value using scientific (exponential) notation (e.g. `2.45e2`, `1.5e-3`).

In the call `showEFloat digs val`, if `digs` is `Nothing`, the value is shown to full precision; if `digs` is `Just d`, then at most `d` digits after the decimal point are shown.

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

Show a signed `RealFloat` value using standard decimal notation (e.g. `245000`, `0.0015`).

In the call `showFFloat digs val`, if `digs` is `Nothing`, the value is shown to full precision; if `digs` is `Just d`, then at most `d` digits after the decimal point are shown.

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

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 `showGFloat digs val`, if `digs` is `Nothing`, the value is shown to full precision; if `digs` is `Just d`, then at most `d` digits after the decimal point are shown.

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.

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

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

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 a

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 `Int` -> ReadS a

Reads an unsigned `Integral` value in an arbitrary base.

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

Read an unsigned number in decimal notation.

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

Read an unsigned number in octal notation.

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

Read an unsigned number in hexadecimal notation. Both upper or lower case letters are allowed.

readFloat :: RealFrac a => ReadS a

Reads an unsigned `RealFrac` value, expressed in decimal scientific notation.

Reads a non-empty string of decimal digits.

# Miscellaneous

fromRat :: RealFloat a => Rational -> a

Converts a `Rational` value into any type in class `RealFloat`.