Copyright | (c) The University of Glasgow 2002 |
---|---|

License | BSD-style (see the file libraries/base/LICENSE) |

Maintainer | [email protected] |

Stability | provisional |

Portability | portable |

Safe Haskell | Trustworthy |

Language | Haskell2010 |

Odds and ends, mostly functions for reading and showing `RealFloat`

-like kind of values.

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

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 Source

Show *non-negative* `Integral`

numbers in base 10.

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

Show *non-negative* `Integral`

numbers in base 16.

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

Show *non-negative* `Integral`

numbers in base 8.

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

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 Source

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 Source

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.

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

Show a signed `RealFloat`

value using standard decimal notation (e.g. `245000`

, `0.0015`

).

This behaves as `showFFloat`

, except that a decimal point is always guaranteed, even if not needed.

Since: 4.7.0.0

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

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.

This behaves as `showFFloat`

, except that a decimal point is always guaranteed, even if not needed.

Since: 4.7.0.0

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.

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

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

Reads a *signed* `Real`

value, given a reader for an unsigned value.

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

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

Read an unsigned number in decimal notation.

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

Read an unsigned number in octal notation.

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

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

readFloat :: RealFrac a => ReadS a Source

Reads an *unsigned* `RealFrac`

value, expressed in decimal scientific notation.

lexDigits :: ReadS String Source

Reads a non-empty string of decimal digits.

© The University of Glasgow and others

Licensed under a BSD-style license (see top of the page).

https://downloads.haskell.org/~ghc/7.10.3/docs/html/libraries/base-4.8.2.0/Numeric.html