GHC.Internal.Bignum.Natural · ghc-internal-9.1401.0

datadata Natural

#

Natural number

Invariant: numbers <= 0xffffffffffffffff use the NS constructor

Constructors

NS Word#
NB ByteArray#

Instances15Enum, Eq, Integral, Data, Num, Ord, …

Enum NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Enum
Eq NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Bignum.Natural
Integral NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Real
Data NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Data.Data
Num NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Num
Note that Natural's Num instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though.
Ord NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Bignum.Natural
Read NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Read
Real NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Real
Show NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Show
Ix NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Ix
Bits NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.Bits
Lift NaturalDefined in ghc-internal-9.1401.0 · GHC.Internal.TH.Lift
TestCoercion SNatDefined in ghc-internal-9.1401.0 · GHC.Internal.TypeNats
TestEquality SNatDefined in ghc-internal-9.1401.0 · GHC.Internal.TypeNats
type Compare a b = CmpNat a bDefined in ghc-internal-9.1401.0 · GHC.Internal.Data.Type.Ord

valuenaturalCheck# :: Natural -> Bool#

#

Check Natural invariants

valuenaturalCheck :: Natural -> Bool

#

Check Natural invariants

Useful constants

2 declarations

valuenaturalZero :: Natural

#

Zero Natural

valuenaturalOne :: Natural

#

One Natural

Predicates

3 declarations

valuenaturalIsZero :: Natural -> Bool

#

Test Zero Natural

valuenaturalIsOne :: Natural -> Bool

#

Test One Natural

valuenaturalIsPowerOf2# :: Natural -> (# (# #) | Word# #)

#

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

Conversion with...

0 declarations

BigNat

valuenaturalFromBigNat# :: BigNat# -> Natural

#

Create a Natural from a BigNat# (respect the invariants)

valuenaturalToBigNat# :: Natural -> BigNat#

#

Convert a Natural into a BigNat#

Word

valuenaturalFromWord# :: Word# -> Natural

#

Create a Natural from a Word#

valuenaturalFromWord2# :: Word# -> Word# -> Natural

#

Convert two Word# (most-significant first) into a Natural

valuenaturalFromWord :: Word -> Natural

#

Create a Natural from a Word

valuenaturalToWord# :: Natural -> Word#

#

Convert the lower bits of a Natural into a Word#

valuenaturalToWord :: Natural -> Word

#

Convert the lower bits of a Natural into a Word

valuenaturalToWordClamp# :: Natural -> Word#

#

Convert a Natural into a Word# clamping to (maxBound :: Word#).

valuenaturalToWordClamp :: Natural -> Word

#

Convert a Natural into a Word# clamping to (maxBound :: Word).

valuenaturalToWordMaybe# :: Natural -> (# (# #) | Word# #)

#

Try downcasting Natural to Word value. Returns (##) if value doesn't fit in Word.

Limbs

valuenaturalFromWordList :: [Word] -> Natural

#

Create a Natural from a list of Word

valuenaturalToMutableByteArray#

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

#

Write a Natural 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#.

valuenaturalFromByteArray#

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

#

Read a Natural 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.

Floating point

valuenaturalEncodeDouble# :: Natural -> Int# -> Double#

#

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

valuenaturalEncodeFloat# :: Natural -> Int# -> Float#

#

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

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

Addr#

valuenaturalToAddr#

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

#

Write a Natural 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#.

valuenaturalToAddr :: Natural -> Addr# -> Bool# -> IO Word

#

Write a Natural 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#.

valuenaturalFromAddr#

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

#

Read a Natural 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.

valuenaturalFromAddr :: Word# -> Addr# -> Bool# -> IO Natural

#

Read a Natural 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.

Comparison

13 declarations

valuenaturalEq# :: Natural -> Natural -> Bool#

#

Equality test for Natural

valuenaturalEq :: Natural -> Natural -> Bool

#

Equality test for Natural

valuenaturalNe# :: Natural -> Natural -> Bool#

#

Inequality test for Natural

valuenaturalNe :: Natural -> Natural -> Bool

#

Inequality test for Natural

valuenaturalGe# :: Natural -> Natural -> Bool#

#

Greater or equal test for Natural

valuenaturalGe :: Natural -> Natural -> Bool

#

Greater or equal test for Natural

valuenaturalLe# :: Natural -> Natural -> Bool#

#

Lower or equal test for Natural

valuenaturalLe :: Natural -> Natural -> Bool

#

Lower or equal test for Natural

valuenaturalGt# :: Natural -> Natural -> Bool#

#

Greater test for Natural

valuenaturalGt :: Natural -> Natural -> Bool

#

Greater test for Natural

valuenaturalLt# :: Natural -> Natural -> Bool#

#

Lower test for Natural

valuenaturalLt :: Natural -> Natural -> Bool

#

Lower test for Natural

valuenaturalCompare :: Natural -> Natural -> Ordering

#

Compare two Natural

Bit operations

20 declarations

valuenaturalPopCount# :: Natural -> Word#

#

PopCount for Natural

valuenaturalPopCount :: Natural -> Word

#

PopCount for Natural

valuenaturalShiftR# :: Natural -> Word# -> Natural

#

Right shift for Natural

valuenaturalShiftR :: Natural -> Word -> Natural

#

Right shift for Natural

valuenaturalShiftL# :: Natural -> Word# -> Natural

#

Left shift

valuenaturalShiftL :: Natural -> Word -> Natural

#

Left shift

valuenaturalAnd :: Natural -> Natural -> Natural

#

valuenaturalAndNot :: Natural -> Natural -> Natural

#

valuenaturalOr :: Natural -> Natural -> Natural

#

valuenaturalXor :: Natural -> Natural -> Natural

#

valuenaturalTestBit# :: Natural -> Word# -> Bool#

#

valuenaturalTestBit :: Natural -> Word -> Bool

#

valuenaturalBit# :: Word# -> Natural

#

valuenaturalBit :: Word -> Natural

#

valuenaturalSetBit# :: Natural -> Word# -> Natural

#

valuenaturalSetBit :: Natural -> Word -> Natural

#

valuenaturalClearBit# :: Natural -> Word# -> Natural

#

valuenaturalClearBit :: Natural -> Word -> Natural

#

valuenaturalComplementBit# :: Natural -> Word# -> Natural

#

valuenaturalComplementBit :: Natural -> Word -> Natural

#

Arithmetic

21 declarations

valuenaturalAdd :: Natural -> Natural -> Natural

#

Add two naturals

valuenaturalSub :: Natural -> Natural -> (# (# #) | Natural #)

#

Sub two naturals

valuenaturalSubThrow :: Natural -> Natural -> Natural

#

Sub two naturals

Throw an Underflow exception if x < y

valuenaturalSubUnsafe :: Natural -> Natural -> Natural

#

Sub two naturals

Unsafe: don't check that x >= y Undefined results if it happens

valuenaturalMul :: Natural -> Natural -> Natural

#

Multiplication

valuenaturalSqr :: Natural -> Natural

#

Square a Natural

valuenaturalSignum :: Natural -> Natural

#

Signum for Natural

valuenaturalNegate :: Natural -> Natural

#

Negate for Natural

valuenaturalQuotRem# :: Natural -> Natural -> (# Natural, Natural #)

#

Return division quotient and remainder

Division by zero is handled by BigNat

valuenaturalQuotRem :: Natural -> Natural -> (Natural, Natural)

#

Return division quotient and remainder

valuenaturalQuot :: Natural -> Natural -> Natural

#

Return division quotient

valuenaturalRem :: Natural -> Natural -> Natural

#

Return division remainder

valuenaturalGcd :: Natural -> Natural -> Natural

#

Compute greatest common divisor.

valuenaturalLcm :: Natural -> Natural -> Natural

#

Compute least common multiple.

valuenaturalLog2# :: Natural -> Word#

#

Base 2 logarithm

valuenaturalLog2 :: Natural -> Word

#

Base 2 logarithm

valuenaturalLogBaseWord# :: Word# -> Natural -> Word#

#

Logarithm for an arbitrary base

valuenaturalLogBaseWord :: Word -> Natural -> Word

#

Logarithm for an arbitrary base

valuenaturalLogBase# :: Natural -> Natural -> Word#

#

Logarithm for an arbitrary base

valuenaturalLogBase :: Natural -> Natural -> Word

#

Logarithm for an arbitrary base

valuenaturalPowMod :: Natural -> Natural -> Natural -> Natural

#

"naturalPowMod b e m" computes base b raised to exponent e modulo m.

Miscellaneous

1 declaration

valuenaturalSizeInBase# :: Word# -> Natural -> Word#

#

Compute the number of digits of the Natural in the given base.

base must be > 1