ghc-bignum-1.2: GHC BigNum library
Safe HaskellSafe-Inferred
LanguageHaskell2010

GHC.Num.Natural

Synopsis

Documentation

data Natural #

Natural number

Invariant: numbers <= 0xffffffff use the NS constructor

Constructors

NS !Word# 
NB !BigNat# 

Instances

Instances details
Eq Natural # 
Instance details

Defined in GHC.Num.Natural

Ord Natural # 
Instance details

Defined in GHC.Num.Natural

naturalCheck# :: Natural -> Bool# #

Check Natural invariants

naturalCheck :: Natural -> Bool #

Check Natural invariants

naturalZero :: Natural #

Zero Natural

naturalOne :: Natural #

One Natural

naturalIsZero :: Natural -> Bool #

Test Zero Natural

naturalIsOne :: Natural -> Bool #

Test One Natural

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

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

naturalFromBigNat# :: BigNat# -> Natural #

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

naturalToBigNat# :: Natural -> BigNat# #

Convert a Natural into a BigNat#

naturalFromWord# :: Word# -> Natural #

Create a Natural from a Word#

naturalFromWord2# :: Word# -> Word# -> Natural #

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

naturalFromWord :: Word -> Natural #

Create a Natural from a Word

naturalFromWordList :: [Word] -> Natural #

Create a Natural from a list of Word

naturalToWord# :: Natural -> Word# #

Convert the lower bits of a Natural into a Word#

naturalToWord :: Natural -> Word #

Convert the lower bits of a Natural into a Word

naturalToWordClamp# :: Natural -> Word# #

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

naturalToWordClamp :: Natural -> Word #

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

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

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

naturalEncodeDouble# :: Natural -> Int# -> Double# #

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

naturalEncodeFloat# :: Natural -> Int# -> Float# #

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

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

naturalEq# :: Natural -> Natural -> Bool# #

Equality test for Natural

naturalEq :: Natural -> Natural -> Bool #

Equality test for Natural

naturalNe# :: Natural -> Natural -> Bool# #

Inequality test for Natural

naturalNe :: Natural -> Natural -> Bool #

Inequality test for Natural

naturalGe# :: Natural -> Natural -> Bool# #

Greater or equal test for Natural

naturalGe :: Natural -> Natural -> Bool #

Greater or equal test for Natural

naturalLe# :: Natural -> Natural -> Bool# #

Lower or equal test for Natural

naturalLe :: Natural -> Natural -> Bool #

Lower or equal test for Natural

naturalGt# :: Natural -> Natural -> Bool# #

Greater test for Natural

naturalGt :: Natural -> Natural -> Bool #

Greater test for Natural

naturalLt# :: Natural -> Natural -> Bool# #

Lower test for Natural

naturalLt :: Natural -> Natural -> Bool #

Lower test for Natural

naturalCompare :: Natural -> Natural -> Ordering #

Compare two Natural

naturalPopCount# :: Natural -> Word# #

PopCount for Natural

naturalPopCount :: Natural -> Word #

PopCount for Natural

naturalShiftR# :: Natural -> Word# -> Natural #

Right shift for Natural

naturalShiftR :: Natural -> Word -> Natural #

Right shift for Natural

naturalShiftL# :: Natural -> Word# -> Natural #

Left shift

naturalShiftL :: Natural -> Word -> Natural #

Left shift

naturalAdd :: Natural -> Natural -> Natural #

Add two naturals

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

Sub two naturals

naturalSubThrow :: Natural -> Natural -> Natural #

Sub two naturals

Throw an Underflow exception if x < y

naturalSubUnsafe :: Natural -> Natural -> Natural #

Sub two naturals

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

naturalMul :: Natural -> Natural -> Natural #

Multiplication

naturalSqr :: Natural -> Natural #

Square a Natural

naturalSignum :: Natural -> Natural #

Signum for Natural

naturalNegate :: Natural -> Natural #

Negate for Natural

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

Return division quotient and remainder

Division by zero is handled by BigNat

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

Return division quotient and remainder

naturalQuot :: Natural -> Natural -> Natural #

Return division quotient

naturalRem :: Natural -> Natural -> Natural #

Return division remainder

naturalGcd :: Natural -> Natural -> Natural #

Compute greatest common divisor.

naturalLcm :: Natural -> Natural -> Natural #

Compute least common multiple.

naturalLog2# :: Natural -> Word# #

Base 2 logarithm

naturalLog2 :: Natural -> Word #

Base 2 logarithm

naturalLogBaseWord# :: Word# -> Natural -> Word# #

Logarithm for an arbitrary base

naturalLogBaseWord :: Word -> Natural -> Word #

Logarithm for an arbitrary base

naturalLogBase# :: Natural -> Natural -> Word# #

Logarithm for an arbitrary base

naturalLogBase :: Natural -> Natural -> Word #

Logarithm for an arbitrary base

naturalPowMod :: Natural -> Natural -> Natural -> Natural #

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

naturalSizeInBase# :: Word# -> Natural -> Word# #

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

base must be > 1

naturalToAddr# :: 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#.

naturalToAddr :: 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#.

naturalFromAddr# :: 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.

naturalFromAddr :: 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.

naturalToMutableByteArray# :: 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#.

naturalFromByteArray# :: 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.