2 % (c) The AQUA Project, Glasgow University, 1994-1996
5 \section[PrelNum]{Module @PrelNum@}
8 {-# OPTIONS -fno-implicit-prelude #-}
14 import {-# SOURCE #-} PrelErr
17 infixl 7 %, /, `quot`, `rem`, `div`, `mod`
20 %*********************************************************
22 \subsection{Standard numeric classes}
24 %*********************************************************
27 class (Num a, Ord a) => Real a where
28 toRational :: a -> Rational
30 class (Real a, Enum a) => Integral a where
31 quot, rem, div, mod :: a -> a -> a
32 quotRem, divMod :: a -> a -> (a,a)
33 toInteger :: a -> Integer
34 toInt :: a -> Int -- partain: Glasgow extension
36 n `quot` d = q where (q,_) = quotRem n d
37 n `rem` d = r where (_,r) = quotRem n d
38 n `div` d = q where (q,_) = divMod n d
39 n `mod` d = r where (_,r) = divMod n d
40 divMod n d = if signum r == negate (signum d) then (q-1, r+d) else qr
41 where qr@(q,r) = quotRem n d
43 class (Num a) => Fractional a where
46 fromRational :: Rational -> a
51 class (Fractional a) => Floating a where
53 exp, log, sqrt :: a -> a
54 (**), logBase :: a -> a -> a
55 sin, cos, tan :: a -> a
56 asin, acos, atan :: a -> a
57 sinh, cosh, tanh :: a -> a
58 asinh, acosh, atanh :: a -> a
60 x ** y = exp (log x * y)
61 logBase x y = log y / log x
64 tanh x = sinh x / cosh x
66 class (Real a, Fractional a) => RealFrac a where
67 properFraction :: (Integral b) => a -> (b,a)
68 truncate, round :: (Integral b) => a -> b
69 ceiling, floor :: (Integral b) => a -> b
71 truncate x = m where (m,_) = properFraction x
73 round x = let (n,r) = properFraction x
74 m = if r < 0 then n - 1 else n + 1
75 in case signum (abs r - 0.5) of
77 0 -> if even n then n else m
80 ceiling x = if r > 0 then n + 1 else n
81 where (n,r) = properFraction x
83 floor x = if r < 0 then n - 1 else n
84 where (n,r) = properFraction x
86 class (RealFrac a, Floating a) => RealFloat a where
87 floatRadix :: a -> Integer
88 floatDigits :: a -> Int
89 floatRange :: a -> (Int,Int)
90 decodeFloat :: a -> (Integer,Int)
91 encodeFloat :: Integer -> Int -> a
94 scaleFloat :: Int -> a -> a
95 isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE
100 exponent x = if m == 0 then 0 else n + floatDigits x
101 where (m,n) = decodeFloat x
103 significand x = encodeFloat m (negate (floatDigits x))
104 where (m,_) = decodeFloat x
106 scaleFloat k x = encodeFloat m (n+k)
107 where (m,n) = decodeFloat x
111 | x == 0 && y > 0 = pi/2
112 | x < 0 && y > 0 = pi + atan (y/x)
113 |(x <= 0 && y < 0) ||
114 (x < 0 && isNegativeZero y) ||
115 (isNegativeZero x && isNegativeZero y)
117 | y == 0 && (x < 0 || isNegativeZero x)
118 = pi -- must be after the previous test on zero y
119 | x==0 && y==0 = y -- must be after the other double zero tests
120 | otherwise = x + y -- x or y is a NaN, return a NaN (via +)
124 %*********************************************************
126 \subsection{Instances for @Int@}
128 %*********************************************************
131 instance Real Int where
132 toRational x = toInteger x % 1
134 instance Integral Int where
135 a@(I# _) `quotRem` b@(I# _) = (a `quotInt` b, a `remInt` b)
136 -- OK, so I made it a little stricter. Shoot me. (WDP 94/10)
138 -- Following chks for zero divisor are non-standard (WDP)
139 a `quot` b = if b /= 0
141 else error "Prelude.Integral.quot{Int}: divide by 0"
142 a `rem` b = if b /= 0
144 else error "Prelude.Integral.rem{Int}: divide by 0"
146 x `div` y = if x > 0 && y < 0 then quotInt (x-y-1) y
147 else if x < 0 && y > 0 then quotInt (x-y+1) y
149 x `mod` y = if x > 0 && y < 0 || x < 0 && y > 0 then
150 if r/=0 then r+y else 0
155 divMod x@(I# _) y@(I# _) = (x `div` y, x `mod` y)
156 -- Stricter. Sorry if you don't like it. (WDP 94/10)
158 --OLD: even x = eqInt (x `mod` 2) 0
159 --OLD: odd x = neInt (x `mod` 2) 0
161 toInteger (I# i) = int2Integer i -- give back a full-blown Integer
166 %*********************************************************
168 \subsection{Instances for @Integer@}
170 %*********************************************************
173 instance Ord Integer where
174 (S# i) <= (S# j) = i <=# j
175 (J# s d) <= (S# i) = cmpIntegerInt# s d i <=# 0#
176 (S# i) <= (J# s d) = cmpIntegerInt# s d i >=# 0#
177 (J# s1 d1) <= (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <=# 0#
179 (S# i) > (S# j) = i ># j
180 (J# s d) > (S# i) = cmpIntegerInt# s d i ># 0#
181 (S# i) > (J# s d) = cmpIntegerInt# s d i <# 0#
182 (J# s1 d1) > (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ># 0#
184 (S# i) < (S# j) = i <# j
185 (J# s d) < (S# i) = cmpIntegerInt# s d i <# 0#
186 (S# i) < (J# s d) = cmpIntegerInt# s d i ># 0#
187 (J# s1 d1) < (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <# 0#
189 (S# i) >= (S# j) = i >=# j
190 (J# s d) >= (S# i) = cmpIntegerInt# s d i >=# 0#
191 (S# i) >= (J# s d) = cmpIntegerInt# s d i <=# 0#
192 (J# s1 d1) >= (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) >=# 0#
194 compare (S# i) (S# j)
198 compare (J# s d) (S# i)
199 = case cmpIntegerInt# s d i of { res# ->
200 if res# <# 0# then LT else
201 if res# ># 0# then GT else EQ
203 compare (S# i) (J# s d)
204 = case cmpIntegerInt# s d i of { res# ->
205 if res# ># 0# then LT else
206 if res# <# 0# then GT else EQ
208 compare (J# s1 d1) (J# s2 d2)
209 = case cmpInteger# s1 d1 s2 d2 of { res# ->
210 if res# <# 0# then LT else
211 if res# ># 0# then GT else EQ
214 toBig (S# i) = case int2Integer# i of { (# s, d #) -> J# s d }
217 instance Num Integer where
218 (+) i1@(S# i) i2@(S# j)
219 = case addIntC# i j of { (# r, c #) ->
220 if c ==# 0# then S# r
221 else toBig i1 + toBig i2 }
222 (+) i1@(J# s d) i2@(S# i) = i1 + toBig i2
223 (+) i1@(S# i) i2@(J# s d) = toBig i1 + i2
224 (+) (J# s1 d1) (J# s2 d2)
225 = case plusInteger# s1 d1 s2 d2 of (# s, d #) -> J# s d
227 (-) i1@(S# i) i2@(S# j)
228 = case subIntC# i j of { (# r, c #) ->
229 if c ==# 0# then S# r
230 else toBig i1 - toBig i2 }
231 (-) i1@(J# s d) i2@(S# i) = i1 - toBig i2
232 (-) i1@(S# i) i2@(J# s d) = toBig i1 - i2
233 (-) (J# s1 d1) (J# s2 d2)
234 = case minusInteger# s1 d1 s2 d2 of (# s, d #) -> J# s d
236 (*) i1@(S# i) i2@(S# j)
237 = case mulIntC# i j of { (# r, c #) ->
238 if c ==# 0# then S# r
239 else toBig i1 * toBig i2 }
240 (*) i1@(J# s d) i2@(S# i) = i1 * toBig i2
241 (*) i1@(S# i) i2@(J# s d) = toBig i1 * i2
242 (*) (J# s1 d1) (J# s2 d2)
243 = case timesInteger# s1 d1 s2 d2 of (# s, d #) -> J# s d
245 negate (S# i) = S# (negateInt# i)
246 negate (J# s d) = J# (negateInt# s) d
248 -- ORIG: abs n = if n >= 0 then n else -n
250 abs (S# i) = case abs (I# i) of I# j -> S# j
252 = if (cmpIntegerInt# s d 0#) >=# 0#
254 else J# (negateInt# s) d
256 signum (S# i) = case signum (I# i) of I# j -> S# j
259 cmp = cmpIntegerInt# s d 0#
261 if cmp ># 0# then S# 1#
262 else if cmp ==# 0# then S# 0#
263 else S# (negateInt# 1#)
267 fromInt (I# i) = S# i
269 instance Real Integer where
272 instance Integral Integer where
273 -- ToDo: a `rem` b returns a small integer if b is small,
274 -- a `quot` b returns a small integer if a is small.
275 quotRem (S# i) (S# j)
276 = case quotRem (I# i) (I# j) of ( I# i, I# j ) -> ( S# i, S# j)
277 quotRem i1@(J# s d) i2@(S# i) = quotRem i1 (toBig i2)
278 quotRem i1@(S# i) i2@(J# s d) = quotRem (toBig i1) i2
279 quotRem (J# s1 d1) (J# s2 d2)
280 = case (quotRemInteger# s1 d1 s2 d2) of
282 -> (J# s3 d3, J# s4 d4)
284 {- USING THE UNDERLYING "GMP" CODE IS DUBIOUS FOR NOW:
286 divMod (J# a1 s1 d1) (J# a2 s2 d2)
287 = case (divModInteger# a1 s1 d1 a2 s2 d2) of
288 Return2GMPs a3 s3 d3 a4 s4 d4
289 -> (J# a3 s3 d3, J# a4 s4 d4)
293 toInt (J# s d) = case (integer2Int# s d) of { n# -> I# n# }
295 -- the rest are identical to the report default methods;
296 -- you get slightly better code if you let the compiler
297 -- see them right here:
298 (S# n) `quot` (S# d) = S# (n `quotInt#` d)
299 n `quot` d = if d /= 0 then q else
300 error "Prelude.Integral.quot{Integer}: divide by 0"
301 where (q,_) = quotRem n d
303 (S# n) `rem` (S# d) = S# (n `remInt#` d)
304 n `rem` d = if d /= 0 then r else
305 error "Prelude.Integral.rem{Integer}: divide by 0"
306 where (_,r) = quotRem n d
308 n `div` d = q where (q,_) = divMod n d
309 n `mod` d = r where (_,r) = divMod n d
311 divMod n d = case (quotRem n d) of { qr@(q,r) ->
312 if signum r == negate (signum d) then (q - 1, r+d) else qr }
313 -- Case-ified by WDP 94/10
315 instance Enum Integer where
318 toEnum n = toInteger n
320 enumFrom n = n : enumFrom (n + 1)
321 enumFromThen e1 e2 = en' e1 (e2 - e1)
322 where en' a b = a : en' (a + b) b
324 | n <= m = takeWhile (<= m) (enumFrom n)
326 enumFromThenTo n m p = takeWhile pred (enumFromThen n m)
328 pred | m >= n = (<= p)
331 instance Show Integer where
332 showsPrec x = showSignedInteger x
333 showList = showList__ (showsPrec 0)
336 instance Ix Integer where
342 | inRange b i = fromInteger (i - m)
343 | otherwise = indexIntegerError i b
344 inRange (m,n) i = m <= i && i <= n
346 -- Sigh, really want to use helper function in Ix, but
347 -- module deps. are too painful.
348 {-# NOINLINE indexIntegerError #-}
349 indexIntegerError :: Integer -> (Integer,Integer) -> a
350 indexIntegerError i rng
351 = error (showString "Ix{Integer}.index: Index " .
352 showParen True (showsPrec 0 i) .
353 showString " out of range " $
354 showParen True (showsPrec 0 rng) "")
356 showSignedInteger :: Int -> Integer -> ShowS
357 showSignedInteger p n r
358 | n < 0 && p > 6 = '(':jtos n (')':r)
359 | otherwise = jtos n r
361 jtos :: Integer -> String -> String
363 | i < 0 = '-' : jtos' (-i) rs
364 | otherwise = jtos' i rs
366 jtos' :: Integer -> String -> String
368 | n < 10 = chr (fromInteger n + (ord_0::Int)) : cs
369 | otherwise = jtos' q (chr (toInt r + (ord_0::Int)) : cs)
371 (q,r) = n `quotRem` 10
374 %*********************************************************
376 \subsection{The @Ratio@ and @Rational@ types}
378 %*********************************************************
381 data (Integral a) => Ratio a = !a :% !a deriving (Eq)
382 type Rational = Ratio Integer
384 {-# SPECIALISE (%) :: Integer -> Integer -> Rational #-}
385 (%) :: (Integral a) => a -> a -> Ratio a
386 numerator, denominator :: (Integral a) => Ratio a -> a
389 \tr{reduce} is a subsidiary function used only in this module .
390 It normalises a ratio by dividing both numerator and denominator by
391 their greatest common divisor.
394 reduce :: (Integral a) => a -> a -> Ratio a
395 reduce _ 0 = error "Ratio.%: zero denominator"
396 reduce x y = (x `quot` d) :% (y `quot` d)
401 x % y = reduce (x * signum y) (abs y)
403 numerator (x :% _) = x
404 denominator (_ :% y) = y
408 %*********************************************************
410 \subsection{Overloaded numeric functions}
412 %*********************************************************
415 even, odd :: (Integral a) => a -> Bool
416 even n = n `rem` 2 == 0
419 {-# SPECIALISE gcd ::
421 Integer -> Integer -> Integer #-}
422 gcd :: (Integral a) => a -> a -> a
423 gcd 0 0 = error "Prelude.gcd: gcd 0 0 is undefined"
424 gcd x y = gcd' (abs x) (abs y)
426 gcd' a b = gcd' b (a `rem` b)
428 {-# SPECIALISE lcm ::
430 Integer -> Integer -> Integer #-}
431 lcm :: (Integral a) => a -> a -> a
434 lcm x y = abs ((x `quot` (gcd x y)) * y)
436 {-# SPECIALISE (^) ::
437 Integer -> Integer -> Integer,
438 Integer -> Int -> Integer,
439 Int -> Int -> Int #-}
440 (^) :: (Num a, Integral b) => a -> b -> a
442 x ^ n | n > 0 = f x (n-1) x
444 f a d y = g a d where
445 g b i | even i = g (b*b) (i `quot` 2)
446 | otherwise = f b (i-1) (b*y)
447 _ ^ _ = error "Prelude.^: negative exponent"
449 {- SPECIALISE (^^) ::
450 Double -> Int -> Double,
451 Rational -> Int -> Rational #-}
452 (^^) :: (Fractional a, Integral b) => a -> b -> a
453 x ^^ n = if n >= 0 then x^n else recip (x^(negate n))