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