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