Fix GMP v4 compatibility.
[packages/integer-gmp.git] / GHC / Integer / Type.lhs
1 \begin{code}
2 {-# LANGUAGE BangPatterns, CPP, UnboxedTuples, UnliftedFFITypes, MagicHash, NoImplicitPrelude #-}
3 {-# OPTIONS_HADDOCK hide #-}
4
5 -- Commentary of Integer library is located on the wiki:
6 -- http://ghc.haskell.org/trac/ghc/wiki/Commentary/Libraries/Integer
7 --
8 -- It gives an in-depth description of implementation details and
9 -- decisions.
10 --
11 -- TODO: Try to use optimized big/small int primops on IL32P64 archs
12 -- (mostly Windows/x86_64). Currently, we have to fall back to
13 -- unoptimized code-paths for most big/small-int primops, due to
14 -- @mpz_*()@ functions using @long@ types, which is smaller than
15 -- @mp_limb_t@ on IL32P64. The @mpn_*()@ functions are often safe to
16 -- use, as they use @mb_limb_t@ instead of @long@.
17 -- (look out for @#if SIZEOF_HSWORD == SIZEOF_LONG@ occurences)
18 --
19
20 #include "MachDeps.h"
21 #include "HsIntegerGmp.h"
22
23 #if SIZEOF_HSWORD == 4
24 #define INT_MINBOUND (-2147483648#)
25 #define NEG_INT_MINBOUND (S# 2147483647# `plusInteger` S# 1#)
26 #elif SIZEOF_HSWORD == 8
27 #define INT_MINBOUND (-9223372036854775808#)
28 #define NEG_INT_MINBOUND (S# 9223372036854775807# `plusInteger` S# 1#)
29 #else
30 #error Unknown SIZEOF_HSWORD; can't define INT_MINBOUND and NEG_INT_MINBOUND
31 #endif
32
33 module GHC.Integer.Type where
34
35 import GHC.Prim (
36     -- Other types we use, convert from, or convert to
37     Int#, Word#, Double#, Float#, ByteArray#, MutableByteArray#, Addr#, State#,
38     indexIntArray#,
39     -- Conversions between those types
40     int2Word#, int2Double#, int2Float#, word2Int#,
41     -- Operations on Int# that we use for operations on S#
42     quotInt#, remInt#, quotRemInt#, negateInt#,
43     (*#), (-#),
44     (==#), (/=#), (<=#), (>=#), (<#), (>#),
45     mulIntMayOflo#, addIntC#, subIntC#,
46     and#, or#, xor#,
47  )
48
49 import GHC.Integer.GMP.Prim (
50     -- GMP-related primitives
51     MPZ#,
52     cmpInteger#, cmpIntegerInt#,
53     plusInteger#, minusInteger#,
54     timesInteger#,
55     quotRemInteger#, quotInteger#, remInteger#,
56     divModInteger#, divInteger#, modInteger#,
57     divExactInteger#,
58     gcdInteger#, gcdExtInteger#, gcdIntegerInt#, gcdInt#,
59     decodeDouble#,
60     int2Integer#, integer2Int#, word2Integer#, integer2Word#,
61     andInteger#, orInteger#, xorInteger#, complementInteger#,
62     testBitInteger#, mul2ExpInteger#, fdivQ2ExpInteger#,
63     powInteger#, powModInteger#, powModSecInteger#, recipModInteger#,
64     nextPrimeInteger#, testPrimeInteger#,
65     sizeInBaseInteger#,
66     importIntegerFromByteArray#, importIntegerFromAddr#,
67     exportIntegerToMutableByteArray#, exportIntegerToAddr#,
68
69 #if SIZEOF_HSWORD == SIZEOF_LONG
70     plusIntegerInt#, minusIntegerInt#,
71     timesIntegerInt#,
72     divIntegerWord#, modIntegerWord#, divModIntegerWord#,
73     divExactIntegerWord#,
74     quotIntegerWord#, remIntegerWord#, quotRemIntegerWord#,
75 #endif
76
77 #if WORD_SIZE_IN_BITS < 64
78     int64ToInteger#,  integerToInt64#,
79     word64ToInteger#, integerToWord64#,
80 #endif
81  )
82
83 #if WORD_SIZE_IN_BITS < 64
84 import GHC.IntWord64 (
85             Int64#, Word64#,
86             int64ToWord64#, intToInt64#,
87             int64ToInt#, word64ToInt64#,
88             geInt64#, leInt64#, leWord64#,
89        )
90 #endif
91
92 import GHC.Classes
93 import GHC.Types
94
95 default ()
96 \end{code}
97
98 %*********************************************************
99 %*                                                      *
100 \subsection{The @Integer@ type}
101 %*                                                      *
102 %*********************************************************
103
104 Convenient boxed Integer PrimOps.
105
106 \begin{code}
107 -- | Arbitrary-precision integers.
108 data Integer
109    = S# Int#            -- ^ \"small\" integers fitting into an 'Int#'
110    | J# Int# ByteArray# -- ^ \"big\" integers represented as GMP's @mpz_t@ structure.
111      --
112      -- The 'Int#' field corresponds to @mpz_t@'s @_mp_size@ field,
113      -- which encodes the sign and the number of /limbs/ stored in the
114      -- 'ByteArray#' field (i.e. @mpz_t@'s @_mp_d@ field). Note: The
115      -- 'ByteArray#' may have been over-allocated, and thus larger
116      -- than the size denoted by the 'Int#' field.
117      --
118      -- This representation tries to avoid using the GMP number
119      -- representation for small integers that fit into a native
120      -- 'Int#'. This allows to reduce (or at least defer) calling into GMP
121      -- for operations whose results remain in the 'Int#'-domain.
122      --
123      -- Note: It does __not__ constitute a violation of invariants to
124      -- represent an integer which would fit into an 'Int#' with the
125      -- 'J#'-constructor. For instance, the value @0@ has (only) two valid
126      -- representations, either @'S#' 0#@ or @'J#' 0 _@.
127
128 -- | Construct 'Integer' value from list of 'Int's.
129 --
130 -- This function is used by GHC for constructing 'Integer' literals.
131 mkInteger :: Bool   -- ^ sign of integer ('True' if non-negative)
132           -> [Int]  -- ^ absolute value expressed in 31 bit chunks, least significant first
133
134                     -- (ideally these would be machine-word 'Word's rather than 31-bit truncated 'Int's)
135           -> Integer
136 mkInteger nonNegative is = let abs = f is
137                            in if nonNegative then abs else negateInteger abs
138     where f [] = S# 0#
139           f (I# i : is') = S# i `orInteger` shiftLInteger (f is') 31#
140
141 {-# NOINLINE smallInteger #-}
142 smallInteger :: Int# -> Integer
143 smallInteger i = S# i
144
145 {-# NOINLINE wordToInteger #-}
146 wordToInteger :: Word# -> Integer
147 wordToInteger w = if isTrue# (i >=# 0#)
148                   then S# i
149                   else case word2Integer# w of (# s, d #) -> J# s d
150     where
151       !i = word2Int# w
152
153 {-# NOINLINE integerToWord #-}
154 integerToWord :: Integer -> Word#
155 integerToWord (S# i) = int2Word# i
156 integerToWord (J# s d) = integer2Word# s d
157
158 #if WORD_SIZE_IN_BITS < 64
159 {-# NOINLINE integerToWord64 #-}
160 integerToWord64 :: Integer -> Word64#
161 integerToWord64 (S# i) = int64ToWord64# (intToInt64# i)
162 integerToWord64 (J# s d) = integerToWord64# s d
163
164 {-# NOINLINE word64ToInteger #-}
165 word64ToInteger :: Word64# -> Integer
166 word64ToInteger w = if isTrue# (w `leWord64#` int64ToWord64# (intToInt64# 0x7FFFFFFF#))
167                     then S# (int64ToInt# (word64ToInt64# w))
168                     else case word64ToInteger# w of
169                          (# s, d #) -> J# s d
170
171 {-# NOINLINE integerToInt64 #-}
172 integerToInt64 :: Integer -> Int64#
173 integerToInt64 (S# i) = intToInt64# i
174 integerToInt64 (J# s d) = integerToInt64# s d
175
176 {-# NOINLINE int64ToInteger #-}
177 int64ToInteger :: Int64# -> Integer
178 int64ToInteger i = if isTrue# (i `leInt64#` intToInt64# 0x7FFFFFFF#) &&
179                       isTrue# (i `geInt64#` intToInt64# -0x80000000#)
180                    then smallInteger (int64ToInt# i)
181                    else case int64ToInteger# i of
182                         (# s, d #) -> J# s d
183 #endif
184
185 integerToInt :: Integer -> Int#
186 {-# NOINLINE integerToInt #-}
187 integerToInt (S# i)   = i
188 integerToInt (J# s d) = integer2Int# s d
189
190 -- This manually floated out constant is needed as GHC doesn't do it on its own
191 minIntAsBig :: Integer
192 minIntAsBig = case int2Integer# INT_MINBOUND of { (# s, d #) -> J# s d }
193
194 -- | Promote 'S#' to 'J#'
195 toBig :: Integer -> Integer
196 toBig (S# i)     = case int2Integer# i of { (# s, d #) -> J# s d }
197 toBig i@(J# _ _) = i
198
199 -- | Demote 'J#' to 'S#' if possible. See also 'smartJ#'.
200 toSmall :: Integer -> Integer
201 toSmall i@(S# _)    = i
202 toSmall (J# s# mb#) = smartJ# s# mb#
203
204
205 -- | Smart 'J#' constructor which tries to construct 'S#' if possible
206 smartJ# :: Int# -> ByteArray# -> Integer
207 smartJ# 0# _ = S# 0#
208 smartJ# 1# mb#  | isTrue# (v ># 0#) = S# v
209     where
210       v = indexIntArray# mb# 0#
211 smartJ# (-1#) mb# | isTrue# (v <# 0#) = S# v
212     where
213       v = negateInt# (indexIntArray# mb# 0#)
214 smartJ# s# mb# = J# s# mb#
215
216 -- |Construct 'Integer' out of a 'MPZ#' as returned by GMP wrapper primops
217 --
218 -- IMPORTANT: The 'ByteArray#' element MUST NOT be accessed unless the
219 -- size-element indicates more than one limb!
220 --
221 -- See notes at definition site of 'MPZ#' in "GHC.Integer.GMP.Prim"
222 -- for more details.
223 mpzToInteger :: MPZ# -> Integer
224 mpzToInteger (# 0#, _, _ #) = S# 0#
225 mpzToInteger (# 1#, _, w# #) | isTrue# (v# >=# 0#) = S# v#
226                              | True = case word2Integer# w# of (# _, d #) -> J# 1# d
227     where
228       v# = word2Int# w#
229 mpzToInteger (# -1#, _, w# #) | isTrue# (v# <=# 0#) = S# v#
230                               | True = case word2Integer# w# of (# _, d #) -> J# -1# d
231     where
232       v# = negateInt# (word2Int# w#)
233 mpzToInteger (# s#, mb#, _ #) = J# s# mb#
234
235 -- | Variant of 'mpzToInteger' for pairs of 'Integer's
236 mpzToInteger2 :: (# MPZ#, MPZ# #) -> (# Integer, Integer #)
237 mpzToInteger2 (# mpz1, mpz2 #) = (# i1, i2 #)
238     where
239       !i1 = mpzToInteger mpz1 -- This use of `!` avoids creating thunks,
240       !i2 = mpzToInteger mpz2 -- see also Note [Use S# if possible].
241
242 -- |Negate MPZ#
243 mpzNeg :: MPZ# -> MPZ#
244 mpzNeg (# s#, mb#, w# #) = (# negateInt# s#, mb#, w# #)
245
246 \end{code}
247
248 Note [Use S# if possible]
249 ~~~~~~~~~~~~~~~~~~~~~~~~~
250 It's a big win to use S#, rather than J#, whenever possible.  Not only
251 does it take less space, but (probably more important) subsequent
252 operations are more efficient. See Trac #8638.
253
254 'smartJ#' is the smart constructor for J# that performs the necessary
255 tests.  When returning a nested result, we always use smartJ# strictly,
256 thus
257        let !r = smartJ# a b in (# r, somthing_else #)
258 to avoid creating a thunk that is subsequently evaluated to a J#.
259 smartJ# itself does a pretty small amount of work, so it's not worth
260 thunking it.
261
262 We call 'smartJ#' in places like quotRemInteger where a big input
263 might produce a small output.
264
265 Just using smartJ# in this way has good results:
266
267         Program           Size    Allocs   Runtime   Elapsed  TotalMem
268 --------------------------------------------------------------------------------
269          gamteb          +0.1%    -19.0%      0.03      0.03     +0.0%
270           kahan          +0.2%     -1.2%      0.17      0.17     +0.0%
271          mandel          +0.1%     -7.7%      0.05      0.05     +0.0%
272           power          +0.1%    -40.8%    -32.5%    -32.5%     +0.0%
273          symalg          +0.2%     -0.5%      0.01      0.01     +0.0%
274 --------------------------------------------------------------------------------
275             Min          +0.0%    -40.8%    -32.5%    -32.5%     -5.1%
276             Max          +0.2%     +0.1%     +2.0%     +2.0%     +0.0%
277  Geometric Mean          +0.1%     -1.0%     -2.5%     -2.5%     -0.1%
278
279 %*********************************************************
280 %*                                                      *
281 \subsection{Dividing @Integers@}
282 %*                                                      *
283 %*********************************************************
284
285 \begin{code}
286 -- XXX There's no good reason for us using unboxed tuples for the
287 -- results, but we don't have Data.Tuple available.
288
289 -- Note that we don't check for divide-by-zero here. That needs
290 -- to be done where it's used.
291 -- (we don't have error)
292
293 {-# NOINLINE quotRemInteger #-}
294 quotRemInteger :: Integer -> Integer -> (# Integer, Integer #)
295 quotRemInteger (S# INT_MINBOUND) b = quotRemInteger minIntAsBig b
296 quotRemInteger (S# i) (S# j) = case quotRemInt# i j of
297                                    (# q, r #) -> (# S# q, S# r #)
298 #if SIZEOF_HSWORD == SIZEOF_LONG
299 quotRemInteger (J# s1 d1) (S# b) | isTrue# (b <# 0#)
300   = case quotRemIntegerWord# s1 d1 (int2Word# (negateInt# b)) of
301           (# q, r #) -> let !q' = mpzToInteger (mpzNeg q)
302                             !r' = mpzToInteger r
303                         in (# q', r' #) -- see also Trac #8726
304 quotRemInteger (J# s1 d1) (S# b)
305   = mpzToInteger2 (quotRemIntegerWord# s1 d1 (int2Word# b))
306 #else
307 quotRemInteger i1@(J# _ _) i2@(S# _) = quotRemInteger i1 (toBig i2)
308 #endif
309 quotRemInteger i1@(S# _) i2@(J# _ _) = quotRemInteger (toBig i1) i2
310 quotRemInteger (J# s1 d1) (J# s2 d2)
311   = mpzToInteger2(quotRemInteger# s1 d1 s2 d2) -- See Note [Use S# if possible]
312
313 {-# NOINLINE divModInteger #-}
314 divModInteger :: Integer -> Integer -> (# Integer, Integer #)
315 divModInteger (S# INT_MINBOUND) b = divModInteger minIntAsBig b
316 divModInteger (S# i) (S# j) = (# S# d, S# m #)
317     where
318       -- NB. don't inline these.  (# S# (i `quotInt#` j), ... #) means
319       -- (# let q = i `quotInt#` j in S# q, ... #) which builds a
320       -- useless thunk.  Placing the bindings here means they'll be
321       -- evaluated strictly.
322       !d = i `divInt#` j
323       !m = i `modInt#` j
324 #if SIZEOF_HSWORD == SIZEOF_LONG
325 divModInteger (J# s1 d1) (S# b) | isTrue# (b <# 0#)
326   = case divModIntegerWord# (negateInt# s1) d1 (int2Word# (negateInt# b)) of
327           (# q, r #) -> let !q' = mpzToInteger q
328                             !r' = mpzToInteger (mpzNeg r)
329                         in (# q', r' #) -- see also Trac #8726
330 divModInteger (J# s1 d1) (S# b)
331   = mpzToInteger2(divModIntegerWord# s1 d1 (int2Word# b))
332 #else
333 divModInteger i1@(J# _ _) i2@(S# _) = divModInteger i1 (toBig i2)
334 #endif
335 divModInteger i1@(S# _) i2@(J# _ _) = divModInteger (toBig i1) i2
336 divModInteger (J# s1 d1) (J# s2 d2) = mpzToInteger2 (divModInteger# s1 d1 s2 d2)
337
338 {-# NOINLINE remInteger #-}
339 remInteger :: Integer -> Integer -> Integer
340 remInteger (S# INT_MINBOUND) b = remInteger minIntAsBig b
341 remInteger (S# a) (S# b) = S# (remInt# a b)
342 {- Special case doesn't work, because a 1-element J# has the range
343    -(2^32-1) -- 2^32-1, whereas S# has the range -2^31 -- (2^31-1)
344 remInteger ia@(S# a) (J# sb b)
345   | sb ==# 1#  = S# (remInt# a (word2Int# (integer2Word# sb b)))
346   | sb ==# -1# = S# (remInt# a (0# -# (word2Int# (integer2Word# sb b))))
347   | 0# <# sb   = ia
348   | otherwise  = S# (0# -# a)
349 -}
350 remInteger ia@(S# _) ib@(J# _ _) = remInteger (toBig ia) ib
351 #if SIZEOF_HSWORD == SIZEOF_LONG
352 remInteger (J# sa a) (S# b)
353   = mpzToInteger (remIntegerWord# sa a w)
354   where
355     w = int2Word# (if isTrue# (b <# 0#) then negateInt# b else b)
356 #else
357 remInteger i1@(J# _ _) i2@(S# _) = remInteger i1 (toBig i2)
358 #endif
359 remInteger (J# sa a) (J# sb b)
360   = mpzToInteger (remInteger# sa a sb b)
361
362 {-# NOINLINE quotInteger #-}
363 quotInteger :: Integer -> Integer -> Integer
364 quotInteger (S# INT_MINBOUND) b = quotInteger minIntAsBig b
365 quotInteger (S# a) (S# b) = S# (quotInt# a b)
366 {- Special case disabled, see remInteger above
367 quotInteger (S# a) (J# sb b)
368   | sb ==# 1#  = S# (quotInt# a (word2Int# (integer2Word# sb b)))
369   | sb ==# -1# = S# (quotInt# a (0# -# (word2Int# (integer2Word# sb b))))
370   | otherwise  = S# 0
371 -}
372 quotInteger ia@(S# _) ib@(J# _ _) = quotInteger (toBig ia) ib
373 #if SIZEOF_HSWORD == SIZEOF_LONG
374 quotInteger (J# sa a) (S# b) | isTrue# (b <# 0#)
375   = mpzToInteger (mpzNeg (quotIntegerWord# sa a (int2Word# (negateInt# b))))
376 quotInteger (J# sa a) (S# b)
377   = mpzToInteger (quotIntegerWord# sa a (int2Word# b))
378 #else
379 quotInteger i1@(J# _ _) i2@(S# _) = quotInteger i1 (toBig i2)
380 #endif
381 quotInteger (J# sa a) (J# sb b)
382   = mpzToInteger (quotInteger# sa a sb b)
383
384 {-# NOINLINE modInteger #-}
385 modInteger :: Integer -> Integer -> Integer
386 modInteger (S# INT_MINBOUND) b = modInteger minIntAsBig b
387 modInteger (S# a) (S# b) = S# (modInt# a b)
388 modInteger ia@(S# _) ib@(J# _ _) = modInteger (toBig ia) ib
389 #if SIZEOF_HSWORD == SIZEOF_LONG
390 modInteger (J# sa a) (S# b) | isTrue# (b <# 0#)
391   = mpzToInteger (mpzNeg (modIntegerWord# (negateInt# sa) a (int2Word# (negateInt# b))))
392 modInteger (J# sa a) (S# b)
393   = mpzToInteger (modIntegerWord# sa a (int2Word# b))
394 #else
395 modInteger i1@(J# _ _) i2@(S# _) = modInteger i1 (toBig i2)
396 #endif
397 modInteger (J# sa a) (J# sb b)
398   = mpzToInteger (modInteger# sa a sb b)
399
400 {-# NOINLINE divInteger #-}
401 divInteger :: Integer -> Integer -> Integer
402 divInteger (S# INT_MINBOUND) b = divInteger minIntAsBig b
403 divInteger (S# a) (S# b) = S# (divInt# a b)
404 divInteger ia@(S# _) ib@(J# _ _) = divInteger (toBig ia) ib
405 #if SIZEOF_HSWORD == SIZEOF_LONG
406 divInteger (J# sa a) (S# b) | isTrue# (b <# 0#)
407   = mpzToInteger (divIntegerWord# (negateInt# sa) a (int2Word# (negateInt# b)))
408 divInteger (J# sa a) (S# b)
409   = mpzToInteger (divIntegerWord# sa a (int2Word# b))
410 #else
411 divInteger i1@(J# _ _) i2@(S# _) = divInteger i1 (toBig i2)
412 #endif
413 divInteger (J# sa a) (J# sb b)
414   = mpzToInteger (divInteger# sa a sb b)
415 \end{code}
416
417
418
419 \begin{code}
420 -- | Compute greatest common divisor.
421 {-# NOINLINE gcdInteger #-}
422 gcdInteger :: Integer -> Integer -> Integer
423 -- SUP: Do we really need the first two cases?
424 gcdInteger (S# INT_MINBOUND) b = gcdInteger minIntAsBig b
425 gcdInteger a (S# INT_MINBOUND) = gcdInteger a minIntAsBig
426 gcdInteger (S# a) (S# b) = S# (gcdInt a b)
427 gcdInteger ia@(S# a)  ib@(J# sb b)
428  =      if isTrue# (a  ==# 0#) then absInteger ib
429    else if isTrue# (sb ==# 0#) then absInteger ia
430    else                             S# (gcdIntegerInt# absSb b absA)
431        where !absA  = if isTrue# (a  <# 0#) then negateInt# a  else a
432              !absSb = if isTrue# (sb <# 0#) then negateInt# sb else sb
433 gcdInteger ia@(J# _ _) ib@(S# _) = gcdInteger ib ia
434 gcdInteger (J# sa a) (J# sb b)   = mpzToInteger (gcdInteger# sa a sb b)
435
436 -- | Extended euclidean algorithm.
437 --
438 -- For @/a/@ and @/b/@, compute their greatest common divisor @/g/@
439 -- and the coefficient @/s/@ satisfying @/a//s/ + /b//t/ = /g/@.
440 --
441 -- /Since: 0.5.1.0/
442 {-# NOINLINE gcdExtInteger #-}
443 gcdExtInteger :: Integer -> Integer -> (# Integer, Integer #)
444 gcdExtInteger a@(S# _)   b@(S# _) = gcdExtInteger (toBig a) (toBig b)
445 gcdExtInteger a@(S# _) b@(J# _ _) = gcdExtInteger (toBig a) b
446 gcdExtInteger a@(J# _ _) b@(S# _) = gcdExtInteger a (toBig b)
447 gcdExtInteger (J# sa a) (J# sb b) = mpzToInteger2 (gcdExtInteger# sa a sb b)
448
449 -- | Compute least common multiple.
450 {-# NOINLINE lcmInteger #-}
451 lcmInteger :: Integer -> Integer -> Integer
452 lcmInteger a b =      if a `eqInteger` S# 0# then S# 0#
453                  else if b `eqInteger` S# 0# then S# 0#
454                  else (divExact aa (gcdInteger aa ab)) `timesInteger` ab
455   where aa = absInteger a
456         ab = absInteger b
457
458 -- | Compute greatest common divisor.
459 gcdInt :: Int# -> Int# -> Int#
460 gcdInt 0# y  = absInt y
461 gcdInt x  0# = absInt x
462 gcdInt x  y  = gcdInt# (absInt x) (absInt y)
463
464 absInt :: Int# -> Int#
465 absInt x = if isTrue# (x <# 0#) then negateInt# x else x
466
467 divExact :: Integer -> Integer -> Integer
468 divExact (S# INT_MINBOUND) b = divExact minIntAsBig b
469 divExact (S# a) (S# b) = S# (quotInt# a b)
470 divExact (S# a) (J# sb b)
471   = S# (quotInt# a (integer2Int# sb b))
472 #if SIZEOF_HSWORD == SIZEOF_LONG
473 divExact (J# sa a) (S# b) | isTrue# (b <# 0#)
474   = mpzToInteger (divExactIntegerWord# (negateInt# sa) a (int2Word# (negateInt# b)))
475 divExact (J# sa a) (S# b) = mpzToInteger (divExactIntegerWord# sa a (int2Word# b))
476 #else
477 divExact i1@(J# _ _) i2@(S# _) = divExact i1 (toBig i2)
478 #endif
479 divExact (J# sa a) (J# sb b) = mpzToInteger (divExactInteger# sa a sb b)
480 \end{code}
481
482
483 %*********************************************************
484 %*                                                      *
485 \subsection{The @Integer@ instances for @Eq@, @Ord@}
486 %*                                                      *
487 %*********************************************************
488
489 \begin{code}
490
491 -- | /Since: 0.5.1.0/
492 {-# NOINLINE eqInteger# #-}
493 eqInteger# :: Integer -> Integer -> Int#
494 eqInteger# (S# i)     (S# j)     = i ==# j
495 eqInteger# (S# i)     (J# s d)   = cmpIntegerInt# s d i ==# 0#
496 eqInteger# (J# s d)   (S# i)     = cmpIntegerInt# s d i ==# 0#
497 eqInteger# (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ==# 0#
498
499 -- | /Since: 0.5.1.0/
500 {-# NOINLINE neqInteger# #-}
501 neqInteger# :: Integer -> Integer -> Int#
502 neqInteger# (S# i)     (S# j)     = i /=# j
503 neqInteger# (S# i)     (J# s d)   = cmpIntegerInt# s d i /=# 0#
504 neqInteger# (J# s d)   (S# i)     = cmpIntegerInt# s d i /=# 0#
505 neqInteger# (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) /=# 0#
506
507 {-# INLINE eqInteger  #-}
508 {-# INLINE neqInteger #-}
509 eqInteger, neqInteger :: Integer -> Integer -> Bool
510 eqInteger  a b = isTrue# (a `eqInteger#`  b)
511 neqInteger a b = isTrue# (a `neqInteger#` b)
512
513 instance  Eq Integer  where
514     (==) = eqInteger
515     (/=) = neqInteger
516
517 ------------------------------------------------------------------------
518
519 -- | /Since: 0.5.1.0/
520 {-# NOINLINE leInteger# #-}
521 leInteger# :: Integer -> Integer -> Int#
522 leInteger# (S# i)     (S# j)     = i <=# j
523 leInteger# (J# s d)   (S# i)     = cmpIntegerInt# s d i <=# 0#
524 leInteger# (S# i)     (J# s d)   = cmpIntegerInt# s d i >=# 0#
525 leInteger# (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <=# 0#
526
527 -- | /Since: 0.5.1.0/
528 {-# NOINLINE gtInteger# #-}
529 gtInteger# :: Integer -> Integer -> Int#
530 gtInteger# (S# i)     (S# j)     = i ># j
531 gtInteger# (J# s d)   (S# i)     = cmpIntegerInt# s d i ># 0#
532 gtInteger# (S# i)     (J# s d)   = cmpIntegerInt# s d i <# 0#
533 gtInteger# (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) ># 0#
534
535 -- | /Since: 0.5.1.0/
536 {-# NOINLINE ltInteger# #-}
537 ltInteger# :: Integer -> Integer -> Int#
538 ltInteger# (S# i)     (S# j)     = i <# j
539 ltInteger# (J# s d)   (S# i)     = cmpIntegerInt# s d i <# 0#
540 ltInteger# (S# i)     (J# s d)   = cmpIntegerInt# s d i ># 0#
541 ltInteger# (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) <# 0#
542
543 -- | /Since: 0.5.1.0/
544 {-# NOINLINE geInteger# #-}
545 geInteger# :: Integer -> Integer -> Int#
546 geInteger# (S# i)     (S# j)     = i >=# j
547 geInteger# (J# s d)   (S# i)     = cmpIntegerInt# s d i >=# 0#
548 geInteger# (S# i)     (J# s d)   = cmpIntegerInt# s d i <=# 0#
549 geInteger# (J# s1 d1) (J# s2 d2) = (cmpInteger# s1 d1 s2 d2) >=# 0#
550
551 {-# INLINE leInteger #-}
552 {-# INLINE ltInteger #-}
553 {-# INLINE geInteger #-}
554 {-# INLINE gtInteger #-}
555 leInteger, gtInteger, ltInteger, geInteger :: Integer -> Integer -> Bool
556 leInteger a b = isTrue# (a `leInteger#` b)
557 gtInteger a b = isTrue# (a `gtInteger#` b)
558 ltInteger a b = isTrue# (a `ltInteger#` b)
559 geInteger a b = isTrue# (a `geInteger#` b)
560
561 {-# NOINLINE compareInteger #-}
562 compareInteger :: Integer -> Integer -> Ordering
563 compareInteger (S# i)  (S# j)
564    =      if isTrue# (i ==# j) then EQ
565      else if isTrue# (i <=# j) then LT
566      else                           GT
567 compareInteger (J# s d) (S# i)
568    = case cmpIntegerInt# s d i of { res# ->
569      if isTrue# (res# <# 0#) then LT else
570      if isTrue# (res# ># 0#) then GT else EQ
571      }
572 compareInteger (S# i) (J# s d)
573    = case cmpIntegerInt# s d i of { res# ->
574      if isTrue# (res# ># 0#) then LT else
575      if isTrue# (res# <# 0#) then GT else EQ
576      }
577 compareInteger (J# s1 d1) (J# s2 d2)
578    = case cmpInteger# s1 d1 s2 d2 of { res# ->
579      if isTrue# (res# <# 0#) then LT else
580      if isTrue# (res# ># 0#) then GT else EQ
581      }
582
583 instance Ord Integer where
584     (<=) = leInteger
585     (<)  = ltInteger
586     (>)  = gtInteger
587     (>=) = geInteger
588     compare = compareInteger
589 \end{code}
590
591
592 %*********************************************************
593 %*                                                      *
594 \subsection{The @Integer@ instances for @Num@}
595 %*                                                      *
596 %*********************************************************
597
598 \begin{code}
599 {-# NOINLINE absInteger #-}
600 absInteger :: Integer -> Integer
601 absInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
602 absInteger n@(S# i)   = if isTrue# (i >=# 0#) then n else S# (negateInt# i)
603 absInteger n@(J# s d) = if isTrue# (s >=# 0#) then n else J# (negateInt# s) d
604
605 {-# NOINLINE signumInteger #-}
606 signumInteger :: Integer -> Integer
607 signumInteger (S# i) = if isTrue# (i <# 0#) then S# -1#
608                        else if isTrue# (i ==# 0#) then S# 0#
609                        else S# 1#
610 signumInteger (J# s d)
611   = let
612         !cmp = cmpIntegerInt# s d 0#
613     in
614     if      isTrue# (cmp >#  0#) then S# 1#
615     else if isTrue# (cmp ==# 0#) then S# 0#
616     else                              S# (negateInt# 1#)
617
618 {-# NOINLINE plusInteger #-}
619 plusInteger :: Integer -> Integer -> Integer
620 plusInteger (S# i)      (S# j)   = case addIntC# i j of
621                                    (# r, c #) ->
622                                        if isTrue# (c ==# 0#)
623                                        then S# r
624 #if SIZEOF_HSWORD == SIZEOF_LONG
625                                        else case int2Integer# i of
626                                             (# s, d #) -> mpzToInteger (plusIntegerInt# s d j)
627 #else
628                                        else plusInteger (toBig (S# i)) (toBig (S# j))
629 #endif
630 plusInteger i1@(J# _ _) (S# 0#)   = i1
631 #if SIZEOF_HSWORD == SIZEOF_LONG
632 plusInteger (J# s1 d1)  (S# j)    = mpzToInteger (plusIntegerInt# s1 d1 j)
633 #else
634 plusInteger i1@(J# _ _) i2@(S# _) = plusInteger i1 (toBig i2)
635 #endif
636 plusInteger i1@(S# _) i2@(J# _ _) = plusInteger i2 i1
637 plusInteger (J# s1 d1) (J# s2 d2) = mpzToInteger (plusInteger# s1 d1 s2 d2)
638
639 {-# NOINLINE minusInteger #-}
640 minusInteger :: Integer -> Integer -> Integer
641 minusInteger (S# i)      (S# j)    = case subIntC# i j of
642                                      (# r, c #) ->
643                                          if isTrue# (c ==# 0#) then S# r
644 #if SIZEOF_HSWORD == SIZEOF_LONG
645                                          else case int2Integer# i of
646                                               (# s, d #) -> mpzToInteger (minusIntegerInt# s d j)
647 #else
648                                          else minusInteger (toBig (S# i)) (toBig (S# j))
649 #endif
650 minusInteger i1@(J# _ _) (S# 0#)   = i1
651 minusInteger (S# 0#)    (J# s2 d2) = J# (negateInt# s2) d2
652 #if SIZEOF_HSWORD == SIZEOF_LONG
653 minusInteger (J# s1 d1)  (S# j)    = mpzToInteger (minusIntegerInt# s1 d1 j)
654 minusInteger (S# i)     (J# s2 d2) = mpzToInteger (plusIntegerInt# (negateInt# s2) d2 i)
655 #else
656 minusInteger i1@(J# _ _) i2@(S# _) = minusInteger i1 (toBig i2)
657 minusInteger i1@(S# _) i2@(J# _ _) = minusInteger (toBig i1) i2
658 #endif
659 minusInteger (J# s1 d1) (J# s2 d2) = mpzToInteger (minusInteger# s1 d1 s2 d2)
660
661 {-# NOINLINE timesInteger #-}
662 timesInteger :: Integer -> Integer -> Integer
663 timesInteger (S# i) (S# j)         = if isTrue# (mulIntMayOflo# i j ==# 0#)
664                                      then S# (i *# j)
665 #if SIZEOF_HSWORD == SIZEOF_LONG
666                                      else case int2Integer# i of
667                                           (# s, d #) -> mpzToInteger (timesIntegerInt# s d j)
668 #else
669                                      else timesInteger (toBig (S# i)) (toBig (S# j))
670 #endif
671 timesInteger (S# 0#)     _         = S# 0#
672 timesInteger (S# -1#)    i2        = negateInteger i2
673 timesInteger (S# 1#)     i2        = i2
674 #if SIZEOF_HSWORD == SIZEOF_LONG
675 timesInteger (S# i1)    (J# s2 d2) = mpzToInteger (timesIntegerInt# s2 d2 i1)
676 #else
677 timesInteger i1@(S# _) i2@(J# _ _) = timesInteger (toBig i1) i2
678 #endif
679 timesInteger i1@(J# _ _) i2@(S# _) = timesInteger i2 i1 -- swap args & retry
680 timesInteger (J# s1 d1) (J# s2 d2) = mpzToInteger (timesInteger# s1 d1 s2 d2)
681
682 {-# NOINLINE negateInteger #-}
683 negateInteger :: Integer -> Integer
684 negateInteger (S# INT_MINBOUND) = NEG_INT_MINBOUND
685 negateInteger (S# i)            = S# (negateInt# i)
686 negateInteger (J# s d)          = J# (negateInt# s) d
687 \end{code}
688
689
690 %*********************************************************
691 %*                                                      *
692 \subsection{The @Integer@ stuff for Double@}
693 %*                                                      *
694 %*********************************************************
695
696 \begin{code}
697 {-# NOINLINE encodeFloatInteger #-}
698 encodeFloatInteger :: Integer -> Int# -> Float#
699 encodeFloatInteger (S# i) j     = int_encodeFloat# i j
700 encodeFloatInteger (J# s# d#) e = encodeFloat# s# d# e
701
702 {-# NOINLINE encodeDoubleInteger #-}
703 encodeDoubleInteger :: Integer -> Int# -> Double#
704 encodeDoubleInteger (S# i) j     = int_encodeDouble# i j
705 encodeDoubleInteger (J# s# d#) e = encodeDouble# s# d# e
706
707 {-# NOINLINE decodeDoubleInteger #-}
708 decodeDoubleInteger :: Double# -> (# Integer, Int# #)
709 decodeDoubleInteger d = case decodeDouble# d of
710                         (# exp#, man# #) -> let !man = mpzToInteger man#
711                                             in (# man, exp# #)
712
713 -- previous code: doubleFromInteger n = fromInteger n = encodeFloat n 0
714 -- doesn't work too well, because encodeFloat is defined in
715 -- terms of ccalls which can never be simplified away.  We
716 -- want simple literals like (fromInteger 3 :: Float) to turn
717 -- into (F# 3.0), hence the special case for S# here.
718
719 {-# NOINLINE doubleFromInteger #-}
720 doubleFromInteger :: Integer -> Double#
721 doubleFromInteger (S# i#) = int2Double# i#
722 doubleFromInteger (J# s# d#) = encodeDouble# s# d# 0#
723
724 {-# NOINLINE floatFromInteger #-}
725 floatFromInteger :: Integer -> Float#
726 floatFromInteger (S# i#) = int2Float# i#
727 floatFromInteger (J# s# d#) = encodeFloat# s# d# 0#
728
729 foreign import ccall unsafe "integer_cbits_encodeFloat"
730         encodeFloat# :: Int# -> ByteArray# -> Int# -> Float#
731 foreign import ccall unsafe "__int_encodeFloat"
732         int_encodeFloat# :: Int# -> Int# -> Float#
733
734 foreign import ccall unsafe "integer_cbits_encodeDouble"
735         encodeDouble# :: Int# -> ByteArray# -> Int# -> Double#
736 foreign import ccall unsafe "__int_encodeDouble"
737         int_encodeDouble# :: Int# -> Int# -> Double#
738 \end{code}
739
740 %*********************************************************
741 %*                                                      *
742 \subsection{The @Integer@ Bit definitions@}
743 %*                                                      *
744 %*********************************************************
745
746 We explicitly pattern match against J# and S# in order to produce
747 Core that doesn't have pattern matching errors, as that would
748 introduce a spurious dependency to base.
749
750 \begin{code}
751 {-# NOINLINE andInteger #-}
752 andInteger :: Integer -> Integer -> Integer
753 (S# x)     `andInteger`   (S# y)     = S# (word2Int# (int2Word# x `and#` int2Word# y))
754 x@(S# _)   `andInteger` y@(J# _ _)   = toBig x `andInteger` y
755 x@(J# _ _) `andInteger` y@(S# _)     = x `andInteger` toBig y
756 (J# s1 d1) `andInteger`   (J# s2 d2) =
757      mpzToInteger (andInteger# s1 d1 s2 d2)
758
759 {-# NOINLINE orInteger #-}
760 orInteger :: Integer -> Integer -> Integer
761 (S# x)     `orInteger`   (S# y)     = S# (word2Int# (int2Word# x `or#` int2Word# y))
762 x@(S# _)   `orInteger` y@(J# _ _)   = toBig x `orInteger` y
763 x@(J# _ _) `orInteger` y@(S# _)     = x `orInteger` toBig y
764 (J# s1 d1) `orInteger`   (J# s2 d2) =
765      mpzToInteger (orInteger# s1 d1 s2 d2)
766
767 {-# NOINLINE xorInteger #-}
768 xorInteger :: Integer -> Integer -> Integer
769 (S# x)     `xorInteger`   (S# y)     = S# (word2Int# (int2Word# x `xor#` int2Word# y))
770 x@(S# _)   `xorInteger` y@(J# _ _)   = toBig x `xorInteger` y
771 x@(J# _ _) `xorInteger` y@(S# _)     = x `xorInteger` toBig y
772 (J# s1 d1) `xorInteger`   (J# s2 d2) =
773      mpzToInteger (xorInteger# s1 d1 s2 d2)
774
775 {-# NOINLINE complementInteger #-}
776 complementInteger :: Integer -> Integer
777 complementInteger (S# x)
778     = S# (word2Int# (int2Word# x `xor#` int2Word# (0# -# 1#)))
779 complementInteger (J# s d)
780     = mpzToInteger (complementInteger# s d)
781
782 {-# NOINLINE shiftLInteger #-}
783 shiftLInteger :: Integer -> Int# -> Integer
784 shiftLInteger j@(S# _) i = shiftLInteger (toBig j) i
785 shiftLInteger (J# s d) i = mpzToInteger (mul2ExpInteger# s d i)
786
787 {-# NOINLINE shiftRInteger #-}
788 shiftRInteger :: Integer -> Int# -> Integer
789 shiftRInteger j@(S# _) i = shiftRInteger (toBig j) i
790 shiftRInteger (J# s d) i = mpzToInteger (fdivQ2ExpInteger# s d i)
791
792 -- | /Since: 0.5.1.0/
793 {-# NOINLINE testBitInteger #-}
794 testBitInteger :: Integer -> Int# -> Bool
795 testBitInteger j@(S# _) i = testBitInteger (toBig j) i
796 testBitInteger (J# s d) i = isTrue# (testBitInteger# s d i /=# 0#)
797
798 -- | \"@'powInteger' /b/ /e/@\" computes base @/b/@ raised to exponent @/e/@.
799 --
800 -- /Since: 0.5.1.0/
801 {-# NOINLINE powInteger #-}
802 powInteger :: Integer -> Word# -> Integer
803 powInteger j@(S# _) e = powInteger (toBig j) e
804 powInteger (J# s d) e = mpzToInteger (powInteger# s d e)
805
806 -- | \"@'powModInteger' /b/ /e/ /m/@\" computes base @/b/@ raised to
807 -- exponent @/e/@ modulo @/m/@.
808 --
809 -- Negative exponents are supported if an inverse modulo @/m/@
810 -- exists. It's advised to avoid calling this primitive with negative
811 -- exponents unless it is guaranteed the inverse exists, as failure to
812 -- do so will likely cause program abortion due to a divide-by-zero
813 -- fault. See also 'recipModInteger'.
814 --
815 -- /Since: 0.5.1.0/
816 {-# NOINLINE powModInteger #-}
817 powModInteger :: Integer -> Integer -> Integer -> Integer
818 powModInteger (J# s1 d1) (J# s2 d2) (J# s3 d3) =
819     mpzToInteger (powModInteger# s1 d1 s2 d2 s3 d3)
820 powModInteger b e m = powModInteger (toBig b) (toBig e) (toBig m)
821
822 -- | \"@'powModSecInteger' /b/ /e/ /m/@\" computes base @/b/@ raised to
823 -- exponent @/e/@ modulo @/m/@. It is required that @/e/ > 0@ and
824 -- @/m/@ is odd.
825 --
826 -- This is a \"secure\" variant of 'powModInteger' using the
827 -- @mpz_powm_sec()@ function which is designed to be resilient to side
828 -- channel attacks and is therefore intended for cryptographic
829 -- applications.
830 --
831 -- This primitive is only available when the underlying GMP library
832 -- supports it (GMP >= 5). Otherwise, it internally falls back to
833 -- @'powModInteger'@, and a warning will be emitted when used.
834 --
835 -- /Since: 0.5.1.0/
836 {-# NOINLINE powModSecInteger #-}
837 powModSecInteger :: Integer -> Integer -> Integer -> Integer
838 powModSecInteger (J# s1 d1) (J# s2 d2) (J# s3 d3) =
839     mpzToInteger (powModSecInteger# s1 d1 s2 d2 s3 d3)
840 powModSecInteger b e m = powModSecInteger (toBig b) (toBig e) (toBig m)
841
842 #if HAVE_SECURE_POWM == 0
843 {-# WARNING powModSecInteger "The underlying GMP library does not support a secure version of powModInteger which is side-channel resistant - you need at least GMP version 5 to support this" #-}
844 #endif
845
846 -- | \"@'recipModInteger' /x/ /m/@\" computes the inverse of @/x/@ modulo @/m/@. If
847 -- the inverse exists, the return value @/y/@ will satisfy @0 < /y/ <
848 -- abs(/m/)@, otherwise the result is @0@.
849 --
850 -- Note: The implementation exploits the undocumented property of
851 -- @mpz_invert()@ to not mangle the result operand (which is initialized
852 -- to 0) in case of non-existence of the inverse.
853 --
854 -- /Since: 0.5.1.0/
855 {-# NOINLINE recipModInteger #-}
856 recipModInteger :: Integer -> Integer -> Integer
857 recipModInteger j@(S# _) m@(S# _)   = recipModInteger (toBig j) (toBig m)
858 recipModInteger j@(S# _) m@(J# _ _) = recipModInteger (toBig j) m
859 recipModInteger j@(J# _ _) m@(S# _) = recipModInteger j (toBig m)
860 recipModInteger (J# s d) (J# ms md) = mpzToInteger (recipModInteger# s d ms md)
861
862 -- | Probalistic Miller-Rabin primality test.
863 --
864 -- \"@'testPrimeInteger' /n/ /k/@\" determines whether @/n/@ is prime
865 -- and returns one of the following results:
866 --
867 -- * @2#@ is returned if @/n/@ is definitely prime,
868 --
869 -- * @1#@ if @/n/@ is a /probable prime/, or
870 --
871 -- * @0#@ if @/n/@ is definitely not a prime.
872 --
873 -- The @/k/@ argument controls how many test rounds are performed for
874 -- determining a /probable prime/. For more details, see
875 -- <http://gmplib.org/manual/Number-Theoretic-Functions.html#index-mpz_005fprobab_005fprime_005fp-360 GMP documentation for `mpz_probab_prime_p()`>.
876 --
877 -- /Since: 0.5.1.0/
878 {-# NOINLINE testPrimeInteger #-}
879 testPrimeInteger :: Integer -> Int# -> Int#
880 testPrimeInteger j@(S# _) reps = testPrimeInteger (toBig j) reps
881 testPrimeInteger (J# s d) reps = testPrimeInteger# s d reps
882
883 -- | Compute next prime greater than @/n/@ probalistically.
884 --
885 -- According to the GMP documentation, the underlying function
886 -- @mpz_nextprime()@ \"uses a probabilistic algorithm to identify
887 -- primes. For practical purposes it's adequate, the chance of a
888 -- composite passing will be extremely small.\"
889 --
890 -- /Since: 0.5.1.0/
891 {-# NOINLINE nextPrimeInteger #-}
892 nextPrimeInteger :: Integer -> Integer
893 nextPrimeInteger j@(S# _) = nextPrimeInteger (toBig j)
894 nextPrimeInteger (J# s d) = mpzToInteger (nextPrimeInteger# s d)
895
896 -- | Compute number of digits (without sign) in given @/base/@.
897 --
898 -- It's recommended to avoid calling 'sizeInBaseInteger' for small
899 -- integers as this function would currently convert those to big
900 -- integers in order to call @mpz_sizeinbase()@.
901 --
902 -- This function wraps @mpz_sizeinbase()@ which has some
903 -- implementation pecularities to take into account:
904 --
905 -- * \"@'sizeInBaseInteger' 0 /base/ = 1@\" (see also comment in 'exportIntegerToMutableByteArray').
906 --
907 -- * This function is only defined if @/base/ >= 2#@ and @/base/ <= 256#@
908 --   (Note: the documentation claims that only @/base/ <= 62#@ is
909 --   supported, however the actual implementation supports up to base 256).
910 --
911 -- * If @/base/@ is a power of 2, the result will be exact. In other
912 --   cases (e.g. for @/base/ = 10#@), the result /may/ be 1 digit too large
913 --   sometimes.
914 --
915 -- * \"@'sizeInBaseInteger' /i/ 2#@\" can be used to determine the most
916 --   significant bit of @/i/@.
917 --
918 -- /Since: 0.5.1.0/
919 {-# NOINLINE sizeInBaseInteger #-}
920 sizeInBaseInteger :: Integer -> Int# -> Word#
921 sizeInBaseInteger (J# s d) b = sizeInBaseInteger# s d b
922 sizeInBaseInteger j@(S# _) b = sizeInBaseInteger (toBig j) b -- TODO
923
924 -- | Dump 'Integer' (without sign) to mutable byte-array in base-256 representation.
925 --
926 -- The call
927 --
928 -- @'exportIntegerToMutableByteArray' /i/ /mba/ /offset/ /order/@
929 --
930 -- writes
931 --
932 -- * the 'Integer' @/i/@
933 --
934 -- * into the 'MutableByteArray#' @/mba/@ starting at @/offset/@
935 --
936 -- * with most significant byte first if @order@ is @1#@ or least
937 --   significant byte first if @order@ is @-1#@, and
938 --
939 -- * returns number of bytes written.
940 --
941 -- Use \"@'sizeInBaseInteger' /i/ 256#@\" to compute the exact number of
942 -- bytes written in advance for @/i/ /= 0@. In case of @/i/ == 0@,
943 -- 'exportIntegerToMutableByteArray' will write and report zero bytes
944 -- written, whereas 'sizeInBaseInteger' report one byte.
945 --
946 -- It's recommended to avoid calling 'exportIntegerToMutableByteArray' for small
947 -- integers as this function would currently convert those to big
948 -- integers in order to call @mpz_export()@.
949 --
950 -- /Since: 0.5.1.0/
951 {-# NOINLINE exportIntegerToMutableByteArray #-}
952 exportIntegerToMutableByteArray :: Integer -> MutableByteArray# s -> Word# -> Int# -> State# s -> (# State# s, Word# #)
953 exportIntegerToMutableByteArray (J# s d) mba o e = exportIntegerToMutableByteArray# s d mba o e
954 exportIntegerToMutableByteArray j@(S# _) mba o e = exportIntegerToMutableByteArray (toBig j) mba o e -- TODO
955
956 -- | Dump 'Integer' (without sign) to @/addr/@ in base-256 representation.
957 --
958 -- @'exportIntegerToAddr' /addr/ /o/ /e/@
959 --
960 -- See description of 'exportIntegerToMutableByteArray' for more details.
961 --
962 -- /Since: 0.5.1.0/
963 {-# NOINLINE exportIntegerToAddr #-}
964 exportIntegerToAddr :: Integer -> Addr# -> Int# -> State# s -> (# State# s, Word# #)
965 exportIntegerToAddr (J# s d) addr o e = exportIntegerToAddr# s d addr o e
966 exportIntegerToAddr j@(S# _) addr o e = exportIntegerToAddr (toBig j) addr o e -- TODO
967
968 -- | Read 'Integer' (without sign) from byte-array in base-256 representation.
969 --
970 -- The call
971 --
972 -- @'importIntegerFromByteArray' /ba/ /offset/ /size/ /order/@
973 --
974 -- reads
975 --
976 -- * @/size/@ bytes from the 'ByteArray#' @/ba/@ starting at @/offset/@
977 --
978 -- * with most significant byte first if @/order/@ is @1#@ or least
979 --   significant byte first if @/order/@ is @-1#@, and
980 --
981 -- * returns a new 'Integer'
982 --
983 -- /Since: 0.5.1.0/
984 {-# NOINLINE importIntegerFromByteArray #-}
985 importIntegerFromByteArray :: ByteArray# -> Word# -> Word# -> Int# -> Integer
986 importIntegerFromByteArray ba o l e = mpzToInteger (importIntegerFromByteArray# ba o l e)
987
988 -- | Read 'Integer' (without sign) from memory location at @/addr/@ in
989 -- base-256 representation.
990 --
991 -- @'importIntegerFromAddr' /addr/ /size/ /order/@
992 --
993 -- See description of 'importIntegerFromByteArray' for more details.
994 --
995 -- /Since: 0.5.1.0/
996 {-# NOINLINE importIntegerFromAddr #-}
997 importIntegerFromAddr :: Addr# -> Word# -> Int# -> State# s -> (# State# s, Integer #)
998 importIntegerFromAddr addr l e st = case importIntegerFromAddr# addr l e st of
999                                       (# st', mpz #) -> let !j = mpzToInteger mpz in (# st', j #)
1000
1001 \end{code}
1002
1003 %*********************************************************
1004 %*                                                      *
1005 \subsection{The @Integer@ hashing@}
1006 %*                                                      *
1007 %*********************************************************
1008
1009 \begin{code}
1010 -- This is used by hashUnique
1011
1012 -- | 'hashInteger' returns the same value as 'fromIntegral', although in
1013 -- unboxed form.  It might be a reasonable hash function for 'Integer',
1014 -- given a suitable distribution of 'Integer' values.
1015 --
1016 -- Note: 'hashInteger' is currently just an alias for 'integerToInt'.
1017
1018 hashInteger :: Integer -> Int#
1019 hashInteger = integerToInt
1020 \end{code}
1021