{-# LANGUAGE Trustworthy #-}{-# LANGUAGE NoImplicitPrelude, MagicHash #-}------------------------------------------------------------------------------- |-- Module : Numeric-- Copyright : (c) The University of Glasgow 2002-- License : BSD-style (see the file libraries/base/LICENSE)---- Maintainer : libraries@haskell.org-- Stability : provisional-- Portability : portable---- Odds and ends, mostly functions for reading and showing-- 'RealFloat'-like kind of values.-------------------------------------------------------------------------------moduleNumeric(-- * ShowingshowSigned ,showIntAtBase ,showInt ,showBin ,showHex ,showOct ,showEFloat ,showFFloat ,showGFloat ,showFFloatAlt ,showGFloatAlt ,showFloat ,showHFloat ,floatToDigits ,-- * Reading-- | /NB:/ 'readInt' is the \'dual\' of 'showIntAtBase',-- and 'readDec' is the \`dual\' of 'showInt'.-- The inconsistent naming is a historical accident.readSigned ,readInt ,readBin ,readDec ,readOct ,readHex ,readFloat ,lexDigits ,-- * MiscellaneousfromRat ,Floating (..))whereimportGHC.Base importGHC.Read importGHC.Real importGHC.Float importGHC.Num importGHC.Show importText.ParserCombinators.ReadP (ReadP ,readP_to_S ,pfail )importqualifiedText.Read.Lex asL-- $setup-- >>> import Prelude-- ------------------------------------------------------------------------------- Reading-- | Reads an /unsigned/ 'Integral' value in an arbitrary base.readInt ::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 readInt :: forall a. Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadS a
readInt a
base Char -> Bool
isDigit Char -> Int
valDigit =forall a. ReadP a -> ReadS a
readP_to_S (forall a. Num a => a -> (Char -> Bool) -> (Char -> Int) -> ReadP a
L.readIntP a
base Char -> Bool
isDigit Char -> Int
valDigit )-- | Read an unsigned number in binary notation.---- >>> readBin "10011"-- [(19,"")]readBin ::(Eq a ,Num a )=>ReadS a readBin :: forall a. (Eq a, Num a) => ReadS a
readBin =forall a. ReadP a -> ReadS a
readP_to_S forall a. (Eq a, Num a) => ReadP a
L.readBinP -- | Read an unsigned number in octal notation.---- >>> readOct "0644"-- [(420,"")]readOct ::(Eq a ,Num a )=>ReadS a readOct :: forall a. (Eq a, Num a) => ReadS a
readOct =forall a. ReadP a -> ReadS a
readP_to_S forall a. (Eq a, Num a) => ReadP a
L.readOctP -- | Read an unsigned number in decimal notation.---- >>> readDec "0644"-- [(644,"")]readDec ::(Eq a ,Num a )=>ReadS a readDec :: forall a. (Eq a, Num a) => ReadS a
readDec =forall a. ReadP a -> ReadS a
readP_to_S forall a. (Eq a, Num a) => ReadP a
L.readDecP -- | Read an unsigned number in hexadecimal notation.-- Both upper or lower case letters are allowed.---- >>> readHex "deadbeef"-- [(3735928559,"")]readHex ::(Eq a ,Num a )=>ReadS a readHex :: forall a. (Eq a, Num a) => ReadS a
readHex =forall a. ReadP a -> ReadS a
readP_to_S forall a. (Eq a, Num a) => ReadP a
L.readHexP -- | Reads an /unsigned/ 'RealFrac' value,-- expressed in decimal scientific notation.readFloat ::RealFrac a =>ReadS a readFloat :: forall a. RealFrac a => ReadS a
readFloat =forall a. ReadP a -> ReadS a
readP_to_S forall a. RealFrac a => ReadP a
readFloatP readFloatP ::RealFrac a =>ReadP a readFloatP :: forall a. RealFrac a => ReadP a
readFloatP =doLexeme
tok <-ReadP Lexeme
L.lex caseLexeme
tok ofL.Number Number
n ->forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. Fractional a => Rational -> a
fromRational forall a b. (a -> b) -> a -> b
$ Number -> Rational
L.numberToRational Number
n Lexeme
_->forall a. ReadP a
pfail -- It's turgid to have readSigned work using list comprehensions,-- but it's specified as a ReadS to ReadS transformer-- With a bit of luck no one will use it.-- | Reads a /signed/ 'Real' value, given a reader for an unsigned value.readSigned ::(Real a )=>ReadS a ->ReadS a readSigned :: forall a. Real a => ReadS a -> ReadS a
readSigned ReadS a
readPos =forall a. Bool -> ReadS a -> ReadS a
readParen Bool
False ReadS a
read' whereread' :: ReadS a
read' String
r =ReadS a
read'' String
r forall a. [a] -> [a] -> [a]
++ (do(String
"-",String
s )<-ReadS String
lex String
r (a
x ,String
t )<-ReadS a
read'' String
s forall (m :: * -> *) a. Monad m => a -> m a
return (-a
x ,String
t ))read'' :: ReadS a
read'' String
r =do(String
str ,String
s )<-ReadS String
lex String
r (a
n ,String
"")<-ReadS a
readPos String
str forall (m :: * -> *) a. Monad m => a -> m a
return (a
n ,String
s )-- ------------------------------------------------------------------------------- Showing-- | Show /non-negative/ 'Integral' numbers in base 10.showInt ::Integral a =>a ->ShowS showInt :: forall a. Integral a => a -> ShowS
showInt a
n0 String
cs0 |a
n0 forall a. Ord a => a -> a -> Bool
< a
0=forall a. String -> a
errorWithoutStackTrace String
"Numeric.showInt: can't show negative numbers"|Bool
otherwise =forall a. Integral a => a -> ShowS
go a
n0 String
cs0 wherego :: t -> ShowS
go t
n String
cs |t
n forall a. Ord a => a -> a -> Bool
< t
10=caseInt -> Char
unsafeChr (Char -> Int
ord Char
'0'forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral t
n )ofc :: Char
c @(C# Char#
_)->Char
c forall a. a -> [a] -> [a]
: String
cs |Bool
otherwise =caseInt -> Char
unsafeChr (Char -> Int
ord Char
'0'forall a. Num a => a -> a -> a
+ forall a b. (Integral a, Num b) => a -> b
fromIntegral t
r )ofc :: Char
c @(C# Char#
_)->t -> ShowS
go t
q (Char
c forall a. a -> [a] -> [a]
: String
cs )where(t
q ,t
r )=t
n forall a. Integral a => a -> a -> (a, a)
`quotRem` t
10-- Controlling the format and precision of floats. The code that-- implements the formatting itself is in @PrelNum@ to avoid-- mutual module deps.{-# SPECIALIZEshowEFloat ::Maybe Int ->Float ->ShowS ,Maybe Int ->Double ->ShowS #-}{-# SPECIALIZEshowFFloat ::Maybe Int ->Float ->ShowS ,Maybe Int ->Double ->ShowS #-}{-# SPECIALIZEshowGFloat ::Maybe Int ->Float ->ShowS ,Maybe Int ->Double ->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.showEFloat ::(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.showFFloat ::(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.showGFloat ::(RealFloat a )=>Maybe Int ->a ->ShowS showEFloat :: forall a. RealFloat a => Maybe Int -> a -> ShowS
showEFloat Maybe Int
d a
x =String -> ShowS
showString (forall a. RealFloat a => FFFormat -> Maybe Int -> a -> String
formatRealFloat FFFormat
FFExponent Maybe Int
d a
x )showFFloat :: forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloat Maybe Int
d a
x =String -> ShowS
showString (forall a. RealFloat a => FFFormat -> Maybe Int -> a -> String
formatRealFloat FFFormat
FFFixed Maybe Int
d a
x )showGFloat :: forall a. RealFloat a => Maybe Int -> a -> ShowS
showGFloat Maybe Int
d a
x =String -> ShowS
showString (forall a. RealFloat a => FFFormat -> Maybe Int -> a -> String
formatRealFloat FFFormat
FFGeneric Maybe Int
d a
x )-- | 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.0showFFloatAlt ::(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.---- This behaves as 'showFFloat', except that a decimal point-- is always guaranteed, even if not needed.---- @since 4.7.0.0showGFloatAlt ::(RealFloat a )=>Maybe Int ->a ->ShowS showFFloatAlt :: forall a. RealFloat a => Maybe Int -> a -> ShowS
showFFloatAlt Maybe Int
d a
x =String -> ShowS
showString (forall a.
RealFloat a =>
FFFormat -> Maybe Int -> Bool -> a -> String
formatRealFloatAlt FFFormat
FFFixed Maybe Int
d Bool
True a
x )showGFloatAlt :: forall a. RealFloat a => Maybe Int -> a -> ShowS
showGFloatAlt Maybe Int
d a
x =String -> ShowS
showString (forall a.
RealFloat a =>
FFFormat -> Maybe Int -> Bool -> a -> String
formatRealFloatAlt FFFormat
FFGeneric Maybe Int
d Bool
True a
x ){- | Show a floating-point value in the hexadecimal format,
similar to the @%a@ specifier in C's printf.
 >>> showHFloat (212.21 :: Double) ""
 "0x1.a86b851eb851fp7"
 >>> showHFloat (-12.76 :: Float) ""
 "-0x1.9851ecp3"
 >>> showHFloat (-0 :: Double) ""
 "-0x0p+0"
-}showHFloat ::RealFloat a =>a ->ShowS showHFloat :: forall a. RealFloat a => a -> ShowS
showHFloat =String -> ShowS
showString forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {a}. RealFloat a => a -> String
fmt wherefmt :: a -> String
fmt a
x |forall a. RealFloat a => a -> Bool
isNaN a
x =String
"NaN"|forall a. RealFloat a => a -> Bool
isInfinite a
x =(ifa
x forall a. Ord a => a -> a -> Bool
< a
0thenString
"-"elseString
"")forall a. [a] -> [a] -> [a]
++ String
"Infinity"|a
x forall a. Ord a => a -> a -> Bool
< a
0Bool -> Bool -> Bool
|| forall a. RealFloat a => a -> Bool
isNegativeZero a
x =Char
'-'forall a. a -> [a] -> [a]
: forall {a}. RealFloat a => a -> String
cvt (-a
x )|Bool
otherwise =forall {a}. RealFloat a => a -> String
cvt a
x cvt :: a -> String
cvt a
x |a
x forall a. Eq a => a -> a -> Bool
== a
0=String
"0x0p+0"|Bool
otherwise =caseforall a. RealFloat a => Integer -> a -> ([Int], Int)
floatToDigits Integer
2a
x ofr :: ([Int], Int)
r @([],Int
_)->forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"Impossible happened: showHFloat: "forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show ([Int], Int)
r (Int
d : [Int]
ds ,Int
e )->String
"0x"forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show Int
d forall a. [a] -> [a] -> [a]
++ forall {a}. (Integral a, Show a) => [a] -> String
frac [Int]
ds forall a. [a] -> [a] -> [a]
++ String
"p"forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show (Int
e forall a. Num a => a -> a -> a
- Int
1)-- Given binary digits, convert them to hex in blocks of 4-- Special case: If all 0's, just drop it.frac :: [a] -> String
frac [a]
digits |forall {a}. (Eq a, Num a) => [a] -> Bool
allZ [a]
digits =String
""|Bool
otherwise =String
"."forall a. [a] -> [a] -> [a]
++ forall {a}. (Integral a, Show a) => [a] -> String
hex [a]
digits wherehex :: [a] -> String
hex [a]
ds =case[a]
ds of[]->String
""[a
a ]->forall {a}. (Integral a, Show a) => a -> a -> a -> a -> ShowS
hexDigit a
a a
0a
0a
0String
""[a
a ,a
b ]->forall {a}. (Integral a, Show a) => a -> a -> a -> a -> ShowS
hexDigit a
a a
b a
0a
0String
""[a
a ,a
b ,a
c ]->forall {a}. (Integral a, Show a) => a -> a -> a -> a -> ShowS
hexDigit a
a a
b a
c a
0String
""a
a : a
b : a
c : a
d : [a]
r ->forall {a}. (Integral a, Show a) => a -> a -> a -> a -> ShowS
hexDigit a
a a
b a
c a
d ([a] -> String
hex [a]
r )hexDigit :: a -> a -> a -> a -> ShowS
hexDigit a
a a
b a
c a
d =forall a. (Integral a, Show a) => a -> ShowS
showHex (a
8forall a. Num a => a -> a -> a
* a
a forall a. Num a => a -> a -> a
+ a
4forall a. Num a => a -> a -> a
* a
b forall a. Num a => a -> a -> a
+ a
2forall a. Num a => a -> a -> a
* a
c forall a. Num a => a -> a -> a
+ a
d )allZ :: [a] -> Bool
allZ [a]
xs =case[a]
xs ofa
x : [a]
more ->a
x forall a. Eq a => a -> a -> Bool
== a
0Bool -> Bool -> Bool
&& [a] -> Bool
allZ [a]
more []->Bool
True -- ----------------------------------------------------------------------------- Integer printing functions-- | Shows a /non-negative/ 'Integral' number using the base specified by the-- first argument, and the character representation specified by the second.showIntAtBase ::(Integral a ,Show a )=>a ->(Int ->Char )->a ->ShowS showIntAtBase :: forall a. (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
showIntAtBase a
base Int -> Char
toChr a
n0 String
r0 |a
base forall a. Ord a => a -> a -> Bool
<= a
1=forall a. String -> a
errorWithoutStackTrace (String
"Numeric.showIntAtBase: applied to unsupported base "forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
base )|a
n0 forall a. Ord a => a -> a -> Bool
< a
0=forall a. String -> a
errorWithoutStackTrace (String
"Numeric.showIntAtBase: applied to negative number "forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show a
n0 )|Bool
otherwise =(a, a) -> ShowS
showIt (forall a. Integral a => a -> a -> (a, a)
quotRem a
n0 a
base )String
r0 whereshowIt :: (a, a) -> ShowS
showIt (a
n ,a
d )String
r =seq :: forall a b. a -> b -> b
seq Char
c forall a b. (a -> b) -> a -> b
$ -- stricter than necessarycasea
n ofa
0->String
r' a
_->(a, a) -> ShowS
showIt (forall a. Integral a => a -> a -> (a, a)
quotRem a
n a
base )String
r' wherec :: Char
c =Int -> Char
toChr (forall a b. (Integral a, Num b) => a -> b
fromIntegral a
d )r' :: String
r' =Char
c forall a. a -> [a] -> [a]
: String
r -- | Show /non-negative/ 'Integral' numbers in base 16.showHex ::(Integral a ,Show a )=>a ->ShowS showHex :: forall a. (Integral a, Show a) => a -> ShowS
showHex =forall a. (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
showIntAtBase a
16Int -> Char
intToDigit -- | Show /non-negative/ 'Integral' numbers in base 8.showOct ::(Integral a ,Show a )=>a ->ShowS showOct :: forall a. (Integral a, Show a) => a -> ShowS
showOct =forall a. (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
showIntAtBase a
8Int -> Char
intToDigit -- | Show /non-negative/ 'Integral' numbers in base 2.showBin ::(Integral a ,Show a )=>a ->ShowS showBin :: forall a. (Integral a, Show a) => a -> ShowS
showBin =forall a. (Integral a, Show a) => a -> (Int -> Char) -> a -> ShowS
showIntAtBase a
2Int -> Char
intToDigit