GHC.Num.Integer · ghc-bignum-1.3

datadata Integer

Arbitrary precision integers. In contrast with fixed-size integral types such as Int, the Integer type represents the entire infinite range of integers.

Integers are stored in a kind of sign-magnitude form, hence do not expect two's complement form when using bit operations.

If the value is small (i.e., fits into an Int), the IS constructor is used. Otherwise IP and IN constructors are used to store a BigNat representing the positive or the negative value magnitude, respectively.

Invariant: IP and IN are used iff the value does not fit in IS.

Constructors

IS Int#
iff value in [minBound::Int, maxBound::Int] range
IP ByteArray#
iff value in ]maxBound::Int, +inf[ range
IN ByteArray#
iff value in ]-inf, minBound::Int[ range

Instances2Eq, Ord

Eq IntegerDefined in ghc-bignum-1.3 · GHC.Num.Integer
Ord IntegerDefined in ghc-bignum-1.3 · GHC.Num.Integer

valueintegerCheck :: Integer -> Bool

#

Check Integer invariants

valueintegerCheck# :: Integer -> Bool#

#

Check Integer invariants

Useful constants

2 declarations

valueintegerZero :: Integer

#

Integer Zero

valueintegerOne :: Integer

#

Integer One

Conversion with...

0 declarations

Int

valueintegerFromInt# :: Int# -> Integer

#

Create an Integer from an Int#

valueintegerFromInt :: Int -> Integer

#

Create an Integer from an Int

valueintegerToInt# :: Integer -> Int#

#

Truncates Integer to least-significant Int#

valueintegerToInt :: Integer -> Int

#

Truncates Integer to least-significant Int#

BigNat

valueintegerFromBigNat# :: BigNat# -> Integer

#

Create a positive Integer from a BigNat

valueintegerFromBigNatNeg# :: BigNat# -> Integer

#

Create a negative Integer from a BigNat

valueintegerFromBigNatSign# :: Int# -> BigNat# -> Integer

#

Create an Integer from a sign-bit and a BigNat

valueintegerToBigNatSign# :: Integer -> (# Int#, BigNat# #)

#

Convert an Integer into a sign-bit and a BigNat

valueintegerToBigNatClamp# :: Integer -> BigNat#

#

Convert an Integer into a BigNat.

Return 0 for negative Integers.

Word

valueintegerFromWord# :: Word# -> Integer

#

Convert a Word# into an Integer

valueintegerFromWord :: Word -> Integer

#

Convert a Word into an Integer

valueintegerFromWordNeg# :: Word# -> Integer

#

Create a negative Integer with the given Word magnitude

valueintegerFromWordSign# :: Int# -> Word# -> Integer

#

Create an Integer from a sign and a Word magnitude

valueintegerToWord# :: Integer -> Word#

#

Truncate an Integer into a Word

valueintegerToWord :: Integer -> Word

#

Truncate an Integer into a Word

Natural

valueintegerFromNatural :: Natural -> Integer

#

Convert a Natural into an Integer

valueintegerToNaturalClamp :: Integer -> Natural

#

Convert an Integer into a Natural

Return 0 for negative Integers.

valueintegerToNatural :: Integer -> Natural

#

Convert an Integer into a Natural

Return absolute value

valueintegerToNaturalThrow :: Integer -> Natural

#

Convert an Integer into a Natural

Throw an Underflow exception if input is negative.

`Int64`/`Word64`

valueintegerFromInt64# :: Int64# -> Integer

#

Convert an Int64# into an Integer

valueintegerFromWord64# :: Word64# -> Integer

#

Convert a Word64# into an Integer

valueintegerToInt64# :: Integer -> Int64#

#

Convert an Integer into an Int64#

valueintegerToWord64# :: Integer -> Word64#

#

Convert an Integer into a Word64#

Floating-point

valueintegerDecodeDouble# :: Double# -> (# Integer, Int# #)

#

Decode a Double# into (# Integer mantissa, Int# exponent #)

valueintegerEncodeDouble# :: Integer -> Int# -> Double#

#

Encode (# Integer mantissa, Int# exponent #) into a Double#

valueintegerEncodeDouble :: Integer -> Int -> Double

#

Encode (Integer mantissa, Int exponent) into a Double

valueintegerEncodeFloat# :: Integer -> Int# -> Float#

#

Encode (# Integer mantissa, Int# exponent #) into a Float#

TODO: Not sure if it's worth to write Float optimized versions here

`Addr#`

valueintegerToAddr#

:: Integer
-> Addr#
-> Bool#
-> State# s
-> (# State# s, Word# #)

#

Write an Integer (without sign) to addr in base-256 representation and return the number of bytes written.

The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1# or least significant byte first (little-endian) if 0#.

valueintegerToAddr :: Integer -> Addr# -> Bool# -> IO Word

#

Write an Integer (without sign) to addr in base-256 representation and return the number of bytes written.

The endianness is selected with the Bool# parameter: write most significant byte first (big-endian) if 1# or least significant byte first (little-endian) if 0#.

valueintegerFromAddr#

:: Word#
-> Addr#
-> Bool#
-> State# s
-> (# State# s, Integer #)

#

Read an Integer (without sign) in base-256 representation from an Addr#.

The size is given in bytes.

The endianness is selected with the Bool# parameter: most significant byte first (big-endian) if 1# or least significant byte first (little-endian) if 0#.

Null higher limbs are automatically trimed.

valueintegerFromAddr :: Word# -> Addr# -> Bool# -> IO Integer

#

Read an Integer (without sign) in base-256 representation from an Addr#.

The size is given in bytes.

The endianness is selected with the Bool# parameter: most significant byte first (big-endian) if 1# or least significant byte first (little-endian) if 0#.

Null higher limbs are automatically trimed.

Limbs

valueintegerFromWordList :: Bool -> [Word] -> Integer

#

Convert a list of Word into an Integer

valueintegerToMutableByteArray#

:: Integer
-> MutableByteArray# s
-> Word#
-> Bool#
-> State# s
-> (# State# s, Word# #)

#

Write an Integer (without sign) in base-256 representation and return the number of bytes written.

The endianness is selected with the Bool# parameter: most significant byte first (big-endian) if 1# or least significant byte first (little-endian) if 0#.

valueintegerToMutableByteArray

:: Integer
-> MutableByteArray# RealWorld
-> Word#
-> Bool#
-> IO Word

#

Write an Integer (without sign) in base-256 representation and return the number of bytes written.

The endianness is selected with the Bool# parameter: most significant byte first (big-endian) if 1# or least significant byte first (little-endian) if 0#.

valueintegerFromByteArray#

:: Word#
-> ByteArray#
-> Word#
-> Bool#
-> State# s
-> (# State# s, Integer #)

#

Read an Integer (without sign) in base-256 representation from a ByteArray#.

The size is given in bytes.

The endianness is selected with the Bool# parameter: most significant byte first (big-endian) if 1# or least significant byte first (little-endian) if 0#.

Null higher limbs are automatically trimed.

valueintegerFromByteArray :: Word# -> ByteArray# -> Word# -> Bool# -> Integer

#

Read an Integer (without sign) in base-256 representation from a ByteArray#.

The size is given in bytes.

The endianness is selected with the Bool# parameter: most significant byte first (big-endian) if 1# or least significant byte first (little-endian) if 0#.

Null higher limbs are automatically trimed.

Predicates

4 declarations

valueintegerIsNegative# :: Integer -> Bool#

#

Negative predicate

valueintegerIsNegative :: Integer -> Bool

#

Negative predicate

valueintegerIsZero :: Integer -> Bool

#

Zero predicate

valueintegerIsOne :: Integer -> Bool

#

One predicate

Comparison

13 declarations

valueintegerNe :: Integer -> Integer -> Bool

#

Not-equal predicate.

valueintegerEq :: Integer -> Integer -> Bool

#

Equal predicate.

valueintegerLe :: Integer -> Integer -> Bool

#

Lower-or-equal predicate.

valueintegerLt :: Integer -> Integer -> Bool

#

Lower predicate.

valueintegerGt :: Integer -> Integer -> Bool

#

Greater predicate.

valueintegerGe :: Integer -> Integer -> Bool

#

Greater-or-equal predicate.

valueintegerEq# :: Integer -> Integer -> Bool#

#

Equal predicate.

valueintegerNe# :: Integer -> Integer -> Bool#

#

Not-equal predicate.

valueintegerGt# :: Integer -> Integer -> Bool#

#

Greater predicate.

valueintegerLe# :: Integer -> Integer -> Bool#

#

Lower-or-equal predicate.

valueintegerLt# :: Integer -> Integer -> Bool#

#

Lower predicate.

valueintegerGe# :: Integer -> Integer -> Bool#

#

Greater-or-equal predicate.

valueintegerCompare :: Integer -> Integer -> Ordering

#

Compare two Integer

Arithmetic

29 declarations

valueintegerSub :: Integer -> Integer -> Integer

#

Subtract one Integer from another.

valueintegerAdd :: Integer -> Integer -> Integer

#

Add two Integers

valueintegerMul :: Integer -> Integer -> Integer

#

Multiply two Integers

valueintegerNegate :: Integer -> Integer

#

Negate Integer.

One edge-case issue to take into account is that Int's range is not symmetric around 0. I.e. minBound+maxBound = -1

IP is used iff n > maxBound::Int IN is used iff n < minBound::Int

valueintegerAbs :: Integer -> Integer

#

Compute absolute value of an Integer

valueintegerSignum :: Integer -> Integer

#

Return -1, 0, and 1 depending on whether argument is negative, zero, or positive, respectively

valueintegerSignum# :: Integer -> Int#

#

Return -1#, 0#, and 1# depending on whether argument is negative, zero, or positive, respectively

valueintegerQuotRem# :: Integer -> Integer -> (# Integer, Integer #)

#

Simultaneous integerQuot and integerRem.

Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault.

valueintegerQuotRem :: Integer -> Integer -> (Integer, Integer)

#

Simultaneous integerQuot and integerRem.

Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault.

valueintegerQuot :: Integer -> Integer -> Integer

#

valueintegerRem :: Integer -> Integer -> Integer

#

valueintegerDivMod# :: Integer -> Integer -> (# Integer, Integer #)

#

Simultaneous integerDiv and integerMod.

Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault.

valueintegerDivMod :: Integer -> Integer -> (Integer, Integer)

#

Simultaneous integerDiv and integerMod.

Divisor must be non-zero otherwise the GHC runtime will terminate with a division-by-zero fault.

valueintegerDiv :: Integer -> Integer -> Integer

#

valueintegerMod :: Integer -> Integer -> Integer

#

valueintegerGcd :: Integer -> Integer -> Integer

#

Compute greatest common divisor.

valueintegerLcm :: Integer -> Integer -> Integer

#

Compute least common multiple.

valueintegerSqr :: Integer -> Integer

#

Square a Integer

valueintegerLog2# :: Integer -> Word#

#

Base 2 logarithm (floor)

For numbers <= 0, return 0

valueintegerLog2 :: Integer -> Word

#

Base 2 logarithm (floor)

For numbers <= 0, return 0

valueintegerLogBaseWord# :: Word# -> Integer -> Word#

#

Logarithm (floor) for an arbitrary base

For numbers <= 0, return 0

valueintegerLogBaseWord :: Word -> Integer -> Word

#

Logarithm (floor) for an arbitrary base

For numbers <= 0, return 0

valueintegerLogBase# :: Integer -> Integer -> Word#

#

Logarithm (floor) for an arbitrary base

For numbers <= 0, return 0

valueintegerLogBase :: Integer -> Integer -> Word

#

Logarithm (floor) for an arbitrary base

For numbers <= 0, return 0

valueintegerIsPowerOf2# :: Integer -> (# (# #) | Word# #)

#

Indicate if the value is a power of two and which one

valueintegerGcde# :: Integer -> Integer -> (# Integer, Integer, Integer #)

#

Get the extended GCD of two integers.

`integerGcde# a b` returns (# g,x,y #) where * ax + by = g = |gcd a b|

valueintegerGcde :: Integer -> Integer -> (Integer, Integer, Integer)

#

Get the extended GCD of two integers.

`integerGcde a b` returns (g,x,y) where * ax + by = g = |gcd a b|

valueintegerRecipMod# :: Integer -> Natural -> (# Natural | () #)

#

Computes the modular inverse.

integerRecipMod# x m behaves as follows:

If m > 1 and gcd x m = 1, it returns an integer y with 0 < y < m such that x*y is congruent to 1 modulo m.
If m > 1 and gcd x m > 1, it fails.
If m = 1, it returns 0 for all x. The computation effectively takes place in the zero ring, which has a single element 0 with 0+0 = 0*0 = 0: the element 0 is the multiplicative identity element and is its own multiplicative inverse.
If m = 0, it fails.

NB. Successful evaluation returns a value of the form (# n | #); failure is indicated by returning (# | () #).

valueintegerPowMod# :: Integer -> Integer -> Natural -> (# Natural | () #)

#

Computes the modular exponentiation.

integerPowMod# b e m behaves as follows:

If m > 1 and e >= 0, it returns an integer y with 0 <= y < m and y congruent to b^e modulo m.
If m > 1 and e < 0, it uses integerRecipMod# to try to find a modular multiplicative inverse b' (which only exists if gcd b m = 1) and then caculates (b')^(-e) modulo m (note that -e > 0); if the inverse does not exist then it fails.
If m = 1, it returns 0 for all b and e.
If m = 0, it fails.

NB. Successful evaluation returns a value of the form (# n | #); failure is indicated by returning (# | () #).