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