Safe Haskell	None
Language	Haskell2010

GHC.Internal.Bignum.Natural

Contents

Useful constants
Predicates
Conversion with...
Comparison
Bit operations
Arithmetic
Miscellaneous

Synopsis

data Natural
- = NS Word#
- | NB ByteArray#
naturalCheck# :: Natural -> Bool#
naturalCheck :: Natural -> Bool
naturalZero :: Natural
naturalOne :: Natural
naturalIsZero :: Natural -> Bool
naturalIsOne :: Natural -> Bool
naturalIsPowerOf2# :: Natural -> (# (# #) | Word# #)
naturalFromBigNat# :: BigNat# -> Natural
naturalToBigNat# :: Natural -> BigNat#
naturalFromWord# :: Word# -> Natural
naturalFromWord2# :: Word# -> Word# -> Natural
naturalFromWord :: Word -> Natural
naturalToWord# :: Natural -> Word#
naturalToWord :: Natural -> Word
naturalToWordClamp# :: Natural -> Word#
naturalToWordClamp :: Natural -> Word
naturalToWordMaybe# :: Natural -> (# (# #) | Word# #)
naturalFromWordList :: [Word] -> Natural
naturalToMutableByteArray# :: Natural -> MutableByteArray# s -> Word# -> Bool# -> State# s -> (# State# s, Word# #)
naturalFromByteArray# :: Word# -> ByteArray# -> Word# -> Bool# -> State# s -> (# State# s, Natural #)
naturalEncodeDouble# :: Natural -> Int# -> Double#
naturalEncodeFloat# :: Natural -> Int# -> Float#
naturalToAddr# :: Natural -> Addr# -> Bool# -> State# s -> (# State# s, Word# #)
naturalToAddr :: Natural -> Addr# -> Bool# -> IO Word
naturalFromAddr# :: Word# -> Addr# -> Bool# -> State# s -> (# State# s, Natural #)
naturalFromAddr :: Word# -> Addr# -> Bool# -> IO Natural
naturalEq# :: Natural -> Natural -> Bool#
naturalEq :: Natural -> Natural -> Bool
naturalNe# :: Natural -> Natural -> Bool#
naturalNe :: Natural -> Natural -> Bool
naturalGe# :: Natural -> Natural -> Bool#
naturalGe :: Natural -> Natural -> Bool
naturalLe# :: Natural -> Natural -> Bool#
naturalLe :: Natural -> Natural -> Bool
naturalGt# :: Natural -> Natural -> Bool#
naturalGt :: Natural -> Natural -> Bool
naturalLt# :: Natural -> Natural -> Bool#
naturalLt :: Natural -> Natural -> Bool
naturalCompare :: Natural -> Natural -> Ordering
naturalPopCount# :: Natural -> Word#
naturalPopCount :: Natural -> Word
naturalShiftR# :: Natural -> Word# -> Natural
naturalShiftR :: Natural -> Word -> Natural
naturalShiftL# :: Natural -> Word# -> Natural
naturalShiftL :: Natural -> Word -> Natural
naturalAnd :: Natural -> Natural -> Natural
naturalAndNot :: Natural -> Natural -> Natural
naturalOr :: Natural -> Natural -> Natural
naturalXor :: Natural -> Natural -> Natural
naturalTestBit# :: Natural -> Word# -> Bool#
naturalTestBit :: Natural -> Word -> Bool
naturalBit# :: Word# -> Natural
naturalBit :: Word -> Natural
naturalSetBit# :: Natural -> Word# -> Natural
naturalSetBit :: Natural -> Word -> Natural
naturalClearBit# :: Natural -> Word# -> Natural
naturalClearBit :: Natural -> Word -> Natural
naturalComplementBit# :: Natural -> Word# -> Natural
naturalComplementBit :: Natural -> Word -> Natural
naturalAdd :: Natural -> Natural -> Natural
naturalSub :: Natural -> Natural -> (# (# #) | Natural #)
naturalSubThrow :: Natural -> Natural -> Natural
naturalSubUnsafe :: Natural -> Natural -> Natural
naturalMul :: Natural -> Natural -> Natural
naturalSqr :: Natural -> Natural
naturalSignum :: Natural -> Natural
naturalNegate :: Natural -> Natural
naturalQuotRem# :: Natural -> Natural -> (# Natural, Natural #)
naturalQuotRem :: Natural -> Natural -> (Natural, Natural)
naturalQuot :: Natural -> Natural -> Natural
naturalRem :: Natural -> Natural -> Natural
naturalGcd :: Natural -> Natural -> Natural
naturalLcm :: Natural -> Natural -> Natural
naturalLog2# :: Natural -> Word#
naturalLog2 :: Natural -> Word
naturalLogBaseWord# :: Word# -> Natural -> Word#
naturalLogBaseWord :: Word -> Natural -> Word
naturalLogBase# :: Natural -> Natural -> Word#
naturalLogBase :: Natural -> Natural -> Word
naturalPowMod :: Natural -> Natural -> Natural -> Natural
naturalSizeInBase# :: Word# -> Natural -> Word#

Documentation

data Natural #

Natural number

Invariant: numbers <= 0xffffffffffffffff use the NS constructor

Constructors

NS Word#
NB ByteArray#

Instances

Instances details

Bits Natural #	Since: base-4.8.0
Instance details Defined in GHC.Internal.Bits Methods (.&.) :: Natural -> Natural -> Natural # (.\|.) :: Natural -> Natural -> Natural # xor :: Natural -> Natural -> Natural # complement :: Natural -> Natural # shift :: Natural -> Int -> Natural # rotate :: Natural -> Int -> Natural # zeroBits :: Natural # bit :: Int -> Natural # setBit :: Natural -> Int -> Natural # clearBit :: Natural -> Int -> Natural # complementBit :: Natural -> Int -> Natural # testBit :: Natural -> Int -> Bool # bitSizeMaybe :: Natural -> Maybe Int # bitSize :: Natural -> Int # isSigned :: Natural -> Bool # shiftL :: Natural -> Int -> Natural # unsafeShiftL :: Natural -> Int -> Natural # shiftR :: Natural -> Int -> Natural # unsafeShiftR :: Natural -> Int -> Natural # rotateL :: Natural -> Int -> Natural # rotateR :: Natural -> Int -> Natural # popCount :: Natural -> Int #
Eq Natural #
Instance details Defined in GHC.Internal.Bignum.Natural Methods (==) :: Natural -> Natural -> Bool # (/=) :: Natural -> Natural -> Bool #
Ord Natural #
Instance details Defined in GHC.Internal.Bignum.Natural Methods compare :: Natural -> Natural -> Ordering # (<) :: Natural -> Natural -> Bool # (<=) :: Natural -> Natural -> Bool # (>) :: Natural -> Natural -> Bool # (>=) :: Natural -> Natural -> Bool # max :: Natural -> Natural -> Natural # min :: Natural -> Natural -> Natural #
Data Natural #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural # toConstr :: Natural -> Constr # dataTypeOf :: Natural -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) # gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural #
Enum Natural #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Enum Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Ix Natural #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Ix Methods range :: (Natural, Natural) -> [Natural] # index :: (Natural, Natural) -> Natural -> Int # unsafeIndex :: (Natural, Natural) -> Natural -> Int # inRange :: (Natural, Natural) -> Natural -> Bool # rangeSize :: (Natural, Natural) -> Int # unsafeRangeSize :: (Natural, Natural) -> Int #
Num Natural #	Note that `Natural`'s `Num` instance isn't a ring: no element but 0 has an additive inverse. It is a semiring though. Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Num Methods (+) :: Natural -> Natural -> Natural # (-) :: Natural -> Natural -> Natural # (*) :: Natural -> Natural -> Natural # negate :: Natural -> Natural # abs :: Natural -> Natural # signum :: Natural -> Natural # fromInteger :: Integer -> Natural #
Read Natural #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Read Methods readsPrec :: Int -> ReadS Natural # readList :: ReadS [Natural] # readPrec :: ReadPrec Natural # readListPrec :: ReadPrec [Natural] #
Integral Natural #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Real Methods quot :: Natural -> Natural -> Natural # rem :: Natural -> Natural -> Natural # div :: Natural -> Natural -> Natural # mod :: Natural -> Natural -> Natural # quotRem :: Natural -> Natural -> (Natural, Natural) # divMod :: Natural -> Natural -> (Natural, Natural) # toInteger :: Natural -> Integer #
Real Natural #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Real Methods toRational :: Natural -> Rational #
Show Natural #	Since: base-4.8.0.0
Instance details Defined in GHC.Internal.Show Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
TestCoercion SNat #	Since: base-4.18.0.0
Instance details Defined in GHC.Internal.TypeNats Methods testCoercion :: forall (a :: Nat) (b :: Nat). SNat a -> SNat b -> Maybe (Coercion a b) #
TestEquality SNat #	Since: base-4.18.0.0
Instance details Defined in GHC.Internal.TypeNats Methods testEquality :: forall (a :: Nat) (b :: Nat). SNat a -> SNat b -> Maybe (a :~: b) #
Lift Natural #
Instance details Defined in GHC.Internal.TH.Lift Methods lift :: Quote m => Natural -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Natural -> Code m Natural #
type Compare (a :: Natural) (b :: Natural) #
Instance details Defined in GHC.Internal.Data.Type.Ord type Compare (a :: Natural) (b :: Natural) = CmpNat a b

naturalCheck# :: Natural -> Bool# #

Check Natural invariants

naturalCheck :: Natural -> Bool #

Check Natural invariants

Useful constants

naturalZero :: Natural #

Zero Natural

naturalOne :: Natural #

One Natural

Predicates

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

Conversion with...

`BigNat`

naturalFromBigNat# :: BigNat# -> Natural #

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

naturalToBigNat# :: Natural -> BigNat# #

Convert a Natural into a BigNat#

`Word`

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

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.

Limbs

naturalFromWordList :: [Word] -> Natural #

Create a Natural from a list of Word

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.

Floating point

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

`Addr#`

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.