base-4.3.1.0: Basic libraries

Numeric

Contents

Description

Odds and ends, mostly functions for reading and showing `RealFloat`-like kind of values.

Synopsis

# 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 => 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.

showInt :: Integral a => a -> ShowSSource

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

showHex :: Integral a => a -> ShowSSource

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

showOct :: Integral a => a -> ShowSSource

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

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

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

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.

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.

Read an unsigned number in decimal notation.

Read an unsigned number in octal notation.

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

Reads an unsigned `RealFrac` value, expressed in decimal scientific notation.
Converts a `Rational` value into any type in class `RealFloat`.