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