4d32d76245f7e8a2dd427ea396ac952db606155f
[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 gcdInteger ia@(S# a)  ib@(J# sb b)
265  =      if a  ==# 0# then absInteger ib
266    else if sb ==# 0# then absInteger ia
267    else                   S# (gcdIntegerInt# absSb b absA)
268        where !absA  = if a  <# 0# then negateInt# a  else a
269              !absSb = if sb <# 0# then negateInt# sb else sb
270 gcdInteger ia@(J# _ _) ib@(S# _) = gcdInteger ib ia
271 gcdInteger (J# sa a) (J# sb b)
272   = case gcdInteger# sa a sb b of (# sg, g #) -> J# sg g
273
274 lcmInteger :: Integer -> Integer -> Integer
275 lcmInteger a b =      if a `eqInteger` S# 0# then S# 0#
276                  else if b `eqInteger` S# 0# then S# 0#
277                  else (divExact aa (gcdInteger aa ab)) `timesInteger` ab
278   where aa = absInteger a
279         ab = absInteger b
280
281 {-# RULES "gcdInteger/Int" forall a b.
282             gcdInteger (S# a) (S# b) = S# (gcdInt a b)
283   #-}
284 gcdInt :: Int# -> Int# -> Int#
285 gcdInt 0# y  = absInt y
286 gcdInt x  0# = absInt x
287 gcdInt x  y  = gcdInt# (absInt x) (absInt y)
288
289 absInt :: Int# -> Int#
290 absInt x = if x <# 0# then negateInt# x else x
291
292 divExact :: Integer -> Integer -> Integer
293 divExact a@(S# INT_MINBOUND) b = divExact (toBig a) b
294 divExact (S# a) (S# b) = S# (quotInt# a b)
295 divExact (S# a) (J# sb b)
296   = S# (quotInt# a (integer2Int# sb b))
297 divExact (J# sa a) (S# b)
298   = case int2Integer# b of
299     (# sb, b' #) -> case divExactInteger# sa a sb b' of
300                     (# sd, d #) -> J# sd d
301 divExact (J# sa a) (J# sb b)
302   = case divExactInteger# sa a sb b of (# sd, d #) -> J# sd d
303 \end{code}
304
305
306 %*********************************************************
307 %*                                                      *
308 \subsection{The @Integer@ instances for @Eq@, @Ord@}
309 %*                                                      *
310 %*********************************************************
311
312 \begin{code}
313 eqInteger :: Integer -> Integer -> Bool
314 eqInteger (S# i)     (S# j)     = i ==# j
315 eqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ==# 0#
316 eqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ==# 0#
317 eqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ==# 0#
318
319 neqInteger :: Integer -> Integer -> Bool
320 neqInteger (S# i)     (S# j)     = i /=# j
321 neqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i /=# 0#
322 neqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i /=# 0#
323 neqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) /=# 0#
324
325 ------------------------------------------------------------------------
326
327 leInteger :: Integer -> Integer -> Bool
328 leInteger (S# i)     (S# j)     = i <=# j
329 leInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <=# 0#
330 leInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i >=# 0#
331 leInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <=# 0#
332
333 gtInteger :: Integer -> Integer -> Bool
334 gtInteger (S# i)     (S# j)     = i ># j
335 gtInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ># 0#
336 gtInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <# 0#
337 gtInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ># 0#
338
339 ltInteger :: Integer -> Integer -> Bool
340 ltInteger (S# i)     (S# j)     = i <# j
341 ltInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <# 0#
342 ltInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ># 0#
343 ltInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <# 0#
344
345 geInteger :: Integer -> Integer -> Bool
346 geInteger (S# i)     (S# j)     = i >=# j
347 geInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i >=# 0#
348 geInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <=# 0#
349 geInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) >=# 0#
350
351 compareInteger :: Integer -> Integer -> Ordering
352 compareInteger (S# i)  (S# j)
353    =      if i ==# j then EQ
354      else if i <=# j then LT
355      else                 GT
356 compareInteger (J# s d) (S# i)
357    = case cmpIntegerInt# s d i of { res# ->
358      if res# <# 0# then LT else
359      if res# ># 0# then GT else EQ
360      }
361 compareInteger (S# i) (J# s d)
362    = case cmpIntegerInt# s d i of { res# ->
363      if res# ># 0# then LT else
364      if res# <# 0# then GT else EQ
365      }
366 compareInteger (J# s1 d1) (J# s2 d2)
367    = case cmpInteger# s1 d1 s2 d2 of { res# ->
368      if res# <# 0# then LT else
369      if res# ># 0# then GT else EQ
370      }
371 \end{code}
372
373
374 %*********************************************************
375 %*                                                      *
376 \subsection{The @Integer@ instances for @Num@}
377 %*                                                      *
378 %*********************************************************
379
380 \begin{code}
381 {-# INLINE absInteger #-}
382 absInteger :: Integer -> Integer
383 absInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
384 absInteger n@(S# i) = if i >=# 0# then n else S# (negateInt# i)
385 absInteger n@(J# s d) = if (s >=# 0#) then n else J# (negateInt# s) d
386
387 signumInteger :: Integer -> Integer
388 signumInteger (S# i) = if i <# 0# then S# -1#
389                        else if i ==# 0# then S# 0#
390                        else S# 1#
391 signumInteger (J# s d)
392   = let
393         !cmp = cmpIntegerInt# s d 0#
394     in
395     if      cmp >#  0# then S# 1#
396     else if cmp ==# 0# then S# 0#
397     else                    S# (negateInt# 1#)
398
399 plusInteger :: Integer -> Integer -> Integer
400 plusInteger i1@(S# i) i2@(S# j)  = case addIntC# i j of
401                                    (# r, c #) ->
402                                        if c ==# 0#
403                                        then S# r
404                                        else plusInteger (toBig i1) (toBig i2)
405 plusInteger i1@(J# _ _) i2@(S# _) = plusInteger i1 (toBig i2)
406 plusInteger i1@(S# _) i2@(J# _ _) = plusInteger (toBig i1) i2
407 plusInteger (J# s1 d1) (J# s2 d2) = case plusInteger# s1 d1 s2 d2 of
408                                     (# s, d #) -> J# s d
409
410 minusInteger :: Integer -> Integer -> Integer
411 minusInteger i1@(S# i) i2@(S# j)   = case subIntC# i j of
412                                      (# r, c #) ->
413                                          if c ==# 0# then S# r
414                                          else minusInteger (toBig i1)
415                                                            (toBig i2)
416 minusInteger i1@(J# _ _) i2@(S# _) = minusInteger i1 (toBig i2)
417 minusInteger i1@(S# _) i2@(J# _ _) = minusInteger (toBig i1) i2
418 minusInteger (J# s1 d1) (J# s2 d2) = case minusInteger# s1 d1 s2 d2 of
419                                      (# s, d #) -> J# s d
420
421 timesInteger :: Integer -> Integer -> Integer
422 timesInteger i1@(S# i) i2@(S# j)   = if mulIntMayOflo# i j ==# 0#
423                                      then S# (i *# j)
424                                      else timesInteger (toBig i1) (toBig i2)
425 timesInteger i1@(J# _ _) i2@(S# _) = timesInteger i1 (toBig i2)
426 timesInteger i1@(S# _) i2@(J# _ _) = timesInteger (toBig i1) i2
427 timesInteger (J# s1 d1) (J# s2 d2) = case timesInteger# s1 d1 s2 d2 of
428                                      (# s, d #) -> J# s d
429
430 negateInteger :: Integer -> Integer
431 negateInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
432 negateInteger (S# i)            = S# (negateInt# i)
433 negateInteger (J# s d)          = J# (negateInt# s) d
434 \end{code}
435
436
437 %*********************************************************
438 %*                                                      *
439 \subsection{The @Integer@ stuff for Double@}
440 %*                                                      *
441 %*********************************************************
442
443 \begin{code}
444 encodeFloatInteger :: Integer -> Int# -> Float#
445 encodeFloatInteger (S# i) j     = int_encodeFloat# i j
446 encodeFloatInteger (J# s# d#) e = encodeFloat# s# d# e
447
448 encodeDoubleInteger :: Integer -> Int# -> Double#
449 encodeDoubleInteger (S# i) j     = int_encodeDouble# i j
450 encodeDoubleInteger (J# s# d#) e = encodeDouble# s# d# e
451
452 decodeDoubleInteger :: Double# -> (# Integer, Int# #)
453 decodeDoubleInteger d = case decodeDouble# d of
454                         (# exp#, s#, d# #) -> (# J# s# d#, exp# #)
455
456 -- previous code: doubleFromInteger n = fromInteger n = encodeFloat n 0
457 -- doesn't work too well, because encodeFloat is defined in
458 -- terms of ccalls which can never be simplified away.  We
459 -- want simple literals like (fromInteger 3 :: Float) to turn
460 -- into (F# 3.0), hence the special case for S# here.
461
462 doubleFromInteger :: Integer -> Double#
463 doubleFromInteger (S# i#) = int2Double# i#
464 doubleFromInteger (J# s# d#) = encodeDouble# s# d# 0#
465
466 floatFromInteger :: Integer -> Float#
467 floatFromInteger (S# i#) = int2Float# i#
468 floatFromInteger (J# s# d#) = encodeFloat# s# d# 0#
469
470 foreign import ccall unsafe "integer_cbits_encodeFloat"
471         encodeFloat# :: Int# -> ByteArray# -> Int# -> Float#
472 foreign import ccall unsafe "__int_encodeFloat"
473         int_encodeFloat# :: Int# -> Int# -> Float#
474
475 foreign import ccall unsafe "integer_cbits_encodeDouble"
476         encodeDouble# :: Int# -> ByteArray# -> Int# -> Double#
477 foreign import ccall unsafe "__int_encodeDouble"
478         int_encodeDouble# :: Int# -> Int# -> Double#
479 \end{code}
480
481 %*********************************************************
482 %*                                                      *
483 \subsection{The @Integer@ Bit definitions@}
484 %*                                                      *
485 %*********************************************************
486
487 \begin{code}
488 andInteger :: Integer -> Integer -> Integer
489 (S# x) `andInteger` (S# y) = S# (word2Int# (int2Word# x `and#` int2Word# y))
490 x@(S# _) `andInteger` y = toBig x `andInteger` y
491 x `andInteger` y@(S# _) = x `andInteger` toBig y
492 (J# s1 d1) `andInteger` (J# s2 d2) =
493      case andInteger# s1 d1 s2 d2 of
494        (# s, d #) -> J# s d
495
496 orInteger :: Integer -> Integer -> Integer
497 (S# x) `orInteger` (S# y) = S# (word2Int# (int2Word# x `or#` int2Word# y))
498 x@(S# _) `orInteger` y = toBig x `orInteger` y
499 x `orInteger` y@(S# _) = x `orInteger` toBig y
500 (J# s1 d1) `orInteger` (J# s2 d2) =
501      case orInteger# s1 d1 s2 d2 of
502        (# s, d #) -> J# s d
503
504 xorInteger :: Integer -> Integer -> Integer
505 (S# x) `xorInteger` (S# y) = S# (word2Int# (int2Word# x `xor#` int2Word# y))
506 x@(S# _) `xorInteger` y = toBig x `xorInteger` y
507 x `xorInteger` y@(S# _) = x `xorInteger` toBig y
508 (J# s1 d1) `xorInteger` (J# s2 d2) =
509      case xorInteger# s1 d1 s2 d2 of
510        (# s, d #) -> J# s d
511
512 complementInteger :: Integer -> Integer
513 complementInteger (S# x)
514     = S# (word2Int# (int2Word# x `xor#` int2Word# (0# -# 1#)))
515 complementInteger (J# s d)
516     = case complementInteger# s d of (# s', d' #) -> J# s' d'
517 \end{code}
518
519 %*********************************************************
520 %*                                                      *
521 \subsection{The @Integer@ hashing@}
522 %*                                                      *
523 %*********************************************************
524
525 \begin{code}
526 -- This is used by hashUnique
527
528 hashInteger :: Integer -> Int#
529 hashInteger (S# i) = i
530 hashInteger (J# s d) = if s ==# 0#
531                        then 0#
532                        else indexIntArray# d 0#
533 \end{code}
534