4ca4cee3b8735ea418489ad882775ef7b0e13df5
[packages/integer-gmp.git] / GHC / Integer.lhs
1 \begin{code}
2 {-# LANGUAGE BangPatterns, CPP, MagicHash #-}
3 {-# OPTIONS_GHC -XNoImplicitPrelude #-}
4 {-# OPTIONS_HADDOCK hide #-}
5 -----------------------------------------------------------------------------
6 -- |
7 -- Module      :  GHC.Integer
8 -- Copyright   :  (c) The University of Glasgow 1994-2008
9 -- License     :  see libraries/integer-gmp/LICENSE
10 --
11 -- Maintainer  :  cvs-ghc@haskell.org
12 -- Stability   :  internal
13 -- Portability :  non-portable (GHC Extensions)
14 --
15 -- The 'Integer' type.
16 --
17 -----------------------------------------------------------------------------
18
19 #include "MachDeps.h"
20 #if SIZEOF_HSWORD == 4
21 #define INT_MINBOUND (-2147483648#)
22 #define NEG_INT_MINBOUND (S# 2147483647# `plusInteger` S# 1#)
23 #elif SIZEOF_HSWORD == 8
24 #define INT_MINBOUND (-9223372036854775808#)
25 #define NEG_INT_MINBOUND (S# 9223372036854775807# `plusInteger` S# 1#)
26 #else
27 #error Unknown SIZEOF_HSWORD; can't define INT_MINBOUND and NEG_INT_MINBOUND
28 #endif
29
30 module GHC.Integer (
31     Integer,
32     smallInteger, wordToInteger, integerToWord, toInt#,
33 #if WORD_SIZE_IN_BITS < 64
34     integerToWord64, word64ToInteger,
35     integerToInt64, int64ToInteger,
36 #endif
37     plusInteger, minusInteger, timesInteger, negateInteger,
38     eqInteger, neqInteger, absInteger, signumInteger,
39     leInteger, gtInteger, ltInteger, geInteger, compareInteger,
40     divModInteger, quotRemInteger, quotInteger, remInteger,
41     encodeFloatInteger, floatFromInteger,
42     encodeDoubleInteger, decodeDoubleInteger, doubleFromInteger,
43     gcdInteger, lcmInteger,
44     andInteger, orInteger, xorInteger, complementInteger,
45     shiftLInteger, shiftRInteger,
46     hashInteger,
47  ) where
48
49 import GHC.Prim (
50     -- Other types we use, convert from, or convert to
51     Int#, Word#, Double#, Float#, ByteArray#,
52     -- Conversions between those types
53     int2Word#, int2Double#, int2Float#, word2Int#,
54     -- Operations on Int# that we use for operations on S#
55     quotInt#, remInt#, negateInt#,
56     (==#), (/=#), (<=#), (>=#), (<#), (>#), (*#), (-#), (+#),
57     mulIntMayOflo#, addIntC#, subIntC#,
58     and#, or#, xor#
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.Ordering
89 import GHC.Types
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 {-# NOINLINE toInt# #-}
146 {-# RULES "toInt#" forall i. toInt# (S# i) = i #-}
147 -- Don't inline toInt#, because it can't do much unless
148 -- it sees a (S# i), and inlining just creates fruitless
149 -- join points.  But we do need a RULE to get the constants
150 -- to work right:  1::Int had better optimise to (I# 1)!
151 toInt# (S# i)   = i
152 toInt# (J# s d) = integer2Int# s d
153
154 toBig :: Integer -> Integer
155 toBig (S# i)     = case int2Integer# i of { (# s, d #) -> J# s d }
156 toBig i@(J# _ _) = i
157 \end{code}
158
159
160 %*********************************************************
161 %*                                                      *
162 \subsection{Dividing @Integers@}
163 %*                                                      *
164 %*********************************************************
165
166 \begin{code}
167 -- XXX There's no good reason for us using unboxed tuples for the
168 -- results, but we don't have Data.Tuple available.
169
170 -- Note that we don't check for divide-by-zero here. That needs
171 -- to be done where it's used.
172 -- (we don't have error)
173
174 quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
175 quotRemInteger a@(S# INT_MINBOUND) b = quotRemInteger (toBig a) b
176 quotRemInteger (S# i) (S# j) = (# S# q, S# r #)
177     where
178       -- NB. don't inline these.  (# S# (i `quotInt#` j), ... #) means
179       -- (# let q = i `quotInt#` j in S# q, ... #) which builds a
180       -- useless thunk.  Placing the bindings here means they'll be
181       -- evaluated strictly.
182       !q = i `quotInt#` j
183       !r = i `remInt#`  j
184 quotRemInteger i1@(J# _ _) i2@(S# _) = quotRemInteger i1 (toBig i2)
185 quotRemInteger i1@(S# _) i2@(J# _ _) = quotRemInteger (toBig i1) i2
186 quotRemInteger (J# s1 d1) (J# s2 d2)
187   = case (quotRemInteger# s1 d1 s2 d2) of
188           (# s3, d3, s4, d4 #)
189             -> (# J# s3 d3, J# s4 d4 #)
190
191 divModInteger :: Integer -> Integer -> (# Integer, Integer #)
192 divModInteger a@(S# INT_MINBOUND) b = divModInteger (toBig a) b
193 divModInteger (S# i) (S# j) = (# S# d, S# m #)
194     where
195       -- NB. don't inline these.  See quotRemInteger above.
196       !d = i `divInt#` j
197       !m = i `modInt#` j
198
199       -- XXX Copied from GHC.Base
200       divInt# :: Int# -> Int# -> Int#
201       x# `divInt#` y#
202        =      if (x# ># 0#) && (y# <# 0#) then ((x# -# 1#) `quotInt#` y#) -# 1#
203          else if (x# <# 0#) && (y# ># 0#) then ((x# +# 1#) `quotInt#` y#) -# 1#
204          else x# `quotInt#` y#
205
206       modInt# :: Int# -> Int# -> Int#
207       x# `modInt#` y#
208        = if ((x# ># 0#) && (y# <# 0#)) ||
209             ((x# <# 0#) && (y# ># 0#))
210          then if r# /=# 0# then r# +# y# else 0#
211          else r#
212           where !r# = x# `remInt#` y#
213
214       (&&) :: Bool -> Bool -> Bool
215       True  && x = x
216       False && _ = False
217
218       (||) :: Bool -> Bool -> Bool
219       True  || _ = True
220       False || x = x
221 divModInteger i1@(J# _ _) i2@(S# _) = divModInteger i1 (toBig i2)
222 divModInteger i1@(S# _) i2@(J# _ _) = divModInteger (toBig i1) i2
223 divModInteger (J# s1 d1) (J# s2 d2)
224   = case (divModInteger# s1 d1 s2 d2) of
225           (# s3, d3, s4, d4 #)
226             -> (# J# s3 d3, J# s4 d4 #)
227
228 remInteger :: Integer -> Integer -> Integer
229 remInteger a@(S# INT_MINBOUND) b = remInteger (toBig a) b
230 remInteger (S# a) (S# b) = S# (remInt# a b)
231 {- Special case doesn't work, because a 1-element J# has the range
232    -(2^32-1) -- 2^32-1, whereas S# has the range -2^31 -- (2^31-1)
233 remInteger ia@(S# a) (J# sb b)
234   | sb ==# 1#  = S# (remInt# a (word2Int# (integer2Word# sb b)))
235   | sb ==# -1# = S# (remInt# a (0# -# (word2Int# (integer2Word# sb b))))
236   | 0# <# sb   = ia
237   | otherwise  = S# (0# -# a)
238 -}
239 remInteger ia@(S# _) ib@(J# _ _) = remInteger (toBig ia) ib
240 remInteger (J# sa a) (S# b)
241   = case int2Integer# b of { (# sb, b' #) ->
242     case remInteger# sa a sb b' of { (# sr, r #) ->
243     S# (integer2Int# sr r) }}
244 remInteger (J# sa a) (J# sb b)
245   = case remInteger# sa a sb b of (# sr, r #) -> J# sr r
246
247 quotInteger :: Integer -> Integer -> Integer
248 quotInteger a@(S# INT_MINBOUND) b = quotInteger (toBig a) b
249 quotInteger (S# a) (S# b) = S# (quotInt# a b)
250 {- Special case disabled, see remInteger above
251 quotInteger (S# a) (J# sb b)
252   | sb ==# 1#  = S# (quotInt# a (word2Int# (integer2Word# sb b)))
253   | sb ==# -1# = S# (quotInt# a (0# -# (word2Int# (integer2Word# sb b))))
254   | otherwise  = S# 0
255 -}
256 quotInteger ia@(S# _) ib@(J# _ _) = quotInteger (toBig ia) ib
257 quotInteger (J# sa a) (S# b)
258   = case int2Integer# b of { (# sb, b' #) ->
259     case quotInteger# sa a sb b' of (# sq, q #) -> J# sq q }
260 quotInteger (J# sa a) (J# sb b)
261   = case quotInteger# sa a sb b of (# sg, g #) -> J# sg g
262 \end{code}
263
264
265
266 \begin{code}
267 -- We can't throw an error here, so it is up to our caller to
268 -- not call us with both arguments being 0.
269 gcdInteger :: Integer -> Integer -> Integer
270 -- SUP: Do we really need the first two cases?
271 gcdInteger a@(S# INT_MINBOUND) b = gcdInteger (toBig a) b
272 gcdInteger a b@(S# INT_MINBOUND) = gcdInteger a (toBig b)
273 gcdInteger (S# a) (S# b) = S# (gcdInt a b)
274 gcdInteger ia@(S# a)  ib@(J# sb b)
275  =      if a  ==# 0# then absInteger ib
276    else if sb ==# 0# then absInteger ia
277    else                   S# (gcdIntegerInt# absSb b absA)
278        where !absA  = if a  <# 0# then negateInt# a  else a
279              !absSb = if sb <# 0# then negateInt# sb else sb
280 gcdInteger ia@(J# _ _) ib@(S# _) = gcdInteger ib ia
281 gcdInteger (J# sa a) (J# sb b)
282   = case gcdInteger# sa a sb b of (# sg, g #) -> J# sg g
283
284 lcmInteger :: Integer -> Integer -> Integer
285 lcmInteger a b =      if a `eqInteger` S# 0# then S# 0#
286                  else if b `eqInteger` S# 0# then S# 0#
287                  else (divExact aa (gcdInteger aa ab)) `timesInteger` ab
288   where aa = absInteger a
289         ab = absInteger b
290
291 {-# RULES "gcdInteger/Int" forall a b.
292             gcdInteger (S# a) (S# b) = S# (gcdInt a b)
293   #-}
294 gcdInt :: Int# -> Int# -> Int#
295 gcdInt 0# y  = absInt y
296 gcdInt x  0# = absInt x
297 gcdInt x  y  = gcdInt# (absInt x) (absInt y)
298
299 absInt :: Int# -> Int#
300 absInt x = if x <# 0# then negateInt# x else x
301
302 divExact :: Integer -> Integer -> Integer
303 divExact a@(S# INT_MINBOUND) b = divExact (toBig a) b
304 divExact (S# a) (S# b) = S# (quotInt# a b)
305 divExact (S# a) (J# sb b)
306   = S# (quotInt# a (integer2Int# sb b))
307 divExact (J# sa a) (S# b)
308   = case int2Integer# b of
309     (# sb, b' #) -> case divExactInteger# sa a sb b' of
310                     (# sd, d #) -> J# sd d
311 divExact (J# sa a) (J# sb b)
312   = case divExactInteger# sa a sb b of (# sd, d #) -> J# sd d
313 \end{code}
314
315
316 %*********************************************************
317 %*                                                      *
318 \subsection{The @Integer@ instances for @Eq@, @Ord@}
319 %*                                                      *
320 %*********************************************************
321
322 \begin{code}
323 eqInteger :: Integer -> Integer -> Bool
324 eqInteger (S# i)     (S# j)     = i ==# j
325 eqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ==# 0#
326 eqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ==# 0#
327 eqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ==# 0#
328
329 neqInteger :: Integer -> Integer -> Bool
330 neqInteger (S# i)     (S# j)     = i /=# j
331 neqInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i /=# 0#
332 neqInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i /=# 0#
333 neqInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) /=# 0#
334
335 ------------------------------------------------------------------------
336
337 leInteger :: Integer -> Integer -> Bool
338 leInteger (S# i)     (S# j)     = i <=# j
339 leInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <=# 0#
340 leInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i >=# 0#
341 leInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <=# 0#
342
343 gtInteger :: Integer -> Integer -> Bool
344 gtInteger (S# i)     (S# j)     = i ># j
345 gtInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i ># 0#
346 gtInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <# 0#
347 gtInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ># 0#
348
349 ltInteger :: Integer -> Integer -> Bool
350 ltInteger (S# i)     (S# j)     = i <# j
351 ltInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i <# 0#
352 ltInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i ># 0#
353 ltInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <# 0#
354
355 geInteger :: Integer -> Integer -> Bool
356 geInteger (S# i)     (S# j)     = i >=# j
357 geInteger (J# s d)   (S# i)     = cmpIntegerInt# s d i >=# 0#
358 geInteger (S# i)     (J# s d)   = cmpIntegerInt# s d i <=# 0#
359 geInteger (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) >=# 0#
360
361 compareInteger :: Integer -> Integer -> Ordering
362 compareInteger (S# i)  (S# j)
363    =      if i ==# j then EQ
364      else if i <=# j then LT
365      else                 GT
366 compareInteger (J# s d) (S# i)
367    = case cmpIntegerInt# s d i of { res# ->
368      if res# <# 0# then LT else
369      if res# ># 0# then GT else EQ
370      }
371 compareInteger (S# i) (J# s d)
372    = case cmpIntegerInt# s d i of { res# ->
373      if res# ># 0# then LT else
374      if res# <# 0# then GT else EQ
375      }
376 compareInteger (J# s1 d1) (J# s2 d2)
377    = case cmpInteger# s1 d1 s2 d2 of { res# ->
378      if res# <# 0# then LT else
379      if res# ># 0# then GT else EQ
380      }
381 \end{code}
382
383
384 %*********************************************************
385 %*                                                      *
386 \subsection{The @Integer@ instances for @Num@}
387 %*                                                      *
388 %*********************************************************
389
390 \begin{code}
391 {-# INLINE absInteger #-}
392 absInteger :: Integer -> Integer
393 absInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
394 absInteger n@(S# i) = if i >=# 0# then n else S# (negateInt# i)
395 absInteger n@(J# s d) = if (s >=# 0#) then n else J# (negateInt# s) d
396
397 signumInteger :: Integer -> Integer
398 signumInteger (S# i) = if i <# 0# then S# -1#
399                        else if i ==# 0# then S# 0#
400                        else S# 1#
401 signumInteger (J# s d)
402   = let
403         !cmp = cmpIntegerInt# s d 0#
404     in
405     if      cmp >#  0# then S# 1#
406     else if cmp ==# 0# then S# 0#
407     else                    S# (negateInt# 1#)
408
409 plusInteger :: Integer -> Integer -> Integer
410 plusInteger i1@(S# i) i2@(S# j)  = case addIntC# i j of
411                                    (# r, c #) ->
412                                        if c ==# 0#
413                                        then S# r
414                                        else plusInteger (toBig i1) (toBig i2)
415 plusInteger i1@(J# _ _) i2@(S# _) = plusInteger i1 (toBig i2)
416 plusInteger i1@(S# _) i2@(J# _ _) = plusInteger (toBig i1) i2
417 plusInteger (J# s1 d1) (J# s2 d2) = case plusInteger# s1 d1 s2 d2 of
418                                     (# s, d #) -> J# s d
419
420 minusInteger :: Integer -> Integer -> Integer
421 minusInteger i1@(S# i) i2@(S# j)   = case subIntC# i j of
422                                      (# r, c #) ->
423                                          if c ==# 0# then S# r
424                                          else minusInteger (toBig i1)
425                                                            (toBig i2)
426 minusInteger i1@(J# _ _) i2@(S# _) = minusInteger i1 (toBig i2)
427 minusInteger i1@(S# _) i2@(J# _ _) = minusInteger (toBig i1) i2
428 minusInteger (J# s1 d1) (J# s2 d2) = case minusInteger# s1 d1 s2 d2 of
429                                      (# s, d #) -> J# s d
430
431 timesInteger :: Integer -> Integer -> Integer
432 timesInteger i1@(S# i) i2@(S# j)   = if mulIntMayOflo# i j ==# 0#
433                                      then S# (i *# j)
434                                      else timesInteger (toBig i1) (toBig i2)
435 timesInteger i1@(J# _ _) i2@(S# _) = timesInteger i1 (toBig i2)
436 timesInteger i1@(S# _) i2@(J# _ _) = timesInteger (toBig i1) i2
437 timesInteger (J# s1 d1) (J# s2 d2) = case timesInteger# s1 d1 s2 d2 of
438                                      (# s, d #) -> J# s d
439
440 negateInteger :: Integer -> Integer
441 negateInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
442 negateInteger (S# i)            = S# (negateInt# i)
443 negateInteger (J# s d)          = J# (negateInt# s) d
444 \end{code}
445
446
447 %*********************************************************
448 %*                                                      *
449 \subsection{The @Integer@ stuff for Double@}
450 %*                                                      *
451 %*********************************************************
452
453 \begin{code}
454 encodeFloatInteger :: Integer -> Int# -> Float#
455 encodeFloatInteger (S# i) j     = int_encodeFloat# i j
456 encodeFloatInteger (J# s# d#) e = encodeFloat# s# d# e
457
458 encodeDoubleInteger :: Integer -> Int# -> Double#
459 encodeDoubleInteger (S# i) j     = int_encodeDouble# i j
460 encodeDoubleInteger (J# s# d#) e = encodeDouble# s# d# e
461
462 decodeDoubleInteger :: Double# -> (# Integer, Int# #)
463 decodeDoubleInteger d = case decodeDouble# d of
464                         (# exp#, s#, d# #) -> (# J# s# d#, exp# #)
465
466 -- previous code: doubleFromInteger n = fromInteger n = encodeFloat n 0
467 -- doesn't work too well, because encodeFloat is defined in
468 -- terms of ccalls which can never be simplified away.  We
469 -- want simple literals like (fromInteger 3 :: Float) to turn
470 -- into (F# 3.0), hence the special case for S# here.
471
472 doubleFromInteger :: Integer -> Double#
473 doubleFromInteger (S# i#) = int2Double# i#
474 doubleFromInteger (J# s# d#) = encodeDouble# s# d# 0#
475
476 floatFromInteger :: Integer -> Float#
477 floatFromInteger (S# i#) = int2Float# i#
478 floatFromInteger (J# s# d#) = encodeFloat# s# d# 0#
479
480 foreign import ccall unsafe "integer_cbits_encodeFloat"
481         encodeFloat# :: Int# -> ByteArray# -> Int# -> Float#
482 foreign import ccall unsafe "__int_encodeFloat"
483         int_encodeFloat# :: Int# -> Int# -> Float#
484
485 foreign import ccall unsafe "integer_cbits_encodeDouble"
486         encodeDouble# :: Int# -> ByteArray# -> Int# -> Double#
487 foreign import ccall unsafe "__int_encodeDouble"
488         int_encodeDouble# :: Int# -> Int# -> Double#
489 \end{code}
490
491 %*********************************************************
492 %*                                                      *
493 \subsection{The @Integer@ Bit definitions@}
494 %*                                                      *
495 %*********************************************************
496
497 We explicitly pattern match against J# and S# in order to produce
498 Core that doesn't have pattern matching errors, as that would
499 introduce a spurious dependency to base.
500
501 \begin{code}
502 andInteger :: Integer -> Integer -> Integer
503 (S# x) `andInteger` (S# y) = S# (word2Int# (int2Word# x `and#` int2Word# y))
504 x@(S# _) `andInteger` y@(J# _ _) = toBig x `andInteger` y
505 x@(J# _ _) `andInteger` y@(S# _) = x `andInteger` toBig y
506 (J# s1 d1) `andInteger` (J# s2 d2) =
507      case andInteger# s1 d1 s2 d2 of
508        (# s, d #) -> J# s d
509
510 orInteger :: Integer -> Integer -> Integer
511 (S# x) `orInteger` (S# y) = S# (word2Int# (int2Word# x `or#` int2Word# y))
512 x@(S# _) `orInteger` y@(J# _ _) = toBig x `orInteger` y
513 x@(J# _ _) `orInteger` y@(S# _) = x `orInteger` toBig y
514 (J# s1 d1) `orInteger` (J# s2 d2) =
515      case orInteger# s1 d1 s2 d2 of
516        (# s, d #) -> J# s d
517
518 xorInteger :: Integer -> Integer -> Integer
519 (S# x) `xorInteger` (S# y) = S# (word2Int# (int2Word# x `xor#` int2Word# y))
520 x@(S# _) `xorInteger` y@(J# _ _) = toBig x `xorInteger` y
521 x@(J# _ _) `xorInteger` y@(S# _) = x `xorInteger` toBig y
522 (J# s1 d1) `xorInteger` (J# s2 d2) =
523      case xorInteger# s1 d1 s2 d2 of
524        (# s, d #) -> J# s d
525
526 complementInteger :: Integer -> Integer
527 complementInteger (S# x)
528     = S# (word2Int# (int2Word# x `xor#` int2Word# (0# -# 1#)))
529 complementInteger (J# s d)
530     = case complementInteger# s d of (# s', d' #) -> J# s' d'
531
532 shiftLInteger :: Integer -> Int# -> Integer
533 shiftLInteger j@(S# _) i = shiftLInteger (toBig j) i
534 shiftLInteger (J# s d) i = case mul2ExpInteger# s d i of
535                            (# s', d' #) -> J# s' d'
536
537 shiftRInteger :: Integer -> Int# -> Integer
538 shiftRInteger j@(S# _) i = shiftRInteger (toBig j) i
539 shiftRInteger (J# s d) i = case fdivQ2ExpInteger# s d i of
540                            (# s', d' #) -> J# s' d'
541 \end{code}
542
543 %*********************************************************
544 %*                                                      *
545 \subsection{The @Integer@ hashing@}
546 %*                                                      *
547 %*********************************************************
548
549 \begin{code}
550 -- This is used by hashUnique
551
552 -- | hashInteger returns the same value as 'fromIntegral', although in
553 -- unboxed form.  It might be a reasonable hash function for 'Integer', 
554 -- given a suitable distribution of 'Integer' values.
555
556 hashInteger :: Integer -> Int#
557 hashInteger = toInt#
558                               
559 \end{code}
560