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