Avoid using deprecated flags
[packages/integer-gmp.git] / GHC / Integer.lhs
1 \begin{code}
2 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
3 {-# OPTIONS_HADDOCK hide #-}
4 -----------------------------------------------------------------------------
5 -- |
6 -- Module      :  GHC.Integer
7 -- Copyright   :  (c) The University of Glasgow 1994-2008
8 -- License     :  see libraries/integer-gmp/LICENSE
9 --
10 -- Maintainer  :  cvs-ghc@haskell.org
11 -- Stability   :  internal
12 -- Portability :  non-portable (GHC Extensions)
13 --
14 -- The 'Integer' type.
15 --
16 -----------------------------------------------------------------------------
17
18 #include "MachDeps.h"
19 #if SIZEOF_HSWORD == 4
20 #define INT_MINBOUND (-2147483648#)
21 #define NEG_INT_MINBOUND (S# 2147483647# `plusInteger` S# 1#)
22 #elif SIZEOF_HSWORD == 8
23 #define INT_MINBOUND (-9223372036854775808#)
24 #define NEG_INT_MINBOUND (S# 9223372036854775807# `plusInteger` S# 1#)
25 #else
26 #error Unknown SIZEOF_HSWORD; can't define INT_MINBOUND and NEG_INT_MINBOUND
27 #endif
28
29 module GHC.Integer (
30     Integer,
31     smallInteger, wordToInteger, integerToWord, toInt#,
32 #if WORD_SIZE_IN_BITS < 64
33     integerToWord64, word64ToInteger,
34     integerToInt64, int64ToInteger,
35 #endif
36     plusInteger, minusInteger, timesInteger, negateInteger,
37     eqInteger, neqInteger, absInteger, signumInteger,
38     leInteger, gtInteger, ltInteger, geInteger, compareInteger,
39     divModInteger, quotRemInteger, quotInteger, remInteger,
40     encodeFloatInteger, decodeFloatInteger, floatFromInteger,
41     encodeDoubleInteger, decodeDoubleInteger, doubleFromInteger,
42     gcdInteger, lcmInteger,
43     andInteger, orInteger, xorInteger, complementInteger,
44     hashInteger,
45  ) where
46
47 import GHC.Prim (
48     -- Other types we use, convert from, or convert to
49     Int#, Word#, Double#, Float#, ByteArray#,
50     -- Conversions between those types
51     int2Word#, int2Double#, int2Float#, word2Int#,
52     -- Operations on Int# that we use for operations on S#
53     quotInt#, remInt#, negateInt#,
54     (==#), (/=#), (<=#), (>=#), (<#), (>#), (*#), (-#), (+#),
55     mulIntMayOflo#, addIntC#, subIntC#, gcdInt#,
56     and#, or#, xor#,
57     indexIntArray#,
58     -- GMP-related primitives in the RTS
59     cmpInteger#, cmpIntegerInt#,
60     plusInteger#, minusInteger#, timesInteger#,
61     quotRemInteger#, quotInteger#, remInteger#, divModInteger#,
62     gcdInteger#, gcdIntegerInt#, divExactInteger#,
63     decodeDouble#, decodeFloat#,
64     int2Integer#, integer2Int#, word2Integer#, integer2Word#,
65     andInteger#, orInteger#, xorInteger#, complementInteger#,
66 #if WORD_SIZE_IN_BITS < 64
67     int64ToInteger#, word64ToInteger#,
68 #endif
69  )
70
71 #if WORD_SIZE_IN_BITS < 64
72 import GHC.IntWord64 (
73             Int64#, Word64#,
74             int64ToWord64#, intToInt64#, integerToWord64#,
75             int64ToInt#, word64ToInt64#, integerToInt64#,
76             geInt64#, leInt64#, leWord64#,
77        )
78 #endif
79
80 import GHC.Bool
81 import GHC.Ordering
82
83 default ()              -- Double isn't available yet,
84                         -- and we shouldn't be using defaults anyway
85 \end{code}
86
87 %*********************************************************
88 %*                                                      *
89 \subsection{The @Integer@ type}
90 %*                                                      *
91 %*********************************************************
92
93 \begin{code}
94 -- | Arbitrary-precision integers.
95 data Integer
96    = S# Int#                            -- small integers
97 #ifndef ILX
98    | J# Int# ByteArray#                 -- large integers
99 #else
100    | J# Void BigInteger                 -- .NET big ints
101
102 foreign type dotnet "BigInteger" BigInteger
103 #endif
104 \end{code}
105
106 Convenient boxed Integer PrimOps.
107
108 \begin{code}
109 {-# INLINE smallInteger #-}
110 smallInteger :: Int# -> Integer
111 smallInteger i = S# i
112
113 {-# INLINE wordToInteger #-}
114 wordToInteger :: Word# -> Integer
115 wordToInteger w = case word2Integer# w of (# s, d #) -> J# s d
116
117 {-# INLINE integerToWord #-}
118 integerToWord :: Integer -> Word#
119 integerToWord (S# i) = int2Word# i
120 integerToWord (J# s d) = integer2Word# s d
121
122 #if WORD_SIZE_IN_BITS < 64
123 {-# INLINE integerToWord64 #-}
124 integerToWord64 :: Integer -> Word64#
125 integerToWord64 (S# i) = int64ToWord64# (intToInt64# i)
126 integerToWord64 (J# s d) = integerToWord64# s d
127
128 word64ToInteger :: Word64# -> Integer
129 word64ToInteger w = if w `leWord64#` int64ToWord64# (intToInt64# 0x7FFFFFFF#)
130                     then S# (int64ToInt# (word64ToInt64# w))
131                     else case word64ToInteger# w of
132                          (# s, d #) -> J# s d
133
134 integerToInt64 :: Integer -> Int64#
135 integerToInt64 (S# i) = intToInt64# i
136 integerToInt64 (J# s d) = integerToInt64# s d
137
138 int64ToInteger :: Int64# -> Integer
139 int64ToInteger i = if ((i `leInt64#` intToInt64# 0x7FFFFFFF#) && 
140                        (i `geInt64#` intToInt64# -0x80000000#))
141                    then smallInteger (int64ToInt# i)
142                    else case int64ToInteger# i of
143                         (# s, d #) -> J# s d
144     where -- XXX Move the (&&) definition below us?
145           True  && x = x
146           False && _ = False
147 #endif
148
149 toInt# :: Integer -> Int#
150 toInt# (S# i)   = i
151 toInt# (J# s d) = integer2Int# s d
152
153 toBig :: Integer -> Integer
154 toBig (S# i)     = case int2Integer# i of { (# s, d #) -> J# s d }
155 toBig i@(J# _ _) = i
156 \end{code}
157
158
159 %*********************************************************
160 %*                                                      *
161 \subsection{Dividing @Integers@}
162 %*                                                      *
163 %*********************************************************
164
165 \begin{code}
166 -- XXX There's no good reason for us using unboxed tuples for the
167 -- results, but we don't have Data.Tuple available.
168
169 -- Note that we don't check for divide-by-zero here. That needs
170 -- to be done where it's used.
171 -- (we don't have error)
172
173 quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
174 quotRemInteger a@(S# INT_MINBOUND) b = quotRemInteger (toBig a) b
175 quotRemInteger (S# i) (S# j) = (# S# (i `quotInt#` j), S# (i `remInt#` j) #)
176 quotRemInteger i1@(J# _ _) i2@(S# _) = quotRemInteger i1 (toBig i2)
177 quotRemInteger i1@(S# _) i2@(J# _ _) = quotRemInteger (toBig i1) i2
178 quotRemInteger (J# s1 d1) (J# s2 d2)
179   = case (quotRemInteger# s1 d1 s2 d2) of
180           (# s3, d3, s4, d4 #)
181             -> (# J# s3 d3, J# s4 d4 #)
182
183 divModInteger :: Integer -> Integer -> (# Integer, Integer #)
184 divModInteger a@(S# INT_MINBOUND) b = divModInteger (toBig a) b
185 divModInteger (S# i) (S# j) = (# S# (i `divInt#` j), S# (i `modInt#` j) #)
186     where
187       -- XXX Copied from GHC.Base
188       divInt# :: Int# -> Int# -> Int#
189       x# `divInt#` y#
190        =      if (x# ># 0#) && (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1#
191          else if (x# <# 0#) && (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1#
192          else x# `quotInt#` y#
193
194       modInt# :: Int# -> Int# -> Int#
195       x# `modInt#` y#
196        = if ((x# ># 0#) && (y# <# 0#)) ||
197             ((x# <# 0#) && (y# ># 0#))
198          then if r# /=# 0# then r# +# y# else 0#
199          else r#
200           where r# = x# `remInt#` y#
201
202       (&&) :: Bool -> Bool -> Bool
203       True  && x = x
204       False && _ = False
205
206       (||) :: Bool -> Bool -> Bool
207       True  || _ = True
208       False || x = x
209 divModInteger i1@(J# _ _) i2@(S# _) = divModInteger i1 (toBig i2)
210 divModInteger i1@(S# _) i2@(J# _ _) = divModInteger (toBig i1) i2
211 divModInteger (J# s1 d1) (J# s2 d2)
212   = case (divModInteger# s1 d1 s2 d2) of
213           (# s3, d3, s4, d4 #)
214             -> (# J# s3 d3, J# s4 d4 #)
215
216 remInteger :: Integer -> Integer -> Integer
217 remInteger a@(S# INT_MINBOUND) b = remInteger (toBig a) b
218 remInteger (S# a) (S# b) = S# (remInt# a b)
219 {- Special case doesn't work, because a 1-element J# has the range
220    -(2^32-1) -- 2^32-1, whereas S# has the range -2^31 -- (2^31-1)
221 remInteger ia@(S# a) (J# sb b)
222   | sb ==# 1#  = S# (remInt# a (word2Int# (integer2Word# sb b)))
223   | sb ==# -1# = S# (remInt# a (0# -# (word2Int# (integer2Word# sb b))))
224   | 0# <# sb   = ia
225   | otherwise  = S# (0# -# a)
226 -}
227 remInteger ia@(S# _) ib@(J# _ _) = remInteger (toBig ia) ib
228 remInteger (J# sa a) (S# b)
229   = case int2Integer# b of { (# sb, b' #) ->
230     case remInteger# sa a sb b' of { (# sr, r #) ->
231     S# (integer2Int# sr r) }}
232 remInteger (J# sa a) (J# sb b)
233   = case remInteger# sa a sb b of (# sr, r #) -> J# sr r
234
235 quotInteger :: Integer -> Integer -> Integer
236 quotInteger a@(S# INT_MINBOUND) b = quotInteger (toBig a) b
237 quotInteger (S# a) (S# b) = S# (quotInt# a b)
238 {- Special case disabled, see remInteger above
239 quotInteger (S# a) (J# sb b)
240   | sb ==# 1#  = S# (quotInt# a (word2Int# (integer2Word# sb b)))
241   | sb ==# -1# = S# (quotInt# a (0# -# (word2Int# (integer2Word# sb b))))
242   | otherwise  = S# 0
243 -}
244 quotInteger ia@(S# _) ib@(J# _ _) = quotInteger (toBig ia) ib
245 quotInteger (J# sa a) (S# b)
246   = case int2Integer# b of { (# sb, b' #) ->
247     case quotInteger# sa a sb b' of (# sq, q #) -> J# sq q }
248 quotInteger (J# sa a) (J# sb b)
249   = case quotInteger# sa a sb b of (# sg, g #) -> J# sg g
250 \end{code}
251
252
253
254 \begin{code}
255 -- We can't throw an error here, so it is up to our caller to
256 -- not call us with both arguments being 0.
257 gcdInteger :: Integer -> Integer -> Integer
258 -- SUP: Do we really need the first two cases?
259 gcdInteger a@(S# INT_MINBOUND) b = gcdInteger (toBig a) b
260 gcdInteger a b@(S# INT_MINBOUND) = gcdInteger a (toBig b)
261 gcdInteger (S# a) (S# b) = S# (gcdInt a b)
262     where -- XXX Copied from GHC.Base
263           gcdInt :: Int# -> Int# -> Int#
264           gcdInt 0# y  = absInt y
265           gcdInt x  0# = absInt x
266           gcdInt x  y  = gcdInt# (absInt x) (absInt y)
267
268           absInt x = if x <# 0# then negateInt# x else x
269 gcdInteger ia@(S# a)  ib@(J# sb b)
270  =      if a  ==# 0# then absInteger ib
271    else if sb ==# 0# then absInteger ia
272    else                   S# (gcdIntegerInt# absSb b absA)
273        where absA  = if a  <# 0# then negateInt# a  else a
274              absSb = if sb <# 0# then negateInt# sb else sb
275 gcdInteger ia@(J# _ _) ib@(S# _) = gcdInteger ib ia
276 gcdInteger (J# sa a) (J# sb b)
277   = case gcdInteger# sa a sb b of (# sg, g #) -> J# sg g
278
279 lcmInteger :: Integer -> Integer -> Integer
280 lcmInteger a b =      if a `eqInteger` S# 0# then S# 0#
281                  else if b `eqInteger` S# 0# then S# 0#
282                  else (divExact aa (gcdInteger aa ab)) `timesInteger` ab
283   where aa = absInteger a
284         ab = absInteger b
285
286 divExact :: Integer -> Integer -> Integer
287 divExact a@(S# INT_MINBOUND) b = divExact (toBig a) b
288 divExact (S# a) (S# b) = S# (quotInt# a b)
289 divExact (S# a) (J# sb b)
290   = S# (quotInt# a (integer2Int# sb b))
291 divExact (J# sa a) (S# b)
292   = case int2Integer# b of
293     (# sb, b' #) -> case divExactInteger# sa a sb b' of
294                     (# sd, d #) -> J# sd d
295 divExact (J# sa a) (J# sb b)
296   = case divExactInteger# sa a sb b of (# sd, d #) -> J# sd d
297 \end{code}
298
299
300 %*********************************************************
301 %*                                                      *
302 \subsection{The @Integer@ instances for @Eq@, @Ord@}
303 %*                                                      *
304 %*********************************************************
305
306 \begin{code}
307 eqInteger :: Integer -> Integer -> Bool
308 eqInteger (S# i)     (S# j)     = i ==# j
309 eqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ==# 0#
310 eqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ==# 0#
311 eqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ==# 0#
312
313 neqInteger :: Integer -> Integer -> Bool
314 neqInteger (S# i)     (S# j)     = i /=# j
315 neqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i /=# 0#
316 neqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i /=# 0#
317 neqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) /=# 0#
318
319 ------------------------------------------------------------------------
320
321 leInteger :: Integer -> Integer -> Bool
322 leInteger (S# i)     (S# j)     = i <=# j
323 leInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <=# 0#
324 leInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i >=# 0#
325 leInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <=# 0#
326
327 gtInteger :: Integer -> Integer -> Bool
328 gtInteger (S# i)     (S# j)     = i ># j
329 gtInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ># 0#
330 gtInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <# 0#
331 gtInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ># 0#
332
333 ltInteger :: Integer -> Integer -> Bool
334 ltInteger (S# i)     (S# j)     = i <# j
335 ltInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <# 0#
336 ltInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ># 0#
337 ltInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <# 0#
338
339 geInteger :: Integer -> Integer -> Bool
340 geInteger (S# i)     (S# j)     = i >=# j
341 geInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i >=# 0#
342 geInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <=# 0#
343 geInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) >=# 0#
344
345 compareInteger :: Integer -> Integer -> Ordering
346 compareInteger (S# i)  (S# j)
347    =      if i ==# j then EQ
348      else if i <=# j then LT
349      else                 GT
350 compareInteger (J# s d) (S# i)
351    = case cmpIntegerInt# s d i of { res# ->
352      if res# <# 0# then LT else
353      if res# ># 0# then GT else EQ
354      }
355 compareInteger (S# i) (J# s d)
356    = case cmpIntegerInt# s d i of { res# ->
357      if res# ># 0# then LT else
358      if res# <# 0# then GT else EQ
359      }
360 compareInteger (J# s1 d1) (J# s2 d2)
361    = case cmpInteger# s1 d1 s2 d2 of { res# ->
362      if res# <# 0# then LT else
363      if res# ># 0# then GT else EQ
364      }
365 \end{code}
366
367
368 %*********************************************************
369 %*                                                      *
370 \subsection{The @Integer@ instances for @Num@}
371 %*                                                      *
372 %*********************************************************
373
374 \begin{code}
375 {-# INLINE absInteger #-}
376 absInteger :: Integer -> Integer
377 absInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
378 absInteger n@(S# i) = if i >=# 0# then n else S# (negateInt# i)
379 absInteger n@(J# s d) = if (s >=# 0#) then n else J# (negateInt# s) d
380
381 signumInteger :: Integer -> Integer
382 signumInteger (S# i) = if i <# 0# then S# -1#
383                        else if i ==# 0# then S# 0#
384                        else S# 1#
385 signumInteger (J# s d)
386   = let
387         cmp = cmpIntegerInt# s d 0#
388     in
389     if      cmp >#  0# then S# 1#
390     else if cmp ==# 0# then S# 0#
391     else                    S# (negateInt# 1#)
392
393 plusInteger :: Integer -> Integer -> Integer
394 plusInteger i1@(S# i) i2@(S# j)  = case addIntC# i j of
395                                    (# r, c #) ->
396                                        if c ==# 0#
397                                        then S# r
398                                        else plusInteger (toBig i1) (toBig i2)
399 plusInteger i1@(J# _ _) i2@(S# _) = plusInteger i1 (toBig i2)
400 plusInteger i1@(S# _) i2@(J# _ _) = plusInteger (toBig i1) i2
401 plusInteger (J# s1 d1) (J# s2 d2) = case plusInteger# s1 d1 s2 d2 of
402                                     (# s, d #) -> J# s d
403
404 minusInteger :: Integer -> Integer -> Integer
405 minusInteger i1@(S# i) i2@(S# j)   = case subIntC# i j of
406                                      (# r, c #) ->
407                                          if c ==# 0# then S# r
408                                          else minusInteger (toBig i1)
409                                                            (toBig i2)
410 minusInteger i1@(J# _ _) i2@(S# _) = minusInteger i1 (toBig i2)
411 minusInteger i1@(S# _) i2@(J# _ _) = minusInteger (toBig i1) i2
412 minusInteger (J# s1 d1) (J# s2 d2) = case minusInteger# s1 d1 s2 d2 of
413                                      (# s, d #) -> J# s d
414
415 timesInteger :: Integer -> Integer -> Integer
416 timesInteger i1@(S# i) i2@(S# j)   = if mulIntMayOflo# i j ==# 0#
417                                      then S# (i *# j)
418                                      else timesInteger (toBig i1) (toBig i2)
419 timesInteger i1@(J# _ _) i2@(S# _) = timesInteger i1 (toBig i2)
420 timesInteger i1@(S# _) i2@(J# _ _) = timesInteger (toBig i1) i2
421 timesInteger (J# s1 d1) (J# s2 d2) = case timesInteger# s1 d1 s2 d2 of
422                                      (# s, d #) -> J# s d
423
424 negateInteger :: Integer -> Integer
425 negateInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
426 negateInteger (S# i)            = S# (negateInt# i)
427 negateInteger (J# s d)          = J# (negateInt# s) d
428 \end{code}
429
430
431 %*********************************************************
432 %*                                                      *
433 \subsection{The @Integer@ stuff for Double@}
434 %*                                                      *
435 %*********************************************************
436
437 \begin{code}
438 encodeFloatInteger :: Integer -> Int# -> Float#
439 encodeFloatInteger (S# i) j     = int_encodeFloat# i j
440 encodeFloatInteger (J# s# d#) e = encodeFloat# s# d# e
441
442 decodeFloatInteger :: Float# -> (# Integer, Int# #)
443 decodeFloatInteger d = case decodeFloat# d of
444                        (# exp#, s#, d# #) -> (# J# s# d#, exp# #)
445
446 encodeDoubleInteger :: Integer -> Int# -> Double#
447 encodeDoubleInteger (S# i) j     = int_encodeDouble# i j
448 encodeDoubleInteger (J# s# d#) e = encodeDouble# s# d# e
449
450 decodeDoubleInteger :: Double# -> (# Integer, Int# #)
451 decodeDoubleInteger d = case decodeDouble# d of
452                         (# exp#, s#, d# #) -> (# J# s# d#, exp# #)
453
454 -- previous code: doubleFromInteger n = fromInteger n = encodeFloat n 0
455 -- doesn't work too well, because encodeFloat is defined in
456 -- terms of ccalls which can never be simplified away.  We
457 -- want simple literals like (fromInteger 3 :: Float) to turn
458 -- into (F# 3.0), hence the special case for S# here.
459
460 doubleFromInteger :: Integer -> Double#
461 doubleFromInteger (S# i#) = int2Double# i#
462 doubleFromInteger (J# s# d#) = encodeDouble# s# d# 0#
463
464 floatFromInteger :: Integer -> Float#
465 floatFromInteger (S# i#) = int2Float# i#
466 floatFromInteger (J# s# d#) = encodeFloat# s# d# 0#
467
468 foreign import ccall unsafe "__encodeFloat"
469         encodeFloat# :: Int# -> ByteArray# -> Int# -> Float#
470 foreign import ccall unsafe "__int_encodeFloat"
471         int_encodeFloat# :: Int# -> Int# -> Float#
472
473 foreign import ccall unsafe "__encodeDouble"
474         encodeDouble# :: Int# -> ByteArray# -> Int# -> Double#
475 foreign import ccall unsafe "__int_encodeDouble"
476         int_encodeDouble# :: Int# -> Int# -> Double#
477 \end{code}
478
479 %*********************************************************
480 %*                                                      *
481 \subsection{The @Integer@ Bit definitions@}
482 %*                                                      *
483 %*********************************************************
484
485 \begin{code}
486 andInteger :: Integer -> Integer -> Integer
487 (S# x) `andInteger` (S# y) = S# (word2Int# (int2Word# x `and#` int2Word# y))
488 x@(S# _) `andInteger` y = toBig x `andInteger` y
489 x `andInteger` y@(S# _) = x `andInteger` toBig y
490 (J# s1 d1) `andInteger` (J# s2 d2) =
491      case andInteger# s1 d1 s2 d2 of
492        (# s, d #) -> J# s d
493
494 orInteger :: Integer -> Integer -> Integer
495 (S# x) `orInteger` (S# y) = S# (word2Int# (int2Word# x `or#` int2Word# y))
496 x@(S# _) `orInteger` y = toBig x `orInteger` y
497 x `orInteger` y@(S# _) = x `orInteger` toBig y
498 (J# s1 d1) `orInteger` (J# s2 d2) =
499      case orInteger# s1 d1 s2 d2 of
500        (# s, d #) -> J# s d
501
502 xorInteger :: Integer -> Integer -> Integer
503 (S# x) `xorInteger` (S# y) = S# (word2Int# (int2Word# x `xor#` int2Word# y))
504 x@(S# _) `xorInteger` y = toBig x `xorInteger` y
505 x `xorInteger` y@(S# _) = x `xorInteger` toBig y
506 (J# s1 d1) `xorInteger` (J# s2 d2) =
507      case xorInteger# s1 d1 s2 d2 of
508        (# s, d #) -> J# s d
509
510 complementInteger :: Integer -> Integer
511 complementInteger (S# x)
512     = S# (word2Int# (int2Word# x `xor#` int2Word# (0# -# 1#)))
513 complementInteger (J# s d)
514     = case complementInteger# s d of (# s', d' #) -> J# s' d'
515 \end{code}
516
517 %*********************************************************
518 %*                                                      *
519 \subsection{The @Integer@ hashing@}
520 %*                                                      *
521 %*********************************************************
522
523 \begin{code}
524 -- This is used by hashUnique
525
526 hashInteger :: Integer -> Int#
527 hashInteger (S# i) = i
528 hashInteger (J# s d) = if s ==# 0#
529                        then 0#
530                        else indexIntArray# d 0#
531 \end{code}
532