Make this package now really integer-gmp, rather than pretending it's integer
[packages/integer-gmp.git] / GHC / Integer / GMP.lhs
1 \begin{code}
2 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
3 -----------------------------------------------------------------------------
4 -- |
5 -- Module      :  GHC.Integer.GMP
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.GMP (
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.GMP.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#,  integerToInt64#,
72     word64ToInteger#, integerToWord64#,
73 #endif
74  )
75
76 #if WORD_SIZE_IN_BITS < 64
77 import GHC.IntWord64 (
78             Int64#, Word64#,
79             int64ToWord64#, intToInt64#,
80             int64ToInt#, word64ToInt64#,
81             geInt64#, leInt64#, leWord64#,
82        )
83 #endif
84
85 import GHC.Bool
86 import GHC.Ordering
87
88 default ()              -- Double isn't available yet,
89                         -- and we shouldn't be using defaults anyway
90 \end{code}
91
92 %*********************************************************
93 %*                                                      *
94 \subsection{The @Integer@ type}
95 %*                                                      *
96 %*********************************************************
97
98 Convenient boxed Integer PrimOps.
99
100 \begin{code}
101 {-# INLINE smallInteger #-}
102 smallInteger :: Int# -> Integer
103 smallInteger i = S# i
104
105 {-# INLINE wordToInteger #-}
106 wordToInteger :: Word# -> Integer
107 wordToInteger w = case word2Integer# w of (# s, d #) -> J# s d
108
109 {-# INLINE integerToWord #-}
110 integerToWord :: Integer -> Word#
111 integerToWord (S# i) = int2Word# i
112 integerToWord (J# s d) = integer2Word# s d
113
114 #if WORD_SIZE_IN_BITS < 64
115 {-# INLINE integerToWord64 #-}
116 integerToWord64 :: Integer -> Word64#
117 integerToWord64 (S# i) = int64ToWord64# (intToInt64# i)
118 integerToWord64 (J# s d) = integerToWord64# s d
119
120 word64ToInteger :: Word64# -> Integer
121 word64ToInteger w = if w `leWord64#` int64ToWord64# (intToInt64# 0x7FFFFFFF#)
122                     then S# (int64ToInt# (word64ToInt64# w))
123                     else case word64ToInteger# w of
124                          (# s, d #) -> J# s d
125
126 integerToInt64 :: Integer -> Int64#
127 integerToInt64 (S# i) = intToInt64# i
128 integerToInt64 (J# s d) = integerToInt64# s d
129
130 int64ToInteger :: Int64# -> Integer
131 int64ToInteger i = if ((i `leInt64#` intToInt64# 0x7FFFFFFF#) && 
132                        (i `geInt64#` intToInt64# -0x80000000#))
133                    then smallInteger (int64ToInt# i)
134                    else case int64ToInteger# i of
135                         (# s, d #) -> J# s d
136     where -- XXX Move the (&&) definition below us?
137           True  && x = x
138           False && _ = False
139 #endif
140
141 toInt# :: Integer -> Int#
142 toInt# (S# i)   = i
143 toInt# (J# s d) = integer2Int# s d
144
145 toBig :: Integer -> Integer
146 toBig (S# i)     = case int2Integer# i of { (# s, d #) -> J# s d }
147 toBig i@(J# _ _) = i
148 \end{code}
149
150
151 %*********************************************************
152 %*                                                      *
153 \subsection{Dividing @Integers@}
154 %*                                                      *
155 %*********************************************************
156
157 \begin{code}
158 -- XXX There's no good reason for us using unboxed tuples for the
159 -- results, but we don't have Data.Tuple available.
160
161 -- Note that we don't check for divide-by-zero here. That needs
162 -- to be done where it's used.
163 -- (we don't have error)
164
165 quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
166 quotRemInteger a@(S# INT_MINBOUND) b = quotRemInteger (toBig a) b
167 quotRemInteger (S# i) (S# j) = (# S# q, S# r #)
168     where
169       -- NB. don't inline these.  (# S# (i `quotInt#` j), ... #) means
170       -- (# let q = i `quotInt#` j in S# q, ... #) which builds a
171       -- useless thunk.  Placing the bindings here means they'll be
172       -- evaluated strictly.
173       !q = i `quotInt#` j
174       !r = 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# d, S# m #)
185     where
186       -- NB. don't inline these.  See quotRemInteger above.
187       !d = i `divInt#` j
188       !m = i `modInt#` j
189
190       -- XXX Copied from GHC.Base
191       divInt# :: Int# -> Int# -> Int#
192       x# `divInt#` y#
193        =      if (x# ># 0#) && (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1#
194          else if (x# <# 0#) && (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1#
195          else x# `quotInt#` y#
196
197       modInt# :: Int# -> Int# -> Int#
198       x# `modInt#` y#
199        = if ((x# ># 0#) && (y# <# 0#)) ||
200             ((x# <# 0#) && (y# ># 0#))
201          then if r# /=# 0# then r# +# y# else 0#
202          else r#
203           where !r# = x# `remInt#` y#
204
205       (&&) :: Bool -> Bool -> Bool
206       True  && x = x
207       False && _ = False
208
209       (||) :: Bool -> Bool -> Bool
210       True  || _ = True
211       False || x = x
212 divModInteger i1@(J# _ _) i2@(S# _) = divModInteger i1 (toBig i2)
213 divModInteger i1@(S# _) i2@(J# _ _) = divModInteger (toBig i1) i2
214 divModInteger (J# s1 d1) (J# s2 d2)
215   = case (divModInteger# s1 d1 s2 d2) of
216           (# s3, d3, s4, d4 #)
217             -> (# J# s3 d3, J# s4 d4 #)
218
219 remInteger :: Integer -> Integer -> Integer
220 remInteger a@(S# INT_MINBOUND) b = remInteger (toBig a) b
221 remInteger (S# a) (S# b) = S# (remInt# a b)
222 {- Special case doesn't work, because a 1-element J# has the range
223    -(2^32-1) -- 2^32-1, whereas S# has the range -2^31 -- (2^31-1)
224 remInteger ia@(S# a) (J# sb b)
225   | sb ==# 1#  = S# (remInt# a (word2Int# (integer2Word# sb b)))
226   | sb ==# -1# = S# (remInt# a (0# -# (word2Int# (integer2Word# sb b))))
227   | 0# <# sb   = ia
228   | otherwise  = S# (0# -# a)
229 -}
230 remInteger ia@(S# _) ib@(J# _ _) = remInteger (toBig ia) ib
231 remInteger (J# sa a) (S# b)
232   = case int2Integer# b of { (# sb, b' #) ->
233     case remInteger# sa a sb b' of { (# sr, r #) ->
234     S# (integer2Int# sr r) }}
235 remInteger (J# sa a) (J# sb b)
236   = case remInteger# sa a sb b of (# sr, r #) -> J# sr r
237
238 quotInteger :: Integer -> Integer -> Integer
239 quotInteger a@(S# INT_MINBOUND) b = quotInteger (toBig a) b
240 quotInteger (S# a) (S# b) = S# (quotInt# a b)
241 {- Special case disabled, see remInteger above
242 quotInteger (S# a) (J# sb b)
243   | sb ==# 1#  = S# (quotInt# a (word2Int# (integer2Word# sb b)))
244   | sb ==# -1# = S# (quotInt# a (0# -# (word2Int# (integer2Word# sb b))))
245   | otherwise  = S# 0
246 -}
247 quotInteger ia@(S# _) ib@(J# _ _) = quotInteger (toBig ia) ib
248 quotInteger (J# sa a) (S# b)
249   = case int2Integer# b of { (# sb, b' #) ->
250     case quotInteger# sa a sb b' of (# sq, q #) -> J# sq q }
251 quotInteger (J# sa a) (J# sb b)
252   = case quotInteger# sa a sb b of (# sg, g #) -> J# sg g
253 \end{code}
254
255
256
257 \begin{code}
258 -- We can't throw an error here, so it is up to our caller to
259 -- not call us with both arguments being 0.
260 gcdInteger :: Integer -> Integer -> Integer
261 -- SUP: Do we really need the first two cases?
262 gcdInteger a@(S# INT_MINBOUND) b = gcdInteger (toBig a) b
263 gcdInteger a b@(S# INT_MINBOUND) = gcdInteger a (toBig b)
264 gcdInteger (S# a) (S# b) = S# (gcdInt a b)
265 gcdInteger ia@(S# a)  ib@(J# sb b)
266  =      if a  ==# 0# then absInteger ib
267    else if sb ==# 0# then absInteger ia
268    else                   S# (gcdIntegerInt# absSb b absA)
269        where !absA  = if a  <# 0# then negateInt# a  else a
270              !absSb = if sb <# 0# then negateInt# sb else sb
271 gcdInteger ia@(J# _ _) ib@(S# _) = gcdInteger ib ia
272 gcdInteger (J# sa a) (J# sb b)
273   = case gcdInteger# sa a sb b of (# sg, g #) -> J# sg g
274
275 lcmInteger :: Integer -> Integer -> Integer
276 lcmInteger a b =      if a `eqInteger` S# 0# then S# 0#
277                  else if b `eqInteger` S# 0# then S# 0#
278                  else (divExact aa (gcdInteger aa ab)) `timesInteger` ab
279   where aa = absInteger a
280         ab = absInteger b
281
282 {-# RULES "gcdInteger/Int" forall a b.
283             gcdInteger (S# a) (S# b) = S# (gcdInt a b)
284   #-}
285 gcdInt :: Int# -> Int# -> Int#
286 gcdInt 0# y  = absInt y
287 gcdInt x  0# = absInt x
288 gcdInt x  y  = gcdInt# (absInt x) (absInt y)
289
290 absInt :: Int# -> Int#
291 absInt x = if x <# 0# then negateInt# x else x
292
293 divExact :: Integer -> Integer -> Integer
294 divExact a@(S# INT_MINBOUND) b = divExact (toBig a) b
295 divExact (S# a) (S# b) = S# (quotInt# a b)
296 divExact (S# a) (J# sb b)
297   = S# (quotInt# a (integer2Int# sb b))
298 divExact (J# sa a) (S# b)
299   = case int2Integer# b of
300     (# sb, b' #) -> case divExactInteger# sa a sb b' of
301                     (# sd, d #) -> J# sd d
302 divExact (J# sa a) (J# sb b)
303   = case divExactInteger# sa a sb b of (# sd, d #) -> J# sd d
304 \end{code}
305
306
307 %*********************************************************
308 %*                                                      *
309 \subsection{The @Integer@ instances for @Eq@, @Ord@}
310 %*                                                      *
311 %*********************************************************
312
313 \begin{code}
314 eqInteger :: Integer -> Integer -> Bool
315 eqInteger (S# i)     (S# j)     = i ==# j
316 eqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ==# 0#
317 eqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ==# 0#
318 eqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ==# 0#
319
320 neqInteger :: Integer -> Integer -> Bool
321 neqInteger (S# i)     (S# j)     = i /=# j
322 neqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i /=# 0#
323 neqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i /=# 0#
324 neqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) /=# 0#
325
326 ------------------------------------------------------------------------
327
328 leInteger :: Integer -> Integer -> Bool
329 leInteger (S# i)     (S# j)     = i <=# j
330 leInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <=# 0#
331 leInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i >=# 0#
332 leInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <=# 0#
333
334 gtInteger :: Integer -> Integer -> Bool
335 gtInteger (S# i)     (S# j)     = i ># j
336 gtInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ># 0#
337 gtInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <# 0#
338 gtInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ># 0#
339
340 ltInteger :: Integer -> Integer -> Bool
341 ltInteger (S# i)     (S# j)     = i <# j
342 ltInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <# 0#
343 ltInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ># 0#
344 ltInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <# 0#
345
346 geInteger :: Integer -> Integer -> Bool
347 geInteger (S# i)     (S# j)     = i >=# j
348 geInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i >=# 0#
349 geInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <=# 0#
350 geInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) >=# 0#
351
352 compareInteger :: Integer -> Integer -> Ordering
353 compareInteger (S# i)  (S# j)
354    =      if i ==# j then EQ
355      else if i <=# j then LT
356      else                 GT
357 compareInteger (J# s d) (S# i)
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 (S# i) (J# s d)
363    = case cmpIntegerInt# s d i of { res# ->
364      if res# ># 0# then LT else
365      if res# <# 0# then GT else EQ
366      }
367 compareInteger (J# s1 d1) (J# s2 d2)
368    = case cmpInteger# s1 d1 s2 d2 of { res# ->
369      if res# <# 0# then LT else
370      if res# ># 0# then GT else EQ
371      }
372 \end{code}
373
374
375 %*********************************************************
376 %*                                                      *
377 \subsection{The @Integer@ instances for @Num@}
378 %*                                                      *
379 %*********************************************************
380
381 \begin{code}
382 {-# INLINE absInteger #-}
383 absInteger :: Integer -> Integer
384 absInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
385 absInteger n@(S# i) = if i >=# 0# then n else S# (negateInt# i)
386 absInteger n@(J# s d) = if (s >=# 0#) then n else J# (negateInt# s) d
387
388 signumInteger :: Integer -> Integer
389 signumInteger (S# i) = if i <# 0# then S# -1#
390                        else if i ==# 0# then S# 0#
391                        else S# 1#
392 signumInteger (J# s d)
393   = let
394         !cmp = cmpIntegerInt# s d 0#
395     in
396     if      cmp >#  0# then S# 1#
397     else if cmp ==# 0# then S# 0#
398     else                    S# (negateInt# 1#)
399
400 plusInteger :: Integer -> Integer -> Integer
401 plusInteger i1@(S# i) i2@(S# j)  = case addIntC# i j of
402                                    (# r, c #) ->
403                                        if c ==# 0#
404                                        then S# r
405                                        else plusInteger (toBig i1) (toBig i2)
406 plusInteger i1@(J# _ _) i2@(S# _) = plusInteger i1 (toBig i2)
407 plusInteger i1@(S# _) i2@(J# _ _) = plusInteger (toBig i1) i2
408 plusInteger (J# s1 d1) (J# s2 d2) = case plusInteger# s1 d1 s2 d2 of
409                                     (# s, d #) -> J# s d
410
411 minusInteger :: Integer -> Integer -> Integer
412 minusInteger i1@(S# i) i2@(S# j)   = case subIntC# i j of
413                                      (# r, c #) ->
414                                          if c ==# 0# then S# r
415                                          else minusInteger (toBig i1)
416                                                            (toBig i2)
417 minusInteger i1@(J# _ _) i2@(S# _) = minusInteger i1 (toBig i2)
418 minusInteger i1@(S# _) i2@(J# _ _) = minusInteger (toBig i1) i2
419 minusInteger (J# s1 d1) (J# s2 d2) = case minusInteger# s1 d1 s2 d2 of
420                                      (# s, d #) -> J# s d
421
422 timesInteger :: Integer -> Integer -> Integer
423 timesInteger i1@(S# i) i2@(S# j)   = if mulIntMayOflo# i j ==# 0#
424                                      then S# (i *# j)
425                                      else timesInteger (toBig i1) (toBig i2)
426 timesInteger i1@(J# _ _) i2@(S# _) = timesInteger i1 (toBig i2)
427 timesInteger i1@(S# _) i2@(J# _ _) = timesInteger (toBig i1) i2
428 timesInteger (J# s1 d1) (J# s2 d2) = case timesInteger# s1 d1 s2 d2 of
429                                      (# s, d #) -> J# s d
430
431 negateInteger :: Integer -> Integer
432 negateInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
433 negateInteger (S# i)            = S# (negateInt# i)
434 negateInteger (J# s d)          = J# (negateInt# s) d
435 \end{code}
436
437
438 %*********************************************************
439 %*                                                      *
440 \subsection{The @Integer@ stuff for Double@}
441 %*                                                      *
442 %*********************************************************
443
444 \begin{code}
445 encodeFloatInteger :: Integer -> Int# -> Float#
446 encodeFloatInteger (S# i) j     = int_encodeFloat# i j
447 encodeFloatInteger (J# s# d#) e = encodeFloat# s# d# e
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 "integer_cbits_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 "integer_cbits_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