data-dword-0.3.1.1: Stick two binary words together to get a bigger one

Safe Haskell | None
Language | Haskell2010

Data.DoubleWord

Description

This module provides strict (low and high halves are unpacked) signed and unsigned binary word data types of sizes 96, 128, 160, 192, 224, and 256 bits.

Synopsis

- module Data.BinaryWord
- class BinaryWord w => DoubleWord w where
  - type LoWord w
  - type HiWord w
- data Word96 = Word96 !Word32 !Word64
- data Word128 = Word128 !Word64 !Word64
- data Word160 = Word160 !Word32 !Word128
- data Word192 = Word192 !Word64 !Word128
- data Word224 = Word224 !Word96 !Word128
- data Word256 = Word256 !Word128 !Word128
- data Int96 = Int96 !Int32 !Word64
- data Int128 = Int128 !Int64 !Word64
- data Int160 = Int160 !Int32 !Word128
- data Int192 = Int192 !Int64 !Word128
- data Int224 = Int224 !Int96 !Word128
- data Int256 = Int256 !Int128 !Word128

# Documentation

module Data.BinaryWord

class BinaryWord w => DoubleWord w where #

Defines a particular way to split a binary word in halves.

Minimal complete definition

loWord, hiWord, fromHiAndLo, extendLo, signExtendLo

Associated Types

type LoWord w #

The low half type

type HiWord w #

The high half type

Methods

loWord :: w -> LoWord w #

The low half of the word

hiWord :: w -> HiWord w #

The high half of the word

fromHiAndLo :: HiWord w -> LoWord w -> w #

Construct a word from the low and high halves

extendLo :: LoWord w -> w #

Extend the low half

signExtendLo :: SignedWord (LoWord w) -> w #

Sign-extend the low half

Instances

DoubleWord Int16 # |
Associated Types type LoWord Int16 :: * # type HiWord Int16 :: * # Methods loWord :: Int16 -> LoWord Int16 # hiWord :: Int16 -> HiWord Int16 # fromHiAndLo :: HiWord Int16 -> LoWord Int16 -> Int16 # extendLo :: LoWord Int16 -> Int16 # signExtendLo :: SignedWord (LoWord Int16) -> Int16 #
DoubleWord Int32 # |
Associated Types type LoWord Int32 :: * # type HiWord Int32 :: * # Methods loWord :: Int32 -> LoWord Int32 # hiWord :: Int32 -> HiWord Int32 # fromHiAndLo :: HiWord Int32 -> LoWord Int32 -> Int32 # extendLo :: LoWord Int32 -> Int32 # signExtendLo :: SignedWord (LoWord Int32) -> Int32 #
DoubleWord Int64 # |
Associated Types type LoWord Int64 :: * # type HiWord Int64 :: * # Methods loWord :: Int64 -> LoWord Int64 # hiWord :: Int64 -> HiWord Int64 # fromHiAndLo :: HiWord Int64 -> LoWord Int64 -> Int64 # extendLo :: LoWord Int64 -> Int64 # signExtendLo :: SignedWord (LoWord Int64) -> Int64 #
DoubleWord Word16 # |
Associated Types type LoWord Word16 :: * # type HiWord Word16 :: * # Methods loWord :: Word16 -> LoWord Word16 # hiWord :: Word16 -> HiWord Word16 # fromHiAndLo :: HiWord Word16 -> LoWord Word16 -> Word16 # extendLo :: LoWord Word16 -> Word16 # signExtendLo :: SignedWord (LoWord Word16) -> Word16 #
DoubleWord Word32 # |
Associated Types type LoWord Word32 :: * # type HiWord Word32 :: * # Methods loWord :: Word32 -> LoWord Word32 # hiWord :: Word32 -> HiWord Word32 # fromHiAndLo :: HiWord Word32 -> LoWord Word32 -> Word32 # extendLo :: LoWord Word32 -> Word32 # signExtendLo :: SignedWord (LoWord Word32) -> Word32 #
DoubleWord Word64 # |
Associated Types type LoWord Word64 :: * # type HiWord Word64 :: * # Methods loWord :: Word64 -> LoWord Word64 # hiWord :: Word64 -> HiWord Word64 # fromHiAndLo :: HiWord Word64 -> LoWord Word64 -> Word64 # extendLo :: LoWord Word64 -> Word64 # signExtendLo :: SignedWord (LoWord Word64) -> Word64 #
DoubleWord Int96 # |
Associated Types type LoWord Int96 :: * # type HiWord Int96 :: * # Methods loWord :: Int96 -> LoWord Int96 # hiWord :: Int96 -> HiWord Int96 # fromHiAndLo :: HiWord Int96 -> LoWord Int96 -> Int96 # extendLo :: LoWord Int96 -> Int96 # signExtendLo :: SignedWord (LoWord Int96) -> Int96 #
DoubleWord Word96 # |
Associated Types type LoWord Word96 :: * # type HiWord Word96 :: * # Methods loWord :: Word96 -> LoWord Word96 # hiWord :: Word96 -> HiWord Word96 # fromHiAndLo :: HiWord Word96 -> LoWord Word96 -> Word96 # extendLo :: LoWord Word96 -> Word96 # signExtendLo :: SignedWord (LoWord Word96) -> Word96 #
DoubleWord Int128 # |
Associated Types type LoWord Int128 :: * # type HiWord Int128 :: * # Methods loWord :: Int128 -> LoWord Int128 # hiWord :: Int128 -> HiWord Int128 # fromHiAndLo :: HiWord Int128 -> LoWord Int128 -> Int128 # extendLo :: LoWord Int128 -> Int128 # signExtendLo :: SignedWord (LoWord Int128) -> Int128 #
DoubleWord Word128 # |
Associated Types type LoWord Word128 :: * # type HiWord Word128 :: * # Methods loWord :: Word128 -> LoWord Word128 # hiWord :: Word128 -> HiWord Word128 # fromHiAndLo :: HiWord Word128 -> LoWord Word128 -> Word128 # extendLo :: LoWord Word128 -> Word128 # signExtendLo :: SignedWord (LoWord Word128) -> Word128 #
DoubleWord Int160 # |
Associated Types type LoWord Int160 :: * # type HiWord Int160 :: * # Methods loWord :: Int160 -> LoWord Int160 # hiWord :: Int160 -> HiWord Int160 # fromHiAndLo :: HiWord Int160 -> LoWord Int160 -> Int160 # extendLo :: LoWord Int160 -> Int160 # signExtendLo :: SignedWord (LoWord Int160) -> Int160 #
DoubleWord Word160 # |
Associated Types type LoWord Word160 :: * # type HiWord Word160 :: * # Methods loWord :: Word160 -> LoWord Word160 # hiWord :: Word160 -> HiWord Word160 # fromHiAndLo :: HiWord Word160 -> LoWord Word160 -> Word160 # extendLo :: LoWord Word160 -> Word160 # signExtendLo :: SignedWord (LoWord Word160) -> Word160 #
DoubleWord Int192 # |
Associated Types type LoWord Int192 :: * # type HiWord Int192 :: * # Methods loWord :: Int192 -> LoWord Int192 # hiWord :: Int192 -> HiWord Int192 # fromHiAndLo :: HiWord Int192 -> LoWord Int192 -> Int192 # extendLo :: LoWord Int192 -> Int192 # signExtendLo :: SignedWord (LoWord Int192) -> Int192 #
DoubleWord Word192 # |
Associated Types type LoWord Word192 :: * # type HiWord Word192 :: * # Methods loWord :: Word192 -> LoWord Word192 # hiWord :: Word192 -> HiWord Word192 # fromHiAndLo :: HiWord Word192 -> LoWord Word192 -> Word192 # extendLo :: LoWord Word192 -> Word192 # signExtendLo :: SignedWord (LoWord Word192) -> Word192 #
DoubleWord Int224 # |
Associated Types type LoWord Int224 :: * # type HiWord Int224 :: * # Methods loWord :: Int224 -> LoWord Int224 # hiWord :: Int224 -> HiWord Int224 # fromHiAndLo :: HiWord Int224 -> LoWord Int224 -> Int224 # extendLo :: LoWord Int224 -> Int224 # signExtendLo :: SignedWord (LoWord Int224) -> Int224 #
DoubleWord Word224 # |
Associated Types type LoWord Word224 :: * # type HiWord Word224 :: * # Methods loWord :: Word224 -> LoWord Word224 # hiWord :: Word224 -> HiWord Word224 # fromHiAndLo :: HiWord Word224 -> LoWord Word224 -> Word224 # extendLo :: LoWord Word224 -> Word224 # signExtendLo :: SignedWord (LoWord Word224) -> Word224 #
DoubleWord Int256 # |
Associated Types type LoWord Int256 :: * # type HiWord Int256 :: * # Methods loWord :: Int256 -> LoWord Int256 # hiWord :: Int256 -> HiWord Int256 # fromHiAndLo :: HiWord Int256 -> LoWord Int256 -> Int256 # extendLo :: LoWord Int256 -> Int256 # signExtendLo :: SignedWord (LoWord Int256) -> Int256 #
DoubleWord Word256 # |
Associated Types type LoWord Word256 :: * # type HiWord Word256 :: * # Methods loWord :: Word256 -> LoWord Word256 # hiWord :: Word256 -> HiWord Word256 # fromHiAndLo :: HiWord Word256 -> LoWord Word256 -> Word256 # extendLo :: LoWord Word256 -> Word256 # signExtendLo :: SignedWord (LoWord Word256) -> Word256 #

data Word96 #

Constructors

Word96 !Word32 !Word64 |

Instances

Bounded Word96 # |
Methods minBound :: Word96 # maxBound :: Word96 #
Enum Word96 # |
Methods succ :: Word96 -> Word96 # pred :: Word96 -> Word96 # toEnum :: Int -> Word96 # fromEnum :: Word96 -> Int # enumFrom :: Word96 -> [Word96] # enumFromThen :: Word96 -> Word96 -> [Word96] # enumFromTo :: Word96 -> Word96 -> [Word96] # enumFromThenTo :: Word96 -> Word96 -> Word96 -> [Word96] #
Eq Word96 # |
Methods (==) :: Word96 -> Word96 -> Bool # (/=) :: Word96 -> Word96 -> Bool #
Integral Word96 # |
Methods quot :: Word96 -> Word96 -> Word96 # rem :: Word96 -> Word96 -> Word96 # div :: Word96 -> Word96 -> Word96 # mod :: Word96 -> Word96 -> Word96 # quotRem :: Word96 -> Word96 -> (Word96, Word96) # divMod :: Word96 -> Word96 -> (Word96, Word96) # toInteger :: Word96 -> Integer #
Data Word96 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word96 -> c Word96 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word96 # toConstr :: Word96 -> Constr # dataTypeOf :: Word96 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word96) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word96) # gmapT :: (forall b. Data b => b -> b) -> Word96 -> Word96 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word96 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word96 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word96 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word96 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word96 -> m Word96 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word96 -> m Word96 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word96 -> m Word96 #
Num Word96 # |
Methods (+) :: Word96 -> Word96 -> Word96 # (-) :: Word96 -> Word96 -> Word96 # (*) :: Word96 -> Word96 -> Word96 # negate :: Word96 -> Word96 # abs :: Word96 -> Word96 # signum :: Word96 -> Word96 # fromInteger :: Integer -> Word96 #
Ord Word96 # |
Methods compare :: Word96 -> Word96 -> Ordering # (<) :: Word96 -> Word96 -> Bool # (<=) :: Word96 -> Word96 -> Bool # (>) :: Word96 -> Word96 -> Bool # (>=) :: Word96 -> Word96 -> Bool # max :: Word96 -> Word96 -> Word96 # min :: Word96 -> Word96 -> Word96 #
Read Word96 # |
Methods readsPrec :: Int -> ReadS Word96 # readList :: ReadS [Word96] # readPrec :: ReadPrec Word96 # readListPrec :: ReadPrec [Word96] #
Real Word96 # |
Methods toRational :: Word96 -> Rational #
Show Word96 # |
Methods showsPrec :: Int -> Word96 -> ShowS # show :: Word96 -> String # showList :: [Word96] -> ShowS #
Ix Word96 # |
Methods range :: (Word96, Word96) -> [Word96] # index :: (Word96, Word96) -> Word96 -> Int # unsafeIndex :: (Word96, Word96) -> Word96 -> Int inRange :: (Word96, Word96) -> Word96 -> Bool # rangeSize :: (Word96, Word96) -> Int # unsafeRangeSize :: (Word96, Word96) -> Int
Generic Word96 # |
Associated Types type Rep Word96 :: * -> * # Methods from :: Word96 -> Rep Word96 x # to :: Rep Word96 x -> Word96 #
Bits Word96 # |
Methods (.&.) :: Word96 -> Word96 -> Word96 # (.|.) :: Word96 -> Word96 -> Word96 # xor :: Word96 -> Word96 -> Word96 # complement :: Word96 -> Word96 # shift :: Word96 -> Int -> Word96 # rotate :: Word96 -> Int -> Word96 # zeroBits :: Word96 # bit :: Int -> Word96 # setBit :: Word96 -> Int -> Word96 # clearBit :: Word96 -> Int -> Word96 # complementBit :: Word96 -> Int -> Word96 # testBit :: Word96 -> Int -> Bool # bitSizeMaybe :: Word96 -> Maybe Int # bitSize :: Word96 -> Int # isSigned :: Word96 -> Bool # shiftL :: Word96 -> Int -> Word96 # unsafeShiftL :: Word96 -> Int -> Word96 # shiftR :: Word96 -> Int -> Word96 # unsafeShiftR :: Word96 -> Int -> Word96 # rotateL :: Word96 -> Int -> Word96 # rotateR :: Word96 -> Int -> Word96 # popCount :: Word96 -> Int #
FiniteBits Word96 # |
Methods finiteBitSize :: Word96 -> Int # countLeadingZeros :: Word96 -> Int # countTrailingZeros :: Word96 -> Int #
BinaryWord Word96 # |
Associated Types type UnsignedWord Word96 :: * # type SignedWord Word96 :: * # Methods unsignedWord :: Word96 -> UnsignedWord Word96 # signedWord :: Word96 -> SignedWord Word96 # unwrappedAdd :: Word96 -> Word96 -> (Word96, UnsignedWord Word96) # unwrappedMul :: Word96 -> Word96 -> (Word96, UnsignedWord Word96) # leadingZeroes :: Word96 -> Int # trailingZeroes :: Word96 -> Int # allZeroes :: Word96 # allOnes :: Word96 # msb :: Word96 # lsb :: Word96 # testMsb :: Word96 -> Bool # testLsb :: Word96 -> Bool # setMsb :: Word96 -> Word96 # setLsb :: Word96 -> Word96 # clearMsb :: Word96 -> Word96 # clearLsb :: Word96 -> Word96 #
Hashable Word96 # |
Methods hashWithSalt :: Int -> Word96 -> Int # hash :: Word96 -> Int #
DoubleWord Word96 # |
Associated Types type LoWord Word96 :: * # type HiWord Word96 :: * # Methods loWord :: Word96 -> LoWord Word96 # hiWord :: Word96 -> HiWord Word96 # fromHiAndLo :: HiWord Word96 -> LoWord Word96 -> Word96 # extendLo :: LoWord Word96 -> Word96 # signExtendLo :: SignedWord (LoWord Word96) -> Word96 #
type Rep Word96 # |
type Rep Word96 = D1 (MetaData "Word96" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Word96" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word32)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64))))
type SignedWord Word96 # |
type SignedWord Word96 = Int96
type UnsignedWord Word96 # |
type UnsignedWord Word96 = Word96
type LoWord Word96 # |
type LoWord Word96 = Word64
type HiWord Word96 # |
type HiWord Word96 = Word32

data Word128 #

Constructors

Word128 !Word64 !Word64 |

Instances

Bounded Word128 # |
Methods minBound :: Word128 # maxBound :: Word128 #
Enum Word128 # |
Methods succ :: Word128 -> Word128 # pred :: Word128 -> Word128 # toEnum :: Int -> Word128 # fromEnum :: Word128 -> Int # enumFrom :: Word128 -> [Word128] # enumFromThen :: Word128 -> Word128 -> [Word128] # enumFromTo :: Word128 -> Word128 -> [Word128] # enumFromThenTo :: Word128 -> Word128 -> Word128 -> [Word128] #
Eq Word128 # |
Methods (==) :: Word128 -> Word128 -> Bool # (/=) :: Word128 -> Word128 -> Bool #
Integral Word128 # |
Methods quot :: Word128 -> Word128 -> Word128 # rem :: Word128 -> Word128 -> Word128 # div :: Word128 -> Word128 -> Word128 # mod :: Word128 -> Word128 -> Word128 # quotRem :: Word128 -> Word128 -> (Word128, Word128) # divMod :: Word128 -> Word128 -> (Word128, Word128) # toInteger :: Word128 -> Integer #
Data Word128 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word128 -> c Word128 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word128 # toConstr :: Word128 -> Constr # dataTypeOf :: Word128 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word128) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word128) # gmapT :: (forall b. Data b => b -> b) -> Word128 -> Word128 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word128 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word128 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word128 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word128 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word128 -> m Word128 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word128 -> m Word128 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word128 -> m Word128 #
Num Word128 # |
Methods (+) :: Word128 -> Word128 -> Word128 # (-) :: Word128 -> Word128 -> Word128 # (*) :: Word128 -> Word128 -> Word128 # negate :: Word128 -> Word128 # abs :: Word128 -> Word128 # signum :: Word128 -> Word128 # fromInteger :: Integer -> Word128 #
Ord Word128 # |
Methods compare :: Word128 -> Word128 -> Ordering # (<) :: Word128 -> Word128 -> Bool # (<=) :: Word128 -> Word128 -> Bool # (>) :: Word128 -> Word128 -> Bool # (>=) :: Word128 -> Word128 -> Bool # max :: Word128 -> Word128 -> Word128 # min :: Word128 -> Word128 -> Word128 #
Read Word128 # |
Methods readsPrec :: Int -> ReadS Word128 # readList :: ReadS [Word128] # readPrec :: ReadPrec Word128 # readListPrec :: ReadPrec [Word128] #
Real Word128 # |
Methods toRational :: Word128 -> Rational #
Show Word128 # |
Methods showsPrec :: Int -> Word128 -> ShowS # show :: Word128 -> String # showList :: [Word128] -> ShowS #
Ix Word128 # |
Methods range :: (Word128, Word128) -> [Word128] # index :: (Word128, Word128) -> Word128 -> Int # unsafeIndex :: (Word128, Word128) -> Word128 -> Int inRange :: (Word128, Word128) -> Word128 -> Bool # rangeSize :: (Word128, Word128) -> Int # unsafeRangeSize :: (Word128, Word128) -> Int
Generic Word128 # |
Associated Types type Rep Word128 :: * -> * # Methods from :: Word128 -> Rep Word128 x # to :: Rep Word128 x -> Word128 #
Bits Word128 # |
Methods (.&.) :: Word128 -> Word128 -> Word128 # (.|.) :: Word128 -> Word128 -> Word128 # xor :: Word128 -> Word128 -> Word128 # complement :: Word128 -> Word128 # shift :: Word128 -> Int -> Word128 # rotate :: Word128 -> Int -> Word128 # zeroBits :: Word128 # bit :: Int -> Word128 # setBit :: Word128 -> Int -> Word128 # clearBit :: Word128 -> Int -> Word128 # complementBit :: Word128 -> Int -> Word128 # testBit :: Word128 -> Int -> Bool # bitSizeMaybe :: Word128 -> Maybe Int # bitSize :: Word128 -> Int # isSigned :: Word128 -> Bool # shiftL :: Word128 -> Int -> Word128 # unsafeShiftL :: Word128 -> Int -> Word128 # shiftR :: Word128 -> Int -> Word128 # unsafeShiftR :: Word128 -> Int -> Word128 # rotateL :: Word128 -> Int -> Word128 # rotateR :: Word128 -> Int -> Word128 # popCount :: Word128 -> Int #
FiniteBits Word128 # |
Methods finiteBitSize :: Word128 -> Int # countLeadingZeros :: Word128 -> Int # countTrailingZeros :: Word128 -> Int #
BinaryWord Word128 # |
Associated Types type UnsignedWord Word128 :: * # type SignedWord Word128 :: * # Methods unsignedWord :: Word128 -> UnsignedWord Word128 # signedWord :: Word128 -> SignedWord Word128 # unwrappedAdd :: Word128 -> Word128 -> (Word128, UnsignedWord Word128) # unwrappedMul :: Word128 -> Word128 -> (Word128, UnsignedWord Word128) # leadingZeroes :: Word128 -> Int # trailingZeroes :: Word128 -> Int # allZeroes :: Word128 # allOnes :: Word128 # msb :: Word128 # lsb :: Word128 # testMsb :: Word128 -> Bool # testLsb :: Word128 -> Bool # setMsb :: Word128 -> Word128 # setLsb :: Word128 -> Word128 # clearMsb :: Word128 -> Word128 # clearLsb :: Word128 -> Word128 #
Hashable Word128 # |
Methods hashWithSalt :: Int -> Word128 -> Int # hash :: Word128 -> Int #
DoubleWord Word128 # |
Associated Types type LoWord Word128 :: * # type HiWord Word128 :: * # Methods loWord :: Word128 -> LoWord Word128 # hiWord :: Word128 -> HiWord Word128 # fromHiAndLo :: HiWord Word128 -> LoWord Word128 -> Word128 # extendLo :: LoWord Word128 -> Word128 # signExtendLo :: SignedWord (LoWord Word128) -> Word128 #
type Rep Word128 # |
type Rep Word128 = D1 (MetaData "Word128" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Word128" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64))))
type SignedWord Word128 # |
type SignedWord Word128 = Int128
type UnsignedWord Word128 # |
type UnsignedWord Word128 = Word128
type LoWord Word128 # |
type LoWord Word128 = Word64
type HiWord Word128 # |
type HiWord Word128 = Word64

data Word160 #

Constructors

Word160 !Word32 !Word128 |

Instances

Bounded Word160 # |
Methods minBound :: Word160 # maxBound :: Word160 #
Enum Word160 # |
Methods succ :: Word160 -> Word160 # pred :: Word160 -> Word160 # toEnum :: Int -> Word160 # fromEnum :: Word160 -> Int # enumFrom :: Word160 -> [Word160] # enumFromThen :: Word160 -> Word160 -> [Word160] # enumFromTo :: Word160 -> Word160 -> [Word160] # enumFromThenTo :: Word160 -> Word160 -> Word160 -> [Word160] #
Eq Word160 # |
Methods (==) :: Word160 -> Word160 -> Bool # (/=) :: Word160 -> Word160 -> Bool #
Integral Word160 # |
Methods quot :: Word160 -> Word160 -> Word160 # rem :: Word160 -> Word160 -> Word160 # div :: Word160 -> Word160 -> Word160 # mod :: Word160 -> Word160 -> Word160 # quotRem :: Word160 -> Word160 -> (Word160, Word160) # divMod :: Word160 -> Word160 -> (Word160, Word160) # toInteger :: Word160 -> Integer #
Data Word160 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word160 -> c Word160 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word160 # toConstr :: Word160 -> Constr # dataTypeOf :: Word160 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word160) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word160) # gmapT :: (forall b. Data b => b -> b) -> Word160 -> Word160 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word160 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word160 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word160 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word160 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word160 -> m Word160 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word160 -> m Word160 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word160 -> m Word160 #
Num Word160 # |
Methods (+) :: Word160 -> Word160 -> Word160 # (-) :: Word160 -> Word160 -> Word160 # (*) :: Word160 -> Word160 -> Word160 # negate :: Word160 -> Word160 # abs :: Word160 -> Word160 # signum :: Word160 -> Word160 # fromInteger :: Integer -> Word160 #
Ord Word160 # |
Methods compare :: Word160 -> Word160 -> Ordering # (<) :: Word160 -> Word160 -> Bool # (<=) :: Word160 -> Word160 -> Bool # (>) :: Word160 -> Word160 -> Bool # (>=) :: Word160 -> Word160 -> Bool # max :: Word160 -> Word160 -> Word160 # min :: Word160 -> Word160 -> Word160 #
Read Word160 # |
Methods readsPrec :: Int -> ReadS Word160 # readList :: ReadS [Word160] # readPrec :: ReadPrec Word160 # readListPrec :: ReadPrec [Word160] #
Real Word160 # |
Methods toRational :: Word160 -> Rational #
Show Word160 # |
Methods showsPrec :: Int -> Word160 -> ShowS # show :: Word160 -> String # showList :: [Word160] -> ShowS #
Ix Word160 # |
Methods range :: (Word160, Word160) -> [Word160] # index :: (Word160, Word160) -> Word160 -> Int # unsafeIndex :: (Word160, Word160) -> Word160 -> Int inRange :: (Word160, Word160) -> Word160 -> Bool # rangeSize :: (Word160, Word160) -> Int # unsafeRangeSize :: (Word160, Word160) -> Int
Generic Word160 # |
Associated Types type Rep Word160 :: * -> * # Methods from :: Word160 -> Rep Word160 x # to :: Rep Word160 x -> Word160 #
Bits Word160 # |
Methods (.&.) :: Word160 -> Word160 -> Word160 # (.|.) :: Word160 -> Word160 -> Word160 # xor :: Word160 -> Word160 -> Word160 # complement :: Word160 -> Word160 # shift :: Word160 -> Int -> Word160 # rotate :: Word160 -> Int -> Word160 # zeroBits :: Word160 # bit :: Int -> Word160 # setBit :: Word160 -> Int -> Word160 # clearBit :: Word160 -> Int -> Word160 # complementBit :: Word160 -> Int -> Word160 # testBit :: Word160 -> Int -> Bool # bitSizeMaybe :: Word160 -> Maybe Int # bitSize :: Word160 -> Int # isSigned :: Word160 -> Bool # shiftL :: Word160 -> Int -> Word160 # unsafeShiftL :: Word160 -> Int -> Word160 # shiftR :: Word160 -> Int -> Word160 # unsafeShiftR :: Word160 -> Int -> Word160 # rotateL :: Word160 -> Int -> Word160 # rotateR :: Word160 -> Int -> Word160 # popCount :: Word160 -> Int #
FiniteBits Word160 # |
Methods finiteBitSize :: Word160 -> Int # countLeadingZeros :: Word160 -> Int # countTrailingZeros :: Word160 -> Int #
BinaryWord Word160 # |
Associated Types type UnsignedWord Word160 :: * # type SignedWord Word160 :: * # Methods unsignedWord :: Word160 -> UnsignedWord Word160 # signedWord :: Word160 -> SignedWord Word160 # unwrappedAdd :: Word160 -> Word160 -> (Word160, UnsignedWord Word160) # unwrappedMul :: Word160 -> Word160 -> (Word160, UnsignedWord Word160) # leadingZeroes :: Word160 -> Int # trailingZeroes :: Word160 -> Int # allZeroes :: Word160 # allOnes :: Word160 # msb :: Word160 # lsb :: Word160 # testMsb :: Word160 -> Bool # testLsb :: Word160 -> Bool # setMsb :: Word160 -> Word160 # setLsb :: Word160 -> Word160 # clearMsb :: Word160 -> Word160 # clearLsb :: Word160 -> Word160 #
Hashable Word160 # |
Methods hashWithSalt :: Int -> Word160 -> Int # hash :: Word160 -> Int #
DoubleWord Word160 # |
Associated Types type LoWord Word160 :: * # type HiWord Word160 :: * # Methods loWord :: Word160 -> LoWord Word160 # hiWord :: Word160 -> HiWord Word160 # fromHiAndLo :: HiWord Word160 -> LoWord Word160 -> Word160 # extendLo :: LoWord Word160 -> Word160 # signExtendLo :: SignedWord (LoWord Word160) -> Word160 #
type Rep Word160 # |
type Rep Word160 = D1 (MetaData "Word160" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Word160" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word32)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Word160 # |
type SignedWord Word160 = Int160
type UnsignedWord Word160 # |
type UnsignedWord Word160 = Word160
type LoWord Word160 # |
type LoWord Word160 = Word128
type HiWord Word160 # |
type HiWord Word160 = Word32

data Word192 #

Constructors

Word192 !Word64 !Word128 |

Instances

Bounded Word192 # |
Methods minBound :: Word192 # maxBound :: Word192 #
Enum Word192 # |
Methods succ :: Word192 -> Word192 # pred :: Word192 -> Word192 # toEnum :: Int -> Word192 # fromEnum :: Word192 -> Int # enumFrom :: Word192 -> [Word192] # enumFromThen :: Word192 -> Word192 -> [Word192] # enumFromTo :: Word192 -> Word192 -> [Word192] # enumFromThenTo :: Word192 -> Word192 -> Word192 -> [Word192] #
Eq Word192 # |
Methods (==) :: Word192 -> Word192 -> Bool # (/=) :: Word192 -> Word192 -> Bool #
Integral Word192 # |
Methods quot :: Word192 -> Word192 -> Word192 # rem :: Word192 -> Word192 -> Word192 # div :: Word192 -> Word192 -> Word192 # mod :: Word192 -> Word192 -> Word192 # quotRem :: Word192 -> Word192 -> (Word192, Word192) # divMod :: Word192 -> Word192 -> (Word192, Word192) # toInteger :: Word192 -> Integer #
Data Word192 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word192 -> c Word192 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word192 # toConstr :: Word192 -> Constr # dataTypeOf :: Word192 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word192) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word192) # gmapT :: (forall b. Data b => b -> b) -> Word192 -> Word192 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word192 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word192 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word192 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word192 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word192 -> m Word192 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word192 -> m Word192 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word192 -> m Word192 #
Num Word192 # |
Methods (+) :: Word192 -> Word192 -> Word192 # (-) :: Word192 -> Word192 -> Word192 # (*) :: Word192 -> Word192 -> Word192 # negate :: Word192 -> Word192 # abs :: Word192 -> Word192 # signum :: Word192 -> Word192 # fromInteger :: Integer -> Word192 #
Ord Word192 # |
Methods compare :: Word192 -> Word192 -> Ordering # (<) :: Word192 -> Word192 -> Bool # (<=) :: Word192 -> Word192 -> Bool # (>) :: Word192 -> Word192 -> Bool # (>=) :: Word192 -> Word192 -> Bool # max :: Word192 -> Word192 -> Word192 # min :: Word192 -> Word192 -> Word192 #
Read Word192 # |
Methods readsPrec :: Int -> ReadS Word192 # readList :: ReadS [Word192] # readPrec :: ReadPrec Word192 # readListPrec :: ReadPrec [Word192] #
Real Word192 # |
Methods toRational :: Word192 -> Rational #
Show Word192 # |
Methods showsPrec :: Int -> Word192 -> ShowS # show :: Word192 -> String # showList :: [Word192] -> ShowS #
Ix Word192 # |
Methods range :: (Word192, Word192) -> [Word192] # index :: (Word192, Word192) -> Word192 -> Int # unsafeIndex :: (Word192, Word192) -> Word192 -> Int inRange :: (Word192, Word192) -> Word192 -> Bool # rangeSize :: (Word192, Word192) -> Int # unsafeRangeSize :: (Word192, Word192) -> Int
Generic Word192 # |
Associated Types type Rep Word192 :: * -> * # Methods from :: Word192 -> Rep Word192 x # to :: Rep Word192 x -> Word192 #
Bits Word192 # |
Methods (.&.) :: Word192 -> Word192 -> Word192 # (.|.) :: Word192 -> Word192 -> Word192 # xor :: Word192 -> Word192 -> Word192 # complement :: Word192 -> Word192 # shift :: Word192 -> Int -> Word192 # rotate :: Word192 -> Int -> Word192 # zeroBits :: Word192 # bit :: Int -> Word192 # setBit :: Word192 -> Int -> Word192 # clearBit :: Word192 -> Int -> Word192 # complementBit :: Word192 -> Int -> Word192 # testBit :: Word192 -> Int -> Bool # bitSizeMaybe :: Word192 -> Maybe Int # bitSize :: Word192 -> Int # isSigned :: Word192 -> Bool # shiftL :: Word192 -> Int -> Word192 # unsafeShiftL :: Word192 -> Int -> Word192 # shiftR :: Word192 -> Int -> Word192 # unsafeShiftR :: Word192 -> Int -> Word192 # rotateL :: Word192 -> Int -> Word192 # rotateR :: Word192 -> Int -> Word192 # popCount :: Word192 -> Int #
FiniteBits Word192 # |
Methods finiteBitSize :: Word192 -> Int # countLeadingZeros :: Word192 -> Int # countTrailingZeros :: Word192 -> Int #
BinaryWord Word192 # |
Associated Types type UnsignedWord Word192 :: * # type SignedWord Word192 :: * # Methods unsignedWord :: Word192 -> UnsignedWord Word192 # signedWord :: Word192 -> SignedWord Word192 # unwrappedAdd :: Word192 -> Word192 -> (Word192, UnsignedWord Word192) # unwrappedMul :: Word192 -> Word192 -> (Word192, UnsignedWord Word192) # leadingZeroes :: Word192 -> Int # trailingZeroes :: Word192 -> Int # allZeroes :: Word192 # allOnes :: Word192 # msb :: Word192 # lsb :: Word192 # testMsb :: Word192 -> Bool # testLsb :: Word192 -> Bool # setMsb :: Word192 -> Word192 # setLsb :: Word192 -> Word192 # clearMsb :: Word192 -> Word192 # clearLsb :: Word192 -> Word192 #
Hashable Word192 # |
Methods hashWithSalt :: Int -> Word192 -> Int # hash :: Word192 -> Int #
DoubleWord Word192 # |
Associated Types type LoWord Word192 :: * # type HiWord Word192 :: * # Methods loWord :: Word192 -> LoWord Word192 # hiWord :: Word192 -> HiWord Word192 # fromHiAndLo :: HiWord Word192 -> LoWord Word192 -> Word192 # extendLo :: LoWord Word192 -> Word192 # signExtendLo :: SignedWord (LoWord Word192) -> Word192 #
type Rep Word192 # |
type Rep Word192 = D1 (MetaData "Word192" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Word192" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Word192 # |
type SignedWord Word192 = Int192
type UnsignedWord Word192 # |
type UnsignedWord Word192 = Word192
type LoWord Word192 # |
type LoWord Word192 = Word128
type HiWord Word192 # |
type HiWord Word192 = Word64

data Word224 #

Constructors

Word224 !Word96 !Word128 |

Instances

Bounded Word224 # |
Methods minBound :: Word224 # maxBound :: Word224 #
Enum Word224 # |
Methods succ :: Word224 -> Word224 # pred :: Word224 -> Word224 # toEnum :: Int -> Word224 # fromEnum :: Word224 -> Int # enumFrom :: Word224 -> [Word224] # enumFromThen :: Word224 -> Word224 -> [Word224] # enumFromTo :: Word224 -> Word224 -> [Word224] # enumFromThenTo :: Word224 -> Word224 -> Word224 -> [Word224] #
Eq Word224 # |
Methods (==) :: Word224 -> Word224 -> Bool # (/=) :: Word224 -> Word224 -> Bool #
Integral Word224 # |
Methods quot :: Word224 -> Word224 -> Word224 # rem :: Word224 -> Word224 -> Word224 # div :: Word224 -> Word224 -> Word224 # mod :: Word224 -> Word224 -> Word224 # quotRem :: Word224 -> Word224 -> (Word224, Word224) # divMod :: Word224 -> Word224 -> (Word224, Word224) # toInteger :: Word224 -> Integer #
Data Word224 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word224 -> c Word224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word224 # toConstr :: Word224 -> Constr # dataTypeOf :: Word224 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word224) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word224) # gmapT :: (forall b. Data b => b -> b) -> Word224 -> Word224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word224 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word224 -> m Word224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word224 -> m Word224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word224 -> m Word224 #
Num Word224 # |
Methods (+) :: Word224 -> Word224 -> Word224 # (-) :: Word224 -> Word224 -> Word224 # (*) :: Word224 -> Word224 -> Word224 # negate :: Word224 -> Word224 # abs :: Word224 -> Word224 # signum :: Word224 -> Word224 # fromInteger :: Integer -> Word224 #
Ord Word224 # |
Methods compare :: Word224 -> Word224 -> Ordering # (<) :: Word224 -> Word224 -> Bool # (<=) :: Word224 -> Word224 -> Bool # (>) :: Word224 -> Word224 -> Bool # (>=) :: Word224 -> Word224 -> Bool # max :: Word224 -> Word224 -> Word224 # min :: Word224 -> Word224 -> Word224 #
Read Word224 # |
Methods readsPrec :: Int -> ReadS Word224 # readList :: ReadS [Word224] # readPrec :: ReadPrec Word224 # readListPrec :: ReadPrec [Word224] #
Real Word224 # |
Methods toRational :: Word224 -> Rational #
Show Word224 # |
Methods showsPrec :: Int -> Word224 -> ShowS # show :: Word224 -> String # showList :: [Word224] -> ShowS #
Ix Word224 # |
Methods range :: (Word224, Word224) -> [Word224] # index :: (Word224, Word224) -> Word224 -> Int # unsafeIndex :: (Word224, Word224) -> Word224 -> Int inRange :: (Word224, Word224) -> Word224 -> Bool # rangeSize :: (Word224, Word224) -> Int # unsafeRangeSize :: (Word224, Word224) -> Int
Generic Word224 # |
Associated Types type Rep Word224 :: * -> * # Methods from :: Word224 -> Rep Word224 x # to :: Rep Word224 x -> Word224 #
Bits Word224 # |
Methods (.&.) :: Word224 -> Word224 -> Word224 # (.|.) :: Word224 -> Word224 -> Word224 # xor :: Word224 -> Word224 -> Word224 # complement :: Word224 -> Word224 # shift :: Word224 -> Int -> Word224 # rotate :: Word224 -> Int -> Word224 # zeroBits :: Word224 # bit :: Int -> Word224 # setBit :: Word224 -> Int -> Word224 # clearBit :: Word224 -> Int -> Word224 # complementBit :: Word224 -> Int -> Word224 # testBit :: Word224 -> Int -> Bool # bitSizeMaybe :: Word224 -> Maybe Int # bitSize :: Word224 -> Int # isSigned :: Word224 -> Bool # shiftL :: Word224 -> Int -> Word224 # unsafeShiftL :: Word224 -> Int -> Word224 # shiftR :: Word224 -> Int -> Word224 # unsafeShiftR :: Word224 -> Int -> Word224 # rotateL :: Word224 -> Int -> Word224 # rotateR :: Word224 -> Int -> Word224 # popCount :: Word224 -> Int #
FiniteBits Word224 # |
Methods finiteBitSize :: Word224 -> Int # countLeadingZeros :: Word224 -> Int # countTrailingZeros :: Word224 -> Int #
BinaryWord Word224 # |
Associated Types type UnsignedWord Word224 :: * # type SignedWord Word224 :: * # Methods unsignedWord :: Word224 -> UnsignedWord Word224 # signedWord :: Word224 -> SignedWord Word224 # unwrappedAdd :: Word224 -> Word224 -> (Word224, UnsignedWord Word224) # unwrappedMul :: Word224 -> Word224 -> (Word224, UnsignedWord Word224) # leadingZeroes :: Word224 -> Int # trailingZeroes :: Word224 -> Int # allZeroes :: Word224 # allOnes :: Word224 # msb :: Word224 # lsb :: Word224 # testMsb :: Word224 -> Bool # testLsb :: Word224 -> Bool # setMsb :: Word224 -> Word224 # setLsb :: Word224 -> Word224 # clearMsb :: Word224 -> Word224 # clearLsb :: Word224 -> Word224 #
Hashable Word224 # |
Methods hashWithSalt :: Int -> Word224 -> Int # hash :: Word224 -> Int #
DoubleWord Word224 # |
Associated Types type LoWord Word224 :: * # type HiWord Word224 :: * # Methods loWord :: Word224 -> LoWord Word224 # hiWord :: Word224 -> HiWord Word224 # fromHiAndLo :: HiWord Word224 -> LoWord Word224 -> Word224 # extendLo :: LoWord Word224 -> Word224 # signExtendLo :: SignedWord (LoWord Word224) -> Word224 #
type Rep Word224 # |
type Rep Word224 = D1 (MetaData "Word224" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Word224" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word96)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Word224 # |
type SignedWord Word224 = Int224
type UnsignedWord Word224 # |
type UnsignedWord Word224 = Word224
type LoWord Word224 # |
type LoWord Word224 = Word128
type HiWord Word224 # |
type HiWord Word224 = Word96

data Word256 #

Constructors

Word256 !Word128 !Word128 |

Instances

Bounded Word256 # |
Methods minBound :: Word256 # maxBound :: Word256 #
Enum Word256 # |
Methods succ :: Word256 -> Word256 # pred :: Word256 -> Word256 # toEnum :: Int -> Word256 # fromEnum :: Word256 -> Int # enumFrom :: Word256 -> [Word256] # enumFromThen :: Word256 -> Word256 -> [Word256] # enumFromTo :: Word256 -> Word256 -> [Word256] # enumFromThenTo :: Word256 -> Word256 -> Word256 -> [Word256] #
Eq Word256 # |
Methods (==) :: Word256 -> Word256 -> Bool # (/=) :: Word256 -> Word256 -> Bool #
Integral Word256 # |
Methods quot :: Word256 -> Word256 -> Word256 # rem :: Word256 -> Word256 -> Word256 # div :: Word256 -> Word256 -> Word256 # mod :: Word256 -> Word256 -> Word256 # quotRem :: Word256 -> Word256 -> (Word256, Word256) # divMod :: Word256 -> Word256 -> (Word256, Word256) # toInteger :: Word256 -> Integer #
Data Word256 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word256 -> c Word256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word256 # toConstr :: Word256 -> Constr # dataTypeOf :: Word256 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word256) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word256) # gmapT :: (forall b. Data b => b -> b) -> Word256 -> Word256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word256 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word256 -> m Word256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word256 -> m Word256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word256 -> m Word256 #
Num Word256 # |
Methods (+) :: Word256 -> Word256 -> Word256 # (-) :: Word256 -> Word256 -> Word256 # (*) :: Word256 -> Word256 -> Word256 # negate :: Word256 -> Word256 # abs :: Word256 -> Word256 # signum :: Word256 -> Word256 # fromInteger :: Integer -> Word256 #
Ord Word256 # |
Methods compare :: Word256 -> Word256 -> Ordering # (<) :: Word256 -> Word256 -> Bool # (<=) :: Word256 -> Word256 -> Bool # (>) :: Word256 -> Word256 -> Bool # (>=) :: Word256 -> Word256 -> Bool # max :: Word256 -> Word256 -> Word256 # min :: Word256 -> Word256 -> Word256 #
Read Word256 # |
Methods readsPrec :: Int -> ReadS Word256 # readList :: ReadS [Word256] # readPrec :: ReadPrec Word256 # readListPrec :: ReadPrec [Word256] #
Real Word256 # |
Methods toRational :: Word256 -> Rational #
Show Word256 # |
Methods showsPrec :: Int -> Word256 -> ShowS # show :: Word256 -> String # showList :: [Word256] -> ShowS #
Ix Word256 # |
Methods range :: (Word256, Word256) -> [Word256] # index :: (Word256, Word256) -> Word256 -> Int # unsafeIndex :: (Word256, Word256) -> Word256 -> Int inRange :: (Word256, Word256) -> Word256 -> Bool # rangeSize :: (Word256, Word256) -> Int # unsafeRangeSize :: (Word256, Word256) -> Int
Generic Word256 # |
Associated Types type Rep Word256 :: * -> * # Methods from :: Word256 -> Rep Word256 x # to :: Rep Word256 x -> Word256 #
Bits Word256 # |
Methods (.&.) :: Word256 -> Word256 -> Word256 # (.|.) :: Word256 -> Word256 -> Word256 # xor :: Word256 -> Word256 -> Word256 # complement :: Word256 -> Word256 # shift :: Word256 -> Int -> Word256 # rotate :: Word256 -> Int -> Word256 # zeroBits :: Word256 # bit :: Int -> Word256 # setBit :: Word256 -> Int -> Word256 # clearBit :: Word256 -> Int -> Word256 # complementBit :: Word256 -> Int -> Word256 # testBit :: Word256 -> Int -> Bool # bitSizeMaybe :: Word256 -> Maybe Int # bitSize :: Word256 -> Int # isSigned :: Word256 -> Bool # shiftL :: Word256 -> Int -> Word256 # unsafeShiftL :: Word256 -> Int -> Word256 # shiftR :: Word256 -> Int -> Word256 # unsafeShiftR :: Word256 -> Int -> Word256 # rotateL :: Word256 -> Int -> Word256 # rotateR :: Word256 -> Int -> Word256 # popCount :: Word256 -> Int #
FiniteBits Word256 # |
Methods finiteBitSize :: Word256 -> Int # countLeadingZeros :: Word256 -> Int # countTrailingZeros :: Word256 -> Int #
BinaryWord Word256 # |
Associated Types type UnsignedWord Word256 :: * # type SignedWord Word256 :: * # Methods unsignedWord :: Word256 -> UnsignedWord Word256 # signedWord :: Word256 -> SignedWord Word256 # unwrappedAdd :: Word256 -> Word256 -> (Word256, UnsignedWord Word256) # unwrappedMul :: Word256 -> Word256 -> (Word256, UnsignedWord Word256) # leadingZeroes :: Word256 -> Int # trailingZeroes :: Word256 -> Int # allZeroes :: Word256 # allOnes :: Word256 # msb :: Word256 # lsb :: Word256 # testMsb :: Word256 -> Bool # testLsb :: Word256 -> Bool # setMsb :: Word256 -> Word256 # setLsb :: Word256 -> Word256 # clearMsb :: Word256 -> Word256 # clearLsb :: Word256 -> Word256 #
Hashable Word256 # |
Methods hashWithSalt :: Int -> Word256 -> Int # hash :: Word256 -> Int #
DoubleWord Word256 # |
Associated Types type LoWord Word256 :: * # type HiWord Word256 :: * # Methods loWord :: Word256 -> LoWord Word256 # hiWord :: Word256 -> HiWord Word256 # fromHiAndLo :: HiWord Word256 -> LoWord Word256 -> Word256 # extendLo :: LoWord Word256 -> Word256 # signExtendLo :: SignedWord (LoWord Word256) -> Word256 #
type Rep Word256 # |
type Rep Word256 = D1 (MetaData "Word256" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Word256" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Word256 # |
type SignedWord Word256 = Int256
type UnsignedWord Word256 # |
type UnsignedWord Word256 = Word256
type LoWord Word256 # |
type LoWord Word256 = Word128
type HiWord Word256 # |
type HiWord Word256 = Word128

data Int96 #

Constructors

Int96 !Int32 !Word64 |

Instances

Bounded Int96 # |
Methods minBound :: Int96 # maxBound :: Int96 #
Enum Int96 # |
Methods succ :: Int96 -> Int96 # pred :: Int96 -> Int96 # toEnum :: Int -> Int96 # fromEnum :: Int96 -> Int # enumFrom :: Int96 -> [Int96] # enumFromThen :: Int96 -> Int96 -> [Int96] # enumFromTo :: Int96 -> Int96 -> [Int96] # enumFromThenTo :: Int96 -> Int96 -> Int96 -> [Int96] #
Eq Int96 # |
Methods (==) :: Int96 -> Int96 -> Bool # (/=) :: Int96 -> Int96 -> Bool #
Integral Int96 # |
Methods quot :: Int96 -> Int96 -> Int96 # rem :: Int96 -> Int96 -> Int96 # div :: Int96 -> Int96 -> Int96 # mod :: Int96 -> Int96 -> Int96 # quotRem :: Int96 -> Int96 -> (Int96, Int96) # divMod :: Int96 -> Int96 -> (Int96, Int96) # toInteger :: Int96 -> Integer #
Data Int96 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int96 -> c Int96 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int96 # toConstr :: Int96 -> Constr # dataTypeOf :: Int96 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int96) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int96) # gmapT :: (forall b. Data b => b -> b) -> Int96 -> Int96 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int96 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int96 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int96 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int96 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int96 -> m Int96 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int96 -> m Int96 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int96 -> m Int96 #
Num Int96 # |
Methods (+) :: Int96 -> Int96 -> Int96 # (-) :: Int96 -> Int96 -> Int96 # (*) :: Int96 -> Int96 -> Int96 # negate :: Int96 -> Int96 # abs :: Int96 -> Int96 # signum :: Int96 -> Int96 # fromInteger :: Integer -> Int96 #
Ord Int96 # |
Methods compare :: Int96 -> Int96 -> Ordering # (<) :: Int96 -> Int96 -> Bool # (<=) :: Int96 -> Int96 -> Bool # (>) :: Int96 -> Int96 -> Bool # (>=) :: Int96 -> Int96 -> Bool # max :: Int96 -> Int96 -> Int96 # min :: Int96 -> Int96 -> Int96 #
Read Int96 # |
Methods readsPrec :: Int -> ReadS Int96 # readList :: ReadS [Int96] # readPrec :: ReadPrec Int96 # readListPrec :: ReadPrec [Int96] #
Real Int96 # |
Methods toRational :: Int96 -> Rational #
Show Int96 # |
Methods showsPrec :: Int -> Int96 -> ShowS # show :: Int96 -> String # showList :: [Int96] -> ShowS #
Ix Int96 # |
Methods range :: (Int96, Int96) -> [Int96] # index :: (Int96, Int96) -> Int96 -> Int # unsafeIndex :: (Int96, Int96) -> Int96 -> Int inRange :: (Int96, Int96) -> Int96 -> Bool # rangeSize :: (Int96, Int96) -> Int # unsafeRangeSize :: (Int96, Int96) -> Int
Generic Int96 # |
Associated Types type Rep Int96 :: * -> * # Methods from :: Int96 -> Rep Int96 x # to :: Rep Int96 x -> Int96 #
Bits Int96 # |
Methods (.&.) :: Int96 -> Int96 -> Int96 # (.|.) :: Int96 -> Int96 -> Int96 # xor :: Int96 -> Int96 -> Int96 # complement :: Int96 -> Int96 # shift :: Int96 -> Int -> Int96 # rotate :: Int96 -> Int -> Int96 # zeroBits :: Int96 # bit :: Int -> Int96 # setBit :: Int96 -> Int -> Int96 # clearBit :: Int96 -> Int -> Int96 # complementBit :: Int96 -> Int -> Int96 # testBit :: Int96 -> Int -> Bool # bitSizeMaybe :: Int96 -> Maybe Int # bitSize :: Int96 -> Int # isSigned :: Int96 -> Bool # shiftL :: Int96 -> Int -> Int96 # unsafeShiftL :: Int96 -> Int -> Int96 # shiftR :: Int96 -> Int -> Int96 # unsafeShiftR :: Int96 -> Int -> Int96 # rotateL :: Int96 -> Int -> Int96 # rotateR :: Int96 -> Int -> Int96 # popCount :: Int96 -> Int #
FiniteBits Int96 # |
Methods finiteBitSize :: Int96 -> Int # countLeadingZeros :: Int96 -> Int # countTrailingZeros :: Int96 -> Int #
BinaryWord Int96 # |
Associated Types type UnsignedWord Int96 :: * # type SignedWord Int96 :: * # Methods unsignedWord :: Int96 -> UnsignedWord Int96 # signedWord :: Int96 -> SignedWord Int96 # unwrappedAdd :: Int96 -> Int96 -> (Int96, UnsignedWord Int96) # unwrappedMul :: Int96 -> Int96 -> (Int96, UnsignedWord Int96) # leadingZeroes :: Int96 -> Int # trailingZeroes :: Int96 -> Int # allZeroes :: Int96 # allOnes :: Int96 # msb :: Int96 # lsb :: Int96 # testMsb :: Int96 -> Bool # testLsb :: Int96 -> Bool # setMsb :: Int96 -> Int96 # setLsb :: Int96 -> Int96 # clearMsb :: Int96 -> Int96 # clearLsb :: Int96 -> Int96 #
Hashable Int96 # |
Methods hashWithSalt :: Int -> Int96 -> Int # hash :: Int96 -> Int #
DoubleWord Int96 # |
Associated Types type LoWord Int96 :: * # type HiWord Int96 :: * # Methods loWord :: Int96 -> LoWord Int96 # hiWord :: Int96 -> HiWord Int96 # fromHiAndLo :: HiWord Int96 -> LoWord Int96 -> Int96 # extendLo :: LoWord Int96 -> Int96 # signExtendLo :: SignedWord (LoWord Int96) -> Int96 #
type Rep Int96 # |
type Rep Int96 = D1 (MetaData "Int96" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Int96" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int32)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64))))
type SignedWord Int96 # |
type SignedWord Int96 = Int96
type UnsignedWord Int96 # |
type UnsignedWord Int96 = Word96
type LoWord Int96 # |
type LoWord Int96 = Word64
type HiWord Int96 # |
type HiWord Int96 = Int32

data Int128 #

Constructors

Int128 !Int64 !Word64 |

Instances

Bounded Int128 # |
Methods minBound :: Int128 # maxBound :: Int128 #
Enum Int128 # |
Methods succ :: Int128 -> Int128 # pred :: Int128 -> Int128 # toEnum :: Int -> Int128 # fromEnum :: Int128 -> Int # enumFrom :: Int128 -> [Int128] # enumFromThen :: Int128 -> Int128 -> [Int128] # enumFromTo :: Int128 -> Int128 -> [Int128] # enumFromThenTo :: Int128 -> Int128 -> Int128 -> [Int128] #
Eq Int128 # |
Methods (==) :: Int128 -> Int128 -> Bool # (/=) :: Int128 -> Int128 -> Bool #
Integral Int128 # |
Methods quot :: Int128 -> Int128 -> Int128 # rem :: Int128 -> Int128 -> Int128 # div :: Int128 -> Int128 -> Int128 # mod :: Int128 -> Int128 -> Int128 # quotRem :: Int128 -> Int128 -> (Int128, Int128) # divMod :: Int128 -> Int128 -> (Int128, Int128) # toInteger :: Int128 -> Integer #
Data Int128 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int128 -> c Int128 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int128 # toConstr :: Int128 -> Constr # dataTypeOf :: Int128 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int128) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int128) # gmapT :: (forall b. Data b => b -> b) -> Int128 -> Int128 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int128 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int128 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int128 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int128 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int128 -> m Int128 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int128 -> m Int128 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int128 -> m Int128 #
Num Int128 # |
Methods (+) :: Int128 -> Int128 -> Int128 # (-) :: Int128 -> Int128 -> Int128 # (*) :: Int128 -> Int128 -> Int128 # negate :: Int128 -> Int128 # abs :: Int128 -> Int128 # signum :: Int128 -> Int128 # fromInteger :: Integer -> Int128 #
Ord Int128 # |
Methods compare :: Int128 -> Int128 -> Ordering # (<) :: Int128 -> Int128 -> Bool # (<=) :: Int128 -> Int128 -> Bool # (>) :: Int128 -> Int128 -> Bool # (>=) :: Int128 -> Int128 -> Bool # max :: Int128 -> Int128 -> Int128 # min :: Int128 -> Int128 -> Int128 #
Read Int128 # |
Methods readsPrec :: Int -> ReadS Int128 # readList :: ReadS [Int128] # readPrec :: ReadPrec Int128 # readListPrec :: ReadPrec [Int128] #
Real Int128 # |
Methods toRational :: Int128 -> Rational #
Show Int128 # |
Methods showsPrec :: Int -> Int128 -> ShowS # show :: Int128 -> String # showList :: [Int128] -> ShowS #
Ix Int128 # |
Methods range :: (Int128, Int128) -> [Int128] # index :: (Int128, Int128) -> Int128 -> Int # unsafeIndex :: (Int128, Int128) -> Int128 -> Int inRange :: (Int128, Int128) -> Int128 -> Bool # rangeSize :: (Int128, Int128) -> Int # unsafeRangeSize :: (Int128, Int128) -> Int
Generic Int128 # |
Associated Types type Rep Int128 :: * -> * # Methods from :: Int128 -> Rep Int128 x # to :: Rep Int128 x -> Int128 #
Bits Int128 # |
Methods (.&.) :: Int128 -> Int128 -> Int128 # (.|.) :: Int128 -> Int128 -> Int128 # xor :: Int128 -> Int128 -> Int128 # complement :: Int128 -> Int128 # shift :: Int128 -> Int -> Int128 # rotate :: Int128 -> Int -> Int128 # zeroBits :: Int128 # bit :: Int -> Int128 # setBit :: Int128 -> Int -> Int128 # clearBit :: Int128 -> Int -> Int128 # complementBit :: Int128 -> Int -> Int128 # testBit :: Int128 -> Int -> Bool # bitSizeMaybe :: Int128 -> Maybe Int # bitSize :: Int128 -> Int # isSigned :: Int128 -> Bool # shiftL :: Int128 -> Int -> Int128 # unsafeShiftL :: Int128 -> Int -> Int128 # shiftR :: Int128 -> Int -> Int128 # unsafeShiftR :: Int128 -> Int -> Int128 # rotateL :: Int128 -> Int -> Int128 # rotateR :: Int128 -> Int -> Int128 # popCount :: Int128 -> Int #
FiniteBits Int128 # |
Methods finiteBitSize :: Int128 -> Int # countLeadingZeros :: Int128 -> Int # countTrailingZeros :: Int128 -> Int #
BinaryWord Int128 # |
Associated Types type UnsignedWord Int128 :: * # type SignedWord Int128 :: * # Methods unsignedWord :: Int128 -> UnsignedWord Int128 # signedWord :: Int128 -> SignedWord Int128 # unwrappedAdd :: Int128 -> Int128 -> (Int128, UnsignedWord Int128) # unwrappedMul :: Int128 -> Int128 -> (Int128, UnsignedWord Int128) # leadingZeroes :: Int128 -> Int # trailingZeroes :: Int128 -> Int # allZeroes :: Int128 # allOnes :: Int128 # msb :: Int128 # lsb :: Int128 # testMsb :: Int128 -> Bool # testLsb :: Int128 -> Bool # setMsb :: Int128 -> Int128 # setLsb :: Int128 -> Int128 # clearMsb :: Int128 -> Int128 # clearLsb :: Int128 -> Int128 #
Hashable Int128 # |
Methods hashWithSalt :: Int -> Int128 -> Int # hash :: Int128 -> Int #
DoubleWord Int128 # |
Associated Types type LoWord Int128 :: * # type HiWord Int128 :: * # Methods loWord :: Int128 -> LoWord Int128 # hiWord :: Int128 -> HiWord Int128 # fromHiAndLo :: HiWord Int128 -> LoWord Int128 -> Int128 # extendLo :: LoWord Int128 -> Int128 # signExtendLo :: SignedWord (LoWord Int128) -> Int128 #
type Rep Int128 # |
type Rep Int128 = D1 (MetaData "Int128" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Int128" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int64)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word64))))
type SignedWord Int128 # |
type SignedWord Int128 = Int128
type UnsignedWord Int128 # |
type UnsignedWord Int128 = Word128
type LoWord Int128 # |
type LoWord Int128 = Word64
type HiWord Int128 # |
type HiWord Int128 = Int64

data Int160 #

Constructors

Int160 !Int32 !Word128 |

Instances

Bounded Int160 # |
Methods minBound :: Int160 # maxBound :: Int160 #
Enum Int160 # |
Methods succ :: Int160 -> Int160 # pred :: Int160 -> Int160 # toEnum :: Int -> Int160 # fromEnum :: Int160 -> Int # enumFrom :: Int160 -> [Int160] # enumFromThen :: Int160 -> Int160 -> [Int160] # enumFromTo :: Int160 -> Int160 -> [Int160] # enumFromThenTo :: Int160 -> Int160 -> Int160 -> [Int160] #
Eq Int160 # |
Methods (==) :: Int160 -> Int160 -> Bool # (/=) :: Int160 -> Int160 -> Bool #
Integral Int160 # |
Methods quot :: Int160 -> Int160 -> Int160 # rem :: Int160 -> Int160 -> Int160 # div :: Int160 -> Int160 -> Int160 # mod :: Int160 -> Int160 -> Int160 # quotRem :: Int160 -> Int160 -> (Int160, Int160) # divMod :: Int160 -> Int160 -> (Int160, Int160) # toInteger :: Int160 -> Integer #
Data Int160 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int160 -> c Int160 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int160 # toConstr :: Int160 -> Constr # dataTypeOf :: Int160 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int160) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int160) # gmapT :: (forall b. Data b => b -> b) -> Int160 -> Int160 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int160 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int160 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int160 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int160 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int160 -> m Int160 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int160 -> m Int160 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int160 -> m Int160 #
Num Int160 # |
Methods (+) :: Int160 -> Int160 -> Int160 # (-) :: Int160 -> Int160 -> Int160 # (*) :: Int160 -> Int160 -> Int160 # negate :: Int160 -> Int160 # abs :: Int160 -> Int160 # signum :: Int160 -> Int160 # fromInteger :: Integer -> Int160 #
Ord Int160 # |
Methods compare :: Int160 -> Int160 -> Ordering # (<) :: Int160 -> Int160 -> Bool # (<=) :: Int160 -> Int160 -> Bool # (>) :: Int160 -> Int160 -> Bool # (>=) :: Int160 -> Int160 -> Bool # max :: Int160 -> Int160 -> Int160 # min :: Int160 -> Int160 -> Int160 #
Read Int160 # |
Methods readsPrec :: Int -> ReadS Int160 # readList :: ReadS [Int160] # readPrec :: ReadPrec Int160 # readListPrec :: ReadPrec [Int160] #
Real Int160 # |
Methods toRational :: Int160 -> Rational #
Show Int160 # |
Methods showsPrec :: Int -> Int160 -> ShowS # show :: Int160 -> String # showList :: [Int160] -> ShowS #
Ix Int160 # |
Methods range :: (Int160, Int160) -> [Int160] # index :: (Int160, Int160) -> Int160 -> Int # unsafeIndex :: (Int160, Int160) -> Int160 -> Int inRange :: (Int160, Int160) -> Int160 -> Bool # rangeSize :: (Int160, Int160) -> Int # unsafeRangeSize :: (Int160, Int160) -> Int
Generic Int160 # |
Associated Types type Rep Int160 :: * -> * # Methods from :: Int160 -> Rep Int160 x # to :: Rep Int160 x -> Int160 #
Bits Int160 # |
Methods (.&.) :: Int160 -> Int160 -> Int160 # (.|.) :: Int160 -> Int160 -> Int160 # xor :: Int160 -> Int160 -> Int160 # complement :: Int160 -> Int160 # shift :: Int160 -> Int -> Int160 # rotate :: Int160 -> Int -> Int160 # zeroBits :: Int160 # bit :: Int -> Int160 # setBit :: Int160 -> Int -> Int160 # clearBit :: Int160 -> Int -> Int160 # complementBit :: Int160 -> Int -> Int160 # testBit :: Int160 -> Int -> Bool # bitSizeMaybe :: Int160 -> Maybe Int # bitSize :: Int160 -> Int # isSigned :: Int160 -> Bool # shiftL :: Int160 -> Int -> Int160 # unsafeShiftL :: Int160 -> Int -> Int160 # shiftR :: Int160 -> Int -> Int160 # unsafeShiftR :: Int160 -> Int -> Int160 # rotateL :: Int160 -> Int -> Int160 # rotateR :: Int160 -> Int -> Int160 # popCount :: Int160 -> Int #
FiniteBits Int160 # |
Methods finiteBitSize :: Int160 -> Int # countLeadingZeros :: Int160 -> Int # countTrailingZeros :: Int160 -> Int #
BinaryWord Int160 # |
Associated Types type UnsignedWord Int160 :: * # type SignedWord Int160 :: * # Methods unsignedWord :: Int160 -> UnsignedWord Int160 # signedWord :: Int160 -> SignedWord Int160 # unwrappedAdd :: Int160 -> Int160 -> (Int160, UnsignedWord Int160) # unwrappedMul :: Int160 -> Int160 -> (Int160, UnsignedWord Int160) # leadingZeroes :: Int160 -> Int # trailingZeroes :: Int160 -> Int # allZeroes :: Int160 # allOnes :: Int160 # msb :: Int160 # lsb :: Int160 # testMsb :: Int160 -> Bool # testLsb :: Int160 -> Bool # setMsb :: Int160 -> Int160 # setLsb :: Int160 -> Int160 # clearMsb :: Int160 -> Int160 # clearLsb :: Int160 -> Int160 #
Hashable Int160 # |
Methods hashWithSalt :: Int -> Int160 -> Int # hash :: Int160 -> Int #
DoubleWord Int160 # |
Associated Types type LoWord Int160 :: * # type HiWord Int160 :: * # Methods loWord :: Int160 -> LoWord Int160 # hiWord :: Int160 -> HiWord Int160 # fromHiAndLo :: HiWord Int160 -> LoWord Int160 -> Int160 # extendLo :: LoWord Int160 -> Int160 # signExtendLo :: SignedWord (LoWord Int160) -> Int160 #
type Rep Int160 # |
type Rep Int160 = D1 (MetaData "Int160" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Int160" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int32)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Int160 # |
type SignedWord Int160 = Int160
type UnsignedWord Int160 # |
type UnsignedWord Int160 = Word160
type LoWord Int160 # |
type LoWord Int160 = Word128
type HiWord Int160 # |
type HiWord Int160 = Int32

data Int192 #

Constructors

Int192 !Int64 !Word128 |

Instances

Bounded Int192 # |
Methods minBound :: Int192 # maxBound :: Int192 #
Enum Int192 # |
Methods succ :: Int192 -> Int192 # pred :: Int192 -> Int192 # toEnum :: Int -> Int192 # fromEnum :: Int192 -> Int # enumFrom :: Int192 -> [Int192] # enumFromThen :: Int192 -> Int192 -> [Int192] # enumFromTo :: Int192 -> Int192 -> [Int192] # enumFromThenTo :: Int192 -> Int192 -> Int192 -> [Int192] #
Eq Int192 # |
Methods (==) :: Int192 -> Int192 -> Bool # (/=) :: Int192 -> Int192 -> Bool #
Integral Int192 # |
Methods quot :: Int192 -> Int192 -> Int192 # rem :: Int192 -> Int192 -> Int192 # div :: Int192 -> Int192 -> Int192 # mod :: Int192 -> Int192 -> Int192 # quotRem :: Int192 -> Int192 -> (Int192, Int192) # divMod :: Int192 -> Int192 -> (Int192, Int192) # toInteger :: Int192 -> Integer #
Data Int192 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int192 -> c Int192 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int192 # toConstr :: Int192 -> Constr # dataTypeOf :: Int192 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int192) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int192) # gmapT :: (forall b. Data b => b -> b) -> Int192 -> Int192 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int192 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int192 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int192 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int192 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int192 -> m Int192 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int192 -> m Int192 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int192 -> m Int192 #
Num Int192 # |
Methods (+) :: Int192 -> Int192 -> Int192 # (-) :: Int192 -> Int192 -> Int192 # (*) :: Int192 -> Int192 -> Int192 # negate :: Int192 -> Int192 # abs :: Int192 -> Int192 # signum :: Int192 -> Int192 # fromInteger :: Integer -> Int192 #
Ord Int192 # |
Methods compare :: Int192 -> Int192 -> Ordering # (<) :: Int192 -> Int192 -> Bool # (<=) :: Int192 -> Int192 -> Bool # (>) :: Int192 -> Int192 -> Bool # (>=) :: Int192 -> Int192 -> Bool # max :: Int192 -> Int192 -> Int192 # min :: Int192 -> Int192 -> Int192 #
Read Int192 # |
Methods readsPrec :: Int -> ReadS Int192 # readList :: ReadS [Int192] # readPrec :: ReadPrec Int192 # readListPrec :: ReadPrec [Int192] #
Real Int192 # |
Methods toRational :: Int192 -> Rational #
Show Int192 # |
Methods showsPrec :: Int -> Int192 -> ShowS # show :: Int192 -> String # showList :: [Int192] -> ShowS #
Ix Int192 # |
Methods range :: (Int192, Int192) -> [Int192] # index :: (Int192, Int192) -> Int192 -> Int # unsafeIndex :: (Int192, Int192) -> Int192 -> Int inRange :: (Int192, Int192) -> Int192 -> Bool # rangeSize :: (Int192, Int192) -> Int # unsafeRangeSize :: (Int192, Int192) -> Int
Generic Int192 # |
Associated Types type Rep Int192 :: * -> * # Methods from :: Int192 -> Rep Int192 x # to :: Rep Int192 x -> Int192 #
Bits Int192 # |
Methods (.&.) :: Int192 -> Int192 -> Int192 # (.|.) :: Int192 -> Int192 -> Int192 # xor :: Int192 -> Int192 -> Int192 # complement :: Int192 -> Int192 # shift :: Int192 -> Int -> Int192 # rotate :: Int192 -> Int -> Int192 # zeroBits :: Int192 # bit :: Int -> Int192 # setBit :: Int192 -> Int -> Int192 # clearBit :: Int192 -> Int -> Int192 # complementBit :: Int192 -> Int -> Int192 # testBit :: Int192 -> Int -> Bool # bitSizeMaybe :: Int192 -> Maybe Int # bitSize :: Int192 -> Int # isSigned :: Int192 -> Bool # shiftL :: Int192 -> Int -> Int192 # unsafeShiftL :: Int192 -> Int -> Int192 # shiftR :: Int192 -> Int -> Int192 # unsafeShiftR :: Int192 -> Int -> Int192 # rotateL :: Int192 -> Int -> Int192 # rotateR :: Int192 -> Int -> Int192 # popCount :: Int192 -> Int #
FiniteBits Int192 # |
Methods finiteBitSize :: Int192 -> Int # countLeadingZeros :: Int192 -> Int # countTrailingZeros :: Int192 -> Int #
BinaryWord Int192 # |
Associated Types type UnsignedWord Int192 :: * # type SignedWord Int192 :: * # Methods unsignedWord :: Int192 -> UnsignedWord Int192 # signedWord :: Int192 -> SignedWord Int192 # unwrappedAdd :: Int192 -> Int192 -> (Int192, UnsignedWord Int192) # unwrappedMul :: Int192 -> Int192 -> (Int192, UnsignedWord Int192) # leadingZeroes :: Int192 -> Int # trailingZeroes :: Int192 -> Int # allZeroes :: Int192 # allOnes :: Int192 # msb :: Int192 # lsb :: Int192 # testMsb :: Int192 -> Bool # testLsb :: Int192 -> Bool # setMsb :: Int192 -> Int192 # setLsb :: Int192 -> Int192 # clearMsb :: Int192 -> Int192 # clearLsb :: Int192 -> Int192 #
Hashable Int192 # |
Methods hashWithSalt :: Int -> Int192 -> Int # hash :: Int192 -> Int #
DoubleWord Int192 # |
Associated Types type LoWord Int192 :: * # type HiWord Int192 :: * # Methods loWord :: Int192 -> LoWord Int192 # hiWord :: Int192 -> HiWord Int192 # fromHiAndLo :: HiWord Int192 -> LoWord Int192 -> Int192 # extendLo :: LoWord Int192 -> Int192 # signExtendLo :: SignedWord (LoWord Int192) -> Int192 #
type Rep Int192 # |
type Rep Int192 = D1 (MetaData "Int192" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Int192" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int64)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Int192 # |
type SignedWord Int192 = Int192
type UnsignedWord Int192 # |
type UnsignedWord Int192 = Word192
type LoWord Int192 # |
type LoWord Int192 = Word128
type HiWord Int192 # |
type HiWord Int192 = Int64

data Int224 #

Constructors

Int224 !Int96 !Word128 |

Instances

Bounded Int224 # |
Methods minBound :: Int224 # maxBound :: Int224 #
Enum Int224 # |
Methods succ :: Int224 -> Int224 # pred :: Int224 -> Int224 # toEnum :: Int -> Int224 # fromEnum :: Int224 -> Int # enumFrom :: Int224 -> [Int224] # enumFromThen :: Int224 -> Int224 -> [Int224] # enumFromTo :: Int224 -> Int224 -> [Int224] # enumFromThenTo :: Int224 -> Int224 -> Int224 -> [Int224] #
Eq Int224 # |
Methods (==) :: Int224 -> Int224 -> Bool # (/=) :: Int224 -> Int224 -> Bool #
Integral Int224 # |
Methods quot :: Int224 -> Int224 -> Int224 # rem :: Int224 -> Int224 -> Int224 # div :: Int224 -> Int224 -> Int224 # mod :: Int224 -> Int224 -> Int224 # quotRem :: Int224 -> Int224 -> (Int224, Int224) # divMod :: Int224 -> Int224 -> (Int224, Int224) # toInteger :: Int224 -> Integer #
Data Int224 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int224 -> c Int224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int224 # toConstr :: Int224 -> Constr # dataTypeOf :: Int224 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int224) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int224) # gmapT :: (forall b. Data b => b -> b) -> Int224 -> Int224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int224 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int224 -> m Int224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int224 -> m Int224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int224 -> m Int224 #
Num Int224 # |
Methods (+) :: Int224 -> Int224 -> Int224 # (-) :: Int224 -> Int224 -> Int224 # (*) :: Int224 -> Int224 -> Int224 # negate :: Int224 -> Int224 # abs :: Int224 -> Int224 # signum :: Int224 -> Int224 # fromInteger :: Integer -> Int224 #
Ord Int224 # |
Methods compare :: Int224 -> Int224 -> Ordering # (<) :: Int224 -> Int224 -> Bool # (<=) :: Int224 -> Int224 -> Bool # (>) :: Int224 -> Int224 -> Bool # (>=) :: Int224 -> Int224 -> Bool # max :: Int224 -> Int224 -> Int224 # min :: Int224 -> Int224 -> Int224 #
Read Int224 # |
Methods readsPrec :: Int -> ReadS Int224 # readList :: ReadS [Int224] # readPrec :: ReadPrec Int224 # readListPrec :: ReadPrec [Int224] #
Real Int224 # |
Methods toRational :: Int224 -> Rational #
Show Int224 # |
Methods showsPrec :: Int -> Int224 -> ShowS # show :: Int224 -> String # showList :: [Int224] -> ShowS #
Ix Int224 # |
Methods range :: (Int224, Int224) -> [Int224] # index :: (Int224, Int224) -> Int224 -> Int # unsafeIndex :: (Int224, Int224) -> Int224 -> Int inRange :: (Int224, Int224) -> Int224 -> Bool # rangeSize :: (Int224, Int224) -> Int # unsafeRangeSize :: (Int224, Int224) -> Int
Generic Int224 # |
Associated Types type Rep Int224 :: * -> * # Methods from :: Int224 -> Rep Int224 x # to :: Rep Int224 x -> Int224 #
Bits Int224 # |
Methods (.&.) :: Int224 -> Int224 -> Int224 # (.|.) :: Int224 -> Int224 -> Int224 # xor :: Int224 -> Int224 -> Int224 # complement :: Int224 -> Int224 # shift :: Int224 -> Int -> Int224 # rotate :: Int224 -> Int -> Int224 # zeroBits :: Int224 # bit :: Int -> Int224 # setBit :: Int224 -> Int -> Int224 # clearBit :: Int224 -> Int -> Int224 # complementBit :: Int224 -> Int -> Int224 # testBit :: Int224 -> Int -> Bool # bitSizeMaybe :: Int224 -> Maybe Int # bitSize :: Int224 -> Int # isSigned :: Int224 -> Bool # shiftL :: Int224 -> Int -> Int224 # unsafeShiftL :: Int224 -> Int -> Int224 # shiftR :: Int224 -> Int -> Int224 # unsafeShiftR :: Int224 -> Int -> Int224 # rotateL :: Int224 -> Int -> Int224 # rotateR :: Int224 -> Int -> Int224 # popCount :: Int224 -> Int #
FiniteBits Int224 # |
Methods finiteBitSize :: Int224 -> Int # countLeadingZeros :: Int224 -> Int # countTrailingZeros :: Int224 -> Int #
BinaryWord Int224 # |
Associated Types type UnsignedWord Int224 :: * # type SignedWord Int224 :: * # Methods unsignedWord :: Int224 -> UnsignedWord Int224 # signedWord :: Int224 -> SignedWord Int224 # unwrappedAdd :: Int224 -> Int224 -> (Int224, UnsignedWord Int224) # unwrappedMul :: Int224 -> Int224 -> (Int224, UnsignedWord Int224) # leadingZeroes :: Int224 -> Int # trailingZeroes :: Int224 -> Int # allZeroes :: Int224 # allOnes :: Int224 # msb :: Int224 # lsb :: Int224 # testMsb :: Int224 -> Bool # testLsb :: Int224 -> Bool # setMsb :: Int224 -> Int224 # setLsb :: Int224 -> Int224 # clearMsb :: Int224 -> Int224 # clearLsb :: Int224 -> Int224 #
Hashable Int224 # |
Methods hashWithSalt :: Int -> Int224 -> Int # hash :: Int224 -> Int #
DoubleWord Int224 # |
Associated Types type LoWord Int224 :: * # type HiWord Int224 :: * # Methods loWord :: Int224 -> LoWord Int224 # hiWord :: Int224 -> HiWord Int224 # fromHiAndLo :: HiWord Int224 -> LoWord Int224 -> Int224 # extendLo :: LoWord Int224 -> Int224 # signExtendLo :: SignedWord (LoWord Int224) -> Int224 #
type Rep Int224 # |
type Rep Int224 = D1 (MetaData "Int224" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Int224" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int96)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Int224 # |
type SignedWord Int224 = Int224
type UnsignedWord Int224 # |
type UnsignedWord Int224 = Word224
type LoWord Int224 # |
type LoWord Int224 = Word128
type HiWord Int224 # |
type HiWord Int224 = Int96

data Int256 #

Constructors

Int256 !Int128 !Word128 |

Instances

Bounded Int256 # |
Methods minBound :: Int256 # maxBound :: Int256 #
Enum Int256 # |
Methods succ :: Int256 -> Int256 # pred :: Int256 -> Int256 # toEnum :: Int -> Int256 # fromEnum :: Int256 -> Int # enumFrom :: Int256 -> [Int256] # enumFromThen :: Int256 -> Int256 -> [Int256] # enumFromTo :: Int256 -> Int256 -> [Int256] # enumFromThenTo :: Int256 -> Int256 -> Int256 -> [Int256] #
Eq Int256 # |
Methods (==) :: Int256 -> Int256 -> Bool # (/=) :: Int256 -> Int256 -> Bool #
Integral Int256 # |
Methods quot :: Int256 -> Int256 -> Int256 # rem :: Int256 -> Int256 -> Int256 # div :: Int256 -> Int256 -> Int256 # mod :: Int256 -> Int256 -> Int256 # quotRem :: Int256 -> Int256 -> (Int256, Int256) # divMod :: Int256 -> Int256 -> (Int256, Int256) # toInteger :: Int256 -> Integer #
Data Int256 # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int256 -> c Int256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int256 # toConstr :: Int256 -> Constr # dataTypeOf :: Int256 -> DataType # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int256) # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int256) # gmapT :: (forall b. Data b => b -> b) -> Int256 -> Int256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int256 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int256 -> m Int256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int256 -> m Int256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int256 -> m Int256 #
Num Int256 # |
Methods (+) :: Int256 -> Int256 -> Int256 # (-) :: Int256 -> Int256 -> Int256 # (*) :: Int256 -> Int256 -> Int256 # negate :: Int256 -> Int256 # abs :: Int256 -> Int256 # signum :: Int256 -> Int256 # fromInteger :: Integer -> Int256 #
Ord Int256 # |
Methods compare :: Int256 -> Int256 -> Ordering # (<) :: Int256 -> Int256 -> Bool # (<=) :: Int256 -> Int256 -> Bool # (>) :: Int256 -> Int256 -> Bool # (>=) :: Int256 -> Int256 -> Bool # max :: Int256 -> Int256 -> Int256 # min :: Int256 -> Int256 -> Int256 #
Read Int256 # |
Methods readsPrec :: Int -> ReadS Int256 # readList :: ReadS [Int256] # readPrec :: ReadPrec Int256 # readListPrec :: ReadPrec [Int256] #
Real Int256 # |
Methods toRational :: Int256 -> Rational #
Show Int256 # |
Methods showsPrec :: Int -> Int256 -> ShowS # show :: Int256 -> String # showList :: [Int256] -> ShowS #
Ix Int256 # |
Methods range :: (Int256, Int256) -> [Int256] # index :: (Int256, Int256) -> Int256 -> Int # unsafeIndex :: (Int256, Int256) -> Int256 -> Int inRange :: (Int256, Int256) -> Int256 -> Bool # rangeSize :: (Int256, Int256) -> Int # unsafeRangeSize :: (Int256, Int256) -> Int
Generic Int256 # |
Associated Types type Rep Int256 :: * -> * # Methods from :: Int256 -> Rep Int256 x # to :: Rep Int256 x -> Int256 #
Bits Int256 # |
Methods (.&.) :: Int256 -> Int256 -> Int256 # (.|.) :: Int256 -> Int256 -> Int256 # xor :: Int256 -> Int256 -> Int256 # complement :: Int256 -> Int256 # shift :: Int256 -> Int -> Int256 # rotate :: Int256 -> Int -> Int256 # zeroBits :: Int256 # bit :: Int -> Int256 # setBit :: Int256 -> Int -> Int256 # clearBit :: Int256 -> Int -> Int256 # complementBit :: Int256 -> Int -> Int256 # testBit :: Int256 -> Int -> Bool # bitSizeMaybe :: Int256 -> Maybe Int # bitSize :: Int256 -> Int # isSigned :: Int256 -> Bool # shiftL :: Int256 -> Int -> Int256 # unsafeShiftL :: Int256 -> Int -> Int256 # shiftR :: Int256 -> Int -> Int256 # unsafeShiftR :: Int256 -> Int -> Int256 # rotateL :: Int256 -> Int -> Int256 # rotateR :: Int256 -> Int -> Int256 # popCount :: Int256 -> Int #
FiniteBits Int256 # |
Methods finiteBitSize :: Int256 -> Int # countLeadingZeros :: Int256 -> Int # countTrailingZeros :: Int256 -> Int #
BinaryWord Int256 # |
Associated Types type UnsignedWord Int256 :: * # type SignedWord Int256 :: * # Methods unsignedWord :: Int256 -> UnsignedWord Int256 # signedWord :: Int256 -> SignedWord Int256 # unwrappedAdd :: Int256 -> Int256 -> (Int256, UnsignedWord Int256) # unwrappedMul :: Int256 -> Int256 -> (Int256, UnsignedWord Int256) # leadingZeroes :: Int256 -> Int # trailingZeroes :: Int256 -> Int # allZeroes :: Int256 # allOnes :: Int256 # msb :: Int256 # lsb :: Int256 # testMsb :: Int256 -> Bool # testLsb :: Int256 -> Bool # setMsb :: Int256 -> Int256 # setLsb :: Int256 -> Int256 # clearMsb :: Int256 -> Int256 # clearLsb :: Int256 -> Int256 #
Hashable Int256 # |
Methods hashWithSalt :: Int -> Int256 -> Int # hash :: Int256 -> Int #
DoubleWord Int256 # |
Associated Types type LoWord Int256 :: * # type HiWord Int256 :: * # Methods loWord :: Int256 -> LoWord Int256 # hiWord :: Int256 -> HiWord Int256 # fromHiAndLo :: HiWord Int256 -> LoWord Int256 -> Int256 # extendLo :: LoWord Int256 -> Int256 # signExtendLo :: SignedWord (LoWord Int256) -> Int256 #
type Rep Int256 # |
type Rep Int256 = D1 (MetaData "Int256" "Data.DoubleWord" "data-dword-0.3.1.1-1MG8mNTIyavEWsvOfESjf4" False) (C1 (MetaCons "Int256" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Int128)) (S1 (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedUnpack) (Rec0 Word128))))
type SignedWord Int256 # |
type SignedWord Int256 = Int256
type UnsignedWord Int256 # |
type UnsignedWord Int256 = Word256
type LoWord Int256 # |
type LoWord Int256 = Word128
type HiWord Int256 # |
type HiWord Int256 = Int128