Define integerToWord64, word64ToInteger, integerToInt64, int64ToInteger
[packages/integer-gmp.git] / GHC / Integer.lhs
1 \begin{code}
2 {-# OPTIONS_GHC -fno-implicit-prelude #-}
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
82 default ()              -- Double isn't available yet,
83                         -- and we shouldn't be using defaults anyway
84 \end{code}
85
86 %*********************************************************
87 %*                                                      *
88 \subsection{The @Integer@ type}
89 %*                                                      *
90 %*********************************************************
91
92 \begin{code}
93 -- | Arbitrary-precision integers.
94 data Integer
95    = S# Int#                            -- small integers
96 #ifndef ILX
97    | J# Int# ByteArray#                 -- large integers
98 #else
99    | J# Void BigInteger                 -- .NET big ints
100
101 foreign type dotnet "BigInteger" BigInteger
102 #endif
103 \end{code}
104
105 Convenient boxed Integer PrimOps.
106
107 \begin{code}
108 {-# INLINE smallInteger #-}
109 smallInteger :: Int# -> Integer
110 smallInteger i = S# i
111
112 {-# INLINE wordToInteger #-}
113 wordToInteger :: Word# -> Integer
114 wordToInteger w = case word2Integer# w of (# s, d #) -> J# s d
115
116 {-# INLINE integerToWord #-}
117 integerToWord :: Integer -> Word#
118 integerToWord (S# i) = int2Word# i
119 integerToWord (J# s d) = integer2Word# s d
120
121 #if WORD_SIZE_IN_BITS < 64
122 {-# INLINE integerToWord64 #-}
123 integerToWord64 :: Integer -> Word64#
124 integerToWord64 (S# i) = int64ToWord64# (intToInt64# i)
125 integerToWord64 (J# s d) = integerToWord64# s d
126
127 word64ToInteger :: Word64# -> Integer
128 word64ToInteger w = if w `leWord64#` int64ToWord64# (intToInt64# 0x7FFFFFFF#)
129                     then S# (int64ToInt# (word64ToInt64# w))
130                     else case word64ToInteger# w of
131                          (# s, d #) -> J# s d
132
133 integerToInt64 :: Integer -> Int64#
134 integerToInt64 (S# i) = intToInt64# i
135 integerToInt64 (J# s d) = integerToInt64# s d
136
137 int64ToInteger :: Int64# -> Integer
138 int64ToInteger i = if ((i `leInt64#` intToInt64# 0x7FFFFFFF#) && 
139                        (i `geInt64#` intToInt64# -0x80000000#))
140                    then smallInteger (int64ToInt# i)
141                    else case int64ToInteger# i of
142                         (# s, d #) -> J# s d
143     where -- XXX Move the (&&) definition below us?
144           True && True = True
145           _ && _ = False
146 #endif
147
148 toInt# :: Integer -> Int#
149 toInt# (S# i)   = i
150 toInt# (J# s d) = integer2Int# s d
151
152 toBig :: Integer -> Integer
153 toBig (S# i)     = case int2Integer# i of { (# s, d #) -> J# s d }
154 toBig i@(J# _ _) = i
155 \end{code}
156
157
158 %*********************************************************
159 %*                                                      *
160 \subsection{Dividing @Integers@}
161 %*                                                      *
162 %*********************************************************
163
164 \begin{code}
165 -- XXX There's no good reason for us using unboxed tuples for the
166 -- results, but we don't have Data.Tuple available.
167
168 -- Note that we don't check for divide-by-zero here. That needs
169 -- to be done where it's used.
170 -- (we don't have error)
171
172 quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
173 quotRemInteger a@(S# INT_MINBOUND) b = quotRemInteger (toBig a) b
174 quotRemInteger (S# i) (S# j) = (# S# (i `quotInt#` j), S# (i `remInt#` j) #)
175 quotRemInteger i1@(J# _ _) i2@(S# _) = quotRemInteger i1 (toBig i2)
176 quotRemInteger i1@(S# _) i2@(J# _ _) = quotRemInteger (toBig i1) i2
177 quotRemInteger (J# s1 d1) (J# s2 d2)
178   = case (quotRemInteger# s1 d1 s2 d2) of
179           (# s3, d3, s4, d4 #)
180             -> (# J# s3 d3, J# s4 d4 #)
181
182 divModInteger :: Integer -> Integer -> (# Integer, Integer #)
183 divModInteger a@(S# INT_MINBOUND) b = divModInteger (toBig a) b
184 divModInteger (S# i) (S# j) = (# S# (i `divInt#` j), S# (i `modInt#` j) #)
185     where
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 -- GT => 1
345 -- EQ => 0
346 -- LT => -1
347 -- XXX Should we just define Ordering higher up?
348 compareInteger :: Integer -> Integer -> Int#
349 compareInteger (S# i)  (S# j)
350    =      if i ==# j then 0#
351      else if i <=# j then -1#
352      else                 1#
353 compareInteger (J# s d) (S# i)
354    = case cmpIntegerInt# s d i of { res# ->
355      if res# <# 0# then -1# else
356      if res# ># 0# then 1# else 0#
357      }
358 compareInteger (S# i) (J# s d)
359    = case cmpIntegerInt# s d i of { res# ->
360      if res# ># 0# then -1# else
361      if res# <# 0# then 1# else 0#
362      }
363 compareInteger (J# s1 d1) (J# s2 d2)
364    = case cmpInteger# s1 d1 s2 d2 of { res# ->
365      if res# <# 0# then -1# else
366      if res# ># 0# then 1# else 0#
367      }
368 \end{code}
369
370
371 %*********************************************************
372 %*                                                      *
373 \subsection{The @Integer@ instances for @Num@}
374 %*                                                      *
375 %*********************************************************
376
377 \begin{code}
378 {-# INLINE absInteger #-}
379 absInteger :: Integer -> Integer
380 absInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
381 absInteger n@(S# i) = if i >=# 0# then n else S# (negateInt# i)
382 absInteger n@(J# s d) = if (s >=# 0#) then n else J# (negateInt# s) d
383
384 signumInteger :: Integer -> Integer
385 signumInteger (S# i) = if i <# 0# then S# -1#
386                        else if i ==# 0# then S# 0#
387                        else S# 1#
388 signumInteger (J# s d)
389   = let
390         cmp = cmpIntegerInt# s d 0#
391     in
392     if      cmp >#  0# then S# 1#
393     else if cmp ==# 0# then S# 0#
394     else                    S# (negateInt# 1#)
395
396 plusInteger :: Integer -> Integer -> Integer
397 plusInteger i1@(S# i) i2@(S# j)  = case addIntC# i j of
398                                    (# r, c #) ->
399                                        if c ==# 0#
400                                        then S# r
401                                        else plusInteger (toBig i1) (toBig i2)
402 plusInteger i1@(J# _ _) i2@(S# _) = plusInteger i1 (toBig i2)
403 plusInteger i1@(S# _) i2@(J# _ _) = plusInteger (toBig i1) i2
404 plusInteger (J# s1 d1) (J# s2 d2) = case plusInteger# s1 d1 s2 d2 of
405                                     (# s, d #) -> J# s d
406
407 minusInteger :: Integer -> Integer -> Integer
408 minusInteger i1@(S# i) i2@(S# j)   = case subIntC# i j of
409                                      (# r, c #) ->
410                                          if c ==# 0# then S# r
411                                          else minusInteger (toBig i1)
412                                                            (toBig i2)
413 minusInteger i1@(J# _ _) i2@(S# _) = minusInteger i1 (toBig i2)
414 minusInteger i1@(S# _) i2@(J# _ _) = minusInteger (toBig i1) i2
415 minusInteger (J# s1 d1) (J# s2 d2) = case minusInteger# s1 d1 s2 d2 of
416                                      (# s, d #) -> J# s d
417
418 timesInteger :: Integer -> Integer -> Integer
419 timesInteger i1@(S# i) i2@(S# j)   = if mulIntMayOflo# i j ==# 0#
420                                      then S# (i *# j)
421                                      else timesInteger (toBig i1) (toBig i2)
422 timesInteger i1@(J# _ _) i2@(S# _) = timesInteger i1 (toBig i2)
423 timesInteger i1@(S# _) i2@(J# _ _) = timesInteger (toBig i1) i2
424 timesInteger (J# s1 d1) (J# s2 d2) = case timesInteger# s1 d1 s2 d2 of
425                                      (# s, d #) -> J# s d
426
427 negateInteger :: Integer -> Integer
428 negateInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
429 negateInteger (S# i)            = S# (negateInt# i)
430 negateInteger (J# s d)          = J# (negateInt# s) d
431 \end{code}
432
433
434 %*********************************************************
435 %*                                                      *
436 \subsection{The @Integer@ stuff for Double@}
437 %*                                                      *
438 %*********************************************************
439
440 \begin{code}
441 encodeFloatInteger :: Integer -> Int# -> Float#
442 encodeFloatInteger (S# i) j     = int_encodeFloat# i j
443 encodeFloatInteger (J# s# d#) e = encodeFloat# s# d# e
444
445 decodeFloatInteger :: Float# -> (# Integer, Int# #)
446 decodeFloatInteger d = case decodeFloat# d of
447                        (# exp#, s#, d# #) -> (# J# s# d#, exp# #)
448
449 encodeDoubleInteger :: Integer -> Int# -> Double#
450 encodeDoubleInteger (S# i) j     = int_encodeDouble# i j
451 encodeDoubleInteger (J# s# d#) e = encodeDouble# s# d# e
452
453 decodeDoubleInteger :: Double# -> (# Integer, Int# #)
454 decodeDoubleInteger d = case decodeDouble# d of
455                         (# exp#, s#, d# #) -> (# J# s# d#, exp# #)
456
457 -- previous code: doubleFromInteger n = fromInteger n = encodeFloat n 0
458 -- doesn't work too well, because encodeFloat is defined in
459 -- terms of ccalls which can never be simplified away.  We
460 -- want simple literals like (fromInteger 3 :: Float) to turn
461 -- into (F# 3.0), hence the special case for S# here.
462
463 doubleFromInteger :: Integer -> Double#
464 doubleFromInteger (S# i#) = int2Double# i#
465 doubleFromInteger (J# s# d#) = encodeDouble# s# d# 0#
466
467 floatFromInteger :: Integer -> Float#
468 floatFromInteger (S# i#) = int2Float# i#
469 floatFromInteger (J# s# d#) = encodeFloat# s# d# 0#
470
471 foreign import ccall unsafe "__encodeFloat"
472         encodeFloat# :: Int# -> ByteArray# -> Int# -> Float#
473 foreign import ccall unsafe "__int_encodeFloat"
474         int_encodeFloat# :: Int# -> Int# -> Float#
475
476 foreign import ccall unsafe "__encodeDouble"
477         encodeDouble# :: Int# -> ByteArray# -> Int# -> Double#
478 foreign import ccall unsafe "__int_encodeDouble"
479         int_encodeDouble# :: Int# -> Int# -> Double#
480 \end{code}
481
482 %*********************************************************
483 %*                                                      *
484 \subsection{The @Integer@ Bit definitions@}
485 %*                                                      *
486 %*********************************************************
487
488 \begin{code}
489 andInteger :: Integer -> Integer -> Integer
490 (S# x) `andInteger` (S# y) = S# (word2Int# (int2Word# x `and#` int2Word# y))
491 x@(S# _) `andInteger` y = toBig x `andInteger` y
492 x `andInteger` y@(S# _) = x `andInteger` toBig y
493 (J# s1 d1) `andInteger` (J# s2 d2) =
494      case andInteger# s1 d1 s2 d2 of
495        (# s, d #) -> J# s d
496
497 orInteger :: Integer -> Integer -> Integer
498 (S# x) `orInteger` (S# y) = S# (word2Int# (int2Word# x `or#` int2Word# y))
499 x@(S# _) `orInteger` y = toBig x `orInteger` y
500 x `orInteger` y@(S# _) = x `orInteger` toBig y
501 (J# s1 d1) `orInteger` (J# s2 d2) =
502      case orInteger# s1 d1 s2 d2 of
503        (# s, d #) -> J# s d
504
505 xorInteger :: Integer -> Integer -> Integer
506 (S# x) `xorInteger` (S# y) = S# (word2Int# (int2Word# x `xor#` int2Word# y))
507 x@(S# _) `xorInteger` y = toBig x `xorInteger` y
508 x `xorInteger` y@(S# _) = x `xorInteger` toBig y
509 (J# s1 d1) `xorInteger` (J# s2 d2) =
510      case xorInteger# s1 d1 s2 d2 of
511        (# s, d #) -> J# s d
512
513 complementInteger :: Integer -> Integer
514 complementInteger (S# x)
515     = S# (word2Int# (int2Word# x `xor#` int2Word# (0# -# 1#)))
516 complementInteger (J# s d)
517     = case complementInteger# s d of (# s', d' #) -> J# s' d'
518 \end{code}
519
520 %*********************************************************
521 %*                                                      *
522 \subsection{The @Integer@ hashing@}
523 %*                                                      *
524 %*********************************************************
525
526 \begin{code}
527 -- This is used by hashUnique
528
529 hashInteger :: Integer -> Int#
530 hashInteger (S# i) = i
531 hashInteger (J# s d) = if s ==# 0#
532                        then 0#
533                        else indexIntArray# d 0#
534 \end{code}
535