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

Documentation

module Data.BinaryWord

class BinaryWord w => DoubleWord w where Source #

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

Minimal complete definition

loWord, hiWord, fromHiAndLo, extendLo, signExtendLo

Associated Types

type LoWord w Source #

The low half type

type HiWord w Source #

The high half type

Methods

loWord :: w -> LoWord w Source #

The low half of the word

hiWord :: w -> HiWord w Source #

The high half of the word

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

Construct a word from the low and high halves

extendLo :: LoWord w -> w Source #

Extend the low half

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

Sign-extend the low half

Instances

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

data Word96 Source #

Constructors

Word96 !Word32 !Word64

Instances

Bounded Word96 Source #
Methods minBound :: Word96 # maxBound :: Word96 #
Enum Word96 Source #
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 Source #
Methods (==) :: Word96 -> Word96 -> Bool # (/=) :: Word96 -> Word96 -> Bool #
Integral Word96 Source #
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 Source #
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 Source #
Methods (+) :: Word96 -> Word96 -> Word96 # (-) :: Word96 -> Word96 -> Word96 # (*) :: Word96 -> Word96 -> Word96 # negate :: Word96 -> Word96 # abs :: Word96 -> Word96 # signum :: Word96 -> Word96 # fromInteger :: Integer -> Word96 #
Ord Word96 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Word96 # readList :: ReadS [Word96] # readPrec :: ReadPrec Word96 # readListPrec :: ReadPrec [Word96] #
Real Word96 Source #
Methods toRational :: Word96 -> Rational #
Show Word96 Source #
Methods showsPrec :: Int -> Word96 -> ShowS # show :: Word96 -> String # showList :: [Word96] -> ShowS #
Ix Word96 Source #
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 Source #
Associated Types type Rep Word96 :: * -> * # Methods from :: Word96 -> Rep Word96 x # to :: Rep Word96 x -> Word96 #
Bits Word96 Source #
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 Source #
Methods finiteBitSize :: Word96 -> Int # countLeadingZeros :: Word96 -> Int # countTrailingZeros :: Word96 -> Int #
BinaryWord Word96 Source #
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 Source #
Methods hashWithSalt :: Int -> Word96 -> Int # hash :: Word96 -> Int #
DoubleWord Word96 Source #
Associated Types type LoWord Word96 :: * Source # type HiWord Word96 :: * Source # Methods loWord :: Word96 -> LoWord Word96 Source # hiWord :: Word96 -> HiWord Word96 Source # fromHiAndLo :: HiWord Word96 -> LoWord Word96 -> Word96 Source # extendLo :: LoWord Word96 -> Word96 Source # signExtendLo :: SignedWord (LoWord Word96) -> Word96 Source #
type Rep Word96 Source #
type Rep Word96 = D1 * (MetaData "Word96" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Word96" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word32)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word64))))
type SignedWord Word96 Source #
type SignedWord Word96 = Int96
type UnsignedWord Word96 Source #
type UnsignedWord Word96 = Word96
type LoWord Word96 Source #
type LoWord Word96 = Word64
type HiWord Word96 Source #
type HiWord Word96 = Word32

data Word128 Source #

Constructors

Word128 !Word64 !Word64

Instances

Bounded Word128 Source #
Methods minBound :: Word128 # maxBound :: Word128 #
Enum Word128 Source #
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 Source #
Methods (==) :: Word128 -> Word128 -> Bool # (/=) :: Word128 -> Word128 -> Bool #
Integral Word128 Source #
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 Source #
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 Source #
Methods (+) :: Word128 -> Word128 -> Word128 # (-) :: Word128 -> Word128 -> Word128 # (*) :: Word128 -> Word128 -> Word128 # negate :: Word128 -> Word128 # abs :: Word128 -> Word128 # signum :: Word128 -> Word128 # fromInteger :: Integer -> Word128 #
Ord Word128 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Word128 # readList :: ReadS [Word128] # readPrec :: ReadPrec Word128 # readListPrec :: ReadPrec [Word128] #
Real Word128 Source #
Methods toRational :: Word128 -> Rational #
Show Word128 Source #
Methods showsPrec :: Int -> Word128 -> ShowS # show :: Word128 -> String # showList :: [Word128] -> ShowS #
Ix Word128 Source #
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 Source #
Associated Types type Rep Word128 :: * -> * # Methods from :: Word128 -> Rep Word128 x # to :: Rep Word128 x -> Word128 #
Bits Word128 Source #
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 Source #
Methods finiteBitSize :: Word128 -> Int # countLeadingZeros :: Word128 -> Int # countTrailingZeros :: Word128 -> Int #
BinaryWord Word128 Source #
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 Source #
Methods hashWithSalt :: Int -> Word128 -> Int # hash :: Word128 -> Int #
DoubleWord Word128 Source #
Associated Types type LoWord Word128 :: * Source # type HiWord Word128 :: * Source # Methods loWord :: Word128 -> LoWord Word128 Source # hiWord :: Word128 -> HiWord Word128 Source # fromHiAndLo :: HiWord Word128 -> LoWord Word128 -> Word128 Source # extendLo :: LoWord Word128 -> Word128 Source # signExtendLo :: SignedWord (LoWord Word128) -> Word128 Source #
type Rep Word128 Source #
type Rep Word128 = D1 * (MetaData "Word128" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Word128" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word64)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word64))))
type SignedWord Word128 Source #
type SignedWord Word128 = Int128
type UnsignedWord Word128 Source #
type UnsignedWord Word128 = Word128
type LoWord Word128 Source #
type LoWord Word128 = Word64
type HiWord Word128 Source #
type HiWord Word128 = Word64

data Word160 Source #

Constructors

Word160 !Word32 !Word128

Instances

Bounded Word160 Source #
Methods minBound :: Word160 # maxBound :: Word160 #
Enum Word160 Source #
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 Source #
Methods (==) :: Word160 -> Word160 -> Bool # (/=) :: Word160 -> Word160 -> Bool #
Integral Word160 Source #
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 Source #
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 Source #
Methods (+) :: Word160 -> Word160 -> Word160 # (-) :: Word160 -> Word160 -> Word160 # (*) :: Word160 -> Word160 -> Word160 # negate :: Word160 -> Word160 # abs :: Word160 -> Word160 # signum :: Word160 -> Word160 # fromInteger :: Integer -> Word160 #
Ord Word160 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Word160 # readList :: ReadS [Word160] # readPrec :: ReadPrec Word160 # readListPrec :: ReadPrec [Word160] #
Real Word160 Source #
Methods toRational :: Word160 -> Rational #
Show Word160 Source #
Methods showsPrec :: Int -> Word160 -> ShowS # show :: Word160 -> String # showList :: [Word160] -> ShowS #
Ix Word160 Source #
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 Source #
Associated Types type Rep Word160 :: * -> * # Methods from :: Word160 -> Rep Word160 x # to :: Rep Word160 x -> Word160 #
Bits Word160 Source #
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 Source #
Methods finiteBitSize :: Word160 -> Int # countLeadingZeros :: Word160 -> Int # countTrailingZeros :: Word160 -> Int #
BinaryWord Word160 Source #
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 Source #
Methods hashWithSalt :: Int -> Word160 -> Int # hash :: Word160 -> Int #
DoubleWord Word160 Source #
Associated Types type LoWord Word160 :: * Source # type HiWord Word160 :: * Source # Methods loWord :: Word160 -> LoWord Word160 Source # hiWord :: Word160 -> HiWord Word160 Source # fromHiAndLo :: HiWord Word160 -> LoWord Word160 -> Word160 Source # extendLo :: LoWord Word160 -> Word160 Source # signExtendLo :: SignedWord (LoWord Word160) -> Word160 Source #
type Rep Word160 Source #
type Rep Word160 = D1 * (MetaData "Word160" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Word160" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word32)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word128))))
type SignedWord Word160 Source #
type SignedWord Word160 = Int160
type UnsignedWord Word160 Source #
type UnsignedWord Word160 = Word160
type LoWord Word160 Source #
type LoWord Word160 = Word128
type HiWord Word160 Source #
type HiWord Word160 = Word32

data Word192 Source #

Constructors

Word192 !Word64 !Word128

Instances

Bounded Word192 Source #
Methods minBound :: Word192 # maxBound :: Word192 #
Enum Word192 Source #
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 Source #
Methods (==) :: Word192 -> Word192 -> Bool # (/=) :: Word192 -> Word192 -> Bool #
Integral Word192 Source #
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 Source #
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 Source #
Methods (+) :: Word192 -> Word192 -> Word192 # (-) :: Word192 -> Word192 -> Word192 # (*) :: Word192 -> Word192 -> Word192 # negate :: Word192 -> Word192 # abs :: Word192 -> Word192 # signum :: Word192 -> Word192 # fromInteger :: Integer -> Word192 #
Ord Word192 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Word192 # readList :: ReadS [Word192] # readPrec :: ReadPrec Word192 # readListPrec :: ReadPrec [Word192] #
Real Word192 Source #
Methods toRational :: Word192 -> Rational #
Show Word192 Source #
Methods showsPrec :: Int -> Word192 -> ShowS # show :: Word192 -> String # showList :: [Word192] -> ShowS #
Ix Word192 Source #
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 Source #
Associated Types type Rep Word192 :: * -> * # Methods from :: Word192 -> Rep Word192 x # to :: Rep Word192 x -> Word192 #
Bits Word192 Source #
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 Source #
Methods finiteBitSize :: Word192 -> Int # countLeadingZeros :: Word192 -> Int # countTrailingZeros :: Word192 -> Int #
BinaryWord Word192 Source #
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 Source #
Methods hashWithSalt :: Int -> Word192 -> Int # hash :: Word192 -> Int #
DoubleWord Word192 Source #
Associated Types type LoWord Word192 :: * Source # type HiWord Word192 :: * Source # Methods loWord :: Word192 -> LoWord Word192 Source # hiWord :: Word192 -> HiWord Word192 Source # fromHiAndLo :: HiWord Word192 -> LoWord Word192 -> Word192 Source # extendLo :: LoWord Word192 -> Word192 Source # signExtendLo :: SignedWord (LoWord Word192) -> Word192 Source #
type Rep Word192 Source #
type Rep Word192 = D1 * (MetaData "Word192" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Word192" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word64)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word128))))
type SignedWord Word192 Source #
type SignedWord Word192 = Int192
type UnsignedWord Word192 Source #
type UnsignedWord Word192 = Word192
type LoWord Word192 Source #
type LoWord Word192 = Word128
type HiWord Word192 Source #
type HiWord Word192 = Word64

data Word224 Source #

Constructors

Word224 !Word96 !Word128

Instances

Bounded Word224 Source #
Methods minBound :: Word224 # maxBound :: Word224 #
Enum Word224 Source #
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 Source #
Methods (==) :: Word224 -> Word224 -> Bool # (/=) :: Word224 -> Word224 -> Bool #
Integral Word224 Source #
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 Source #
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 Source #
Methods (+) :: Word224 -> Word224 -> Word224 # (-) :: Word224 -> Word224 -> Word224 # (*) :: Word224 -> Word224 -> Word224 # negate :: Word224 -> Word224 # abs :: Word224 -> Word224 # signum :: Word224 -> Word224 # fromInteger :: Integer -> Word224 #
Ord Word224 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Word224 # readList :: ReadS [Word224] # readPrec :: ReadPrec Word224 # readListPrec :: ReadPrec [Word224] #
Real Word224 Source #
Methods toRational :: Word224 -> Rational #
Show Word224 Source #
Methods showsPrec :: Int -> Word224 -> ShowS # show :: Word224 -> String # showList :: [Word224] -> ShowS #
Ix Word224 Source #
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 Source #
Associated Types type Rep Word224 :: * -> * # Methods from :: Word224 -> Rep Word224 x # to :: Rep Word224 x -> Word224 #
Bits Word224 Source #
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 Source #
Methods finiteBitSize :: Word224 -> Int # countLeadingZeros :: Word224 -> Int # countTrailingZeros :: Word224 -> Int #
BinaryWord Word224 Source #
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 Source #
Methods hashWithSalt :: Int -> Word224 -> Int # hash :: Word224 -> Int #
DoubleWord Word224 Source #
Associated Types type LoWord Word224 :: * Source # type HiWord Word224 :: * Source # Methods loWord :: Word224 -> LoWord Word224 Source # hiWord :: Word224 -> HiWord Word224 Source # fromHiAndLo :: HiWord Word224 -> LoWord Word224 -> Word224 Source # extendLo :: LoWord Word224 -> Word224 Source # signExtendLo :: SignedWord (LoWord Word224) -> Word224 Source #
type Rep Word224 Source #
type Rep Word224 = D1 * (MetaData "Word224" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Word224" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word96)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word128))))
type SignedWord Word224 Source #
type SignedWord Word224 = Int224
type UnsignedWord Word224 Source #
type UnsignedWord Word224 = Word224
type LoWord Word224 Source #
type LoWord Word224 = Word128
type HiWord Word224 Source #
type HiWord Word224 = Word96

data Word256 Source #

Constructors

Word256 !Word128 !Word128

Instances

Bounded Word256 Source #
Methods minBound :: Word256 # maxBound :: Word256 #
Enum Word256 Source #
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 Source #
Methods (==) :: Word256 -> Word256 -> Bool # (/=) :: Word256 -> Word256 -> Bool #
Integral Word256 Source #
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 Source #
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 Source #
Methods (+) :: Word256 -> Word256 -> Word256 # (-) :: Word256 -> Word256 -> Word256 # (*) :: Word256 -> Word256 -> Word256 # negate :: Word256 -> Word256 # abs :: Word256 -> Word256 # signum :: Word256 -> Word256 # fromInteger :: Integer -> Word256 #
Ord Word256 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Word256 # readList :: ReadS [Word256] # readPrec :: ReadPrec Word256 # readListPrec :: ReadPrec [Word256] #
Real Word256 Source #
Methods toRational :: Word256 -> Rational #
Show Word256 Source #
Methods showsPrec :: Int -> Word256 -> ShowS # show :: Word256 -> String # showList :: [Word256] -> ShowS #
Ix Word256 Source #
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 Source #
Associated Types type Rep Word256 :: * -> * # Methods from :: Word256 -> Rep Word256 x # to :: Rep Word256 x -> Word256 #
Bits Word256 Source #
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 Source #
Methods finiteBitSize :: Word256 -> Int # countLeadingZeros :: Word256 -> Int # countTrailingZeros :: Word256 -> Int #
BinaryWord Word256 Source #
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 Source #
Methods hashWithSalt :: Int -> Word256 -> Int # hash :: Word256 -> Int #
DoubleWord Word256 Source #
Associated Types type LoWord Word256 :: * Source # type HiWord Word256 :: * Source # Methods loWord :: Word256 -> LoWord Word256 Source # hiWord :: Word256 -> HiWord Word256 Source # fromHiAndLo :: HiWord Word256 -> LoWord Word256 -> Word256 Source # extendLo :: LoWord Word256 -> Word256 Source # signExtendLo :: SignedWord (LoWord Word256) -> Word256 Source #
type Rep Word256 Source #
type Rep Word256 = D1 * (MetaData "Word256" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Word256" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word128)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word128))))
type SignedWord Word256 Source #
type SignedWord Word256 = Int256
type UnsignedWord Word256 Source #
type UnsignedWord Word256 = Word256
type LoWord Word256 Source #
type LoWord Word256 = Word128
type HiWord Word256 Source #
type HiWord Word256 = Word128

data Int96 Source #

Constructors

Int96 !Int32 !Word64

Instances

Bounded Int96 Source #
Methods minBound :: Int96 # maxBound :: Int96 #
Enum Int96 Source #
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 Source #
Methods (==) :: Int96 -> Int96 -> Bool # (/=) :: Int96 -> Int96 -> Bool #
Integral Int96 Source #
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 Source #
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 Source #
Methods (+) :: Int96 -> Int96 -> Int96 # (-) :: Int96 -> Int96 -> Int96 # (*) :: Int96 -> Int96 -> Int96 # negate :: Int96 -> Int96 # abs :: Int96 -> Int96 # signum :: Int96 -> Int96 # fromInteger :: Integer -> Int96 #
Ord Int96 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Int96 # readList :: ReadS [Int96] # readPrec :: ReadPrec Int96 # readListPrec :: ReadPrec [Int96] #
Real Int96 Source #
Methods toRational :: Int96 -> Rational #
Show Int96 Source #
Methods showsPrec :: Int -> Int96 -> ShowS # show :: Int96 -> String # showList :: [Int96] -> ShowS #
Ix Int96 Source #
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 Source #
Associated Types type Rep Int96 :: * -> * # Methods from :: Int96 -> Rep Int96 x # to :: Rep Int96 x -> Int96 #
Bits Int96 Source #
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 Source #
Methods finiteBitSize :: Int96 -> Int # countLeadingZeros :: Int96 -> Int # countTrailingZeros :: Int96 -> Int #
BinaryWord Int96 Source #
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 Source #
Methods hashWithSalt :: Int -> Int96 -> Int # hash :: Int96 -> Int #
DoubleWord Int96 Source #
Associated Types type LoWord Int96 :: * Source # type HiWord Int96 :: * Source # Methods loWord :: Int96 -> LoWord Int96 Source # hiWord :: Int96 -> HiWord Int96 Source # fromHiAndLo :: HiWord Int96 -> LoWord Int96 -> Int96 Source # extendLo :: LoWord Int96 -> Int96 Source # signExtendLo :: SignedWord (LoWord Int96) -> Int96 Source #
type Rep Int96 Source #
type Rep Int96 = D1 * (MetaData "Int96" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Int96" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Int32)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word64))))
type SignedWord Int96 Source #
type SignedWord Int96 = Int96
type UnsignedWord Int96 Source #
type UnsignedWord Int96 = Word96
type LoWord Int96 Source #
type LoWord Int96 = Word64
type HiWord Int96 Source #
type HiWord Int96 = Int32

data Int128 Source #

Constructors

Int128 !Int64 !Word64

Instances

Bounded Int128 Source #
Methods minBound :: Int128 # maxBound :: Int128 #
Enum Int128 Source #
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 Source #
Methods (==) :: Int128 -> Int128 -> Bool # (/=) :: Int128 -> Int128 -> Bool #
Integral Int128 Source #
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 Source #
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 Source #
Methods (+) :: Int128 -> Int128 -> Int128 # (-) :: Int128 -> Int128 -> Int128 # (*) :: Int128 -> Int128 -> Int128 # negate :: Int128 -> Int128 # abs :: Int128 -> Int128 # signum :: Int128 -> Int128 # fromInteger :: Integer -> Int128 #
Ord Int128 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Int128 # readList :: ReadS [Int128] # readPrec :: ReadPrec Int128 # readListPrec :: ReadPrec [Int128] #
Real Int128 Source #
Methods toRational :: Int128 -> Rational #
Show Int128 Source #
Methods showsPrec :: Int -> Int128 -> ShowS # show :: Int128 -> String # showList :: [Int128] -> ShowS #
Ix Int128 Source #
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 Source #
Associated Types type Rep Int128 :: * -> * # Methods from :: Int128 -> Rep Int128 x # to :: Rep Int128 x -> Int128 #
Bits Int128 Source #
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 Source #
Methods finiteBitSize :: Int128 -> Int # countLeadingZeros :: Int128 -> Int # countTrailingZeros :: Int128 -> Int #
BinaryWord Int128 Source #
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 Source #
Methods hashWithSalt :: Int -> Int128 -> Int # hash :: Int128 -> Int #
DoubleWord Int128 Source #
Associated Types type LoWord Int128 :: * Source # type HiWord Int128 :: * Source # Methods loWord :: Int128 -> LoWord Int128 Source # hiWord :: Int128 -> HiWord Int128 Source # fromHiAndLo :: HiWord Int128 -> LoWord Int128 -> Int128 Source # extendLo :: LoWord Int128 -> Int128 Source # signExtendLo :: SignedWord (LoWord Int128) -> Int128 Source #
type Rep Int128 Source #
type Rep Int128 = D1 * (MetaData "Int128" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Int128" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Int64)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word64))))
type SignedWord Int128 Source #
type SignedWord Int128 = Int128
type UnsignedWord Int128 Source #
type UnsignedWord Int128 = Word128
type LoWord Int128 Source #
type LoWord Int128 = Word64
type HiWord Int128 Source #
type HiWord Int128 = Int64

data Int160 Source #

Constructors

Int160 !Int32 !Word128

Instances

Bounded Int160 Source #
Methods minBound :: Int160 # maxBound :: Int160 #
Enum Int160 Source #
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 Source #
Methods (==) :: Int160 -> Int160 -> Bool # (/=) :: Int160 -> Int160 -> Bool #
Integral Int160 Source #
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 Source #
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 Source #
Methods (+) :: Int160 -> Int160 -> Int160 # (-) :: Int160 -> Int160 -> Int160 # (*) :: Int160 -> Int160 -> Int160 # negate :: Int160 -> Int160 # abs :: Int160 -> Int160 # signum :: Int160 -> Int160 # fromInteger :: Integer -> Int160 #
Ord Int160 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Int160 # readList :: ReadS [Int160] # readPrec :: ReadPrec Int160 # readListPrec :: ReadPrec [Int160] #
Real Int160 Source #
Methods toRational :: Int160 -> Rational #
Show Int160 Source #
Methods showsPrec :: Int -> Int160 -> ShowS # show :: Int160 -> String # showList :: [Int160] -> ShowS #
Ix Int160 Source #
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 Source #
Associated Types type Rep Int160 :: * -> * # Methods from :: Int160 -> Rep Int160 x # to :: Rep Int160 x -> Int160 #
Bits Int160 Source #
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 Source #
Methods finiteBitSize :: Int160 -> Int # countLeadingZeros :: Int160 -> Int # countTrailingZeros :: Int160 -> Int #
BinaryWord Int160 Source #
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 Source #
Methods hashWithSalt :: Int -> Int160 -> Int # hash :: Int160 -> Int #
DoubleWord Int160 Source #
Associated Types type LoWord Int160 :: * Source # type HiWord Int160 :: * Source # Methods loWord :: Int160 -> LoWord Int160 Source # hiWord :: Int160 -> HiWord Int160 Source # fromHiAndLo :: HiWord Int160 -> LoWord Int160 -> Int160 Source # extendLo :: LoWord Int160 -> Int160 Source # signExtendLo :: SignedWord (LoWord Int160) -> Int160 Source #
type Rep Int160 Source #
type Rep Int160 = D1 * (MetaData "Int160" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Int160" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Int32)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word128))))
type SignedWord Int160 Source #
type SignedWord Int160 = Int160
type UnsignedWord Int160 Source #
type UnsignedWord Int160 = Word160
type LoWord Int160 Source #
type LoWord Int160 = Word128
type HiWord Int160 Source #
type HiWord Int160 = Int32

data Int192 Source #

Constructors

Int192 !Int64 !Word128

Instances

Bounded Int192 Source #
Methods minBound :: Int192 # maxBound :: Int192 #
Enum Int192 Source #
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 Source #
Methods (==) :: Int192 -> Int192 -> Bool # (/=) :: Int192 -> Int192 -> Bool #
Integral Int192 Source #
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 Source #
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 Source #
Methods (+) :: Int192 -> Int192 -> Int192 # (-) :: Int192 -> Int192 -> Int192 # (*) :: Int192 -> Int192 -> Int192 # negate :: Int192 -> Int192 # abs :: Int192 -> Int192 # signum :: Int192 -> Int192 # fromInteger :: Integer -> Int192 #
Ord Int192 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Int192 # readList :: ReadS [Int192] # readPrec :: ReadPrec Int192 # readListPrec :: ReadPrec [Int192] #
Real Int192 Source #
Methods toRational :: Int192 -> Rational #
Show Int192 Source #
Methods showsPrec :: Int -> Int192 -> ShowS # show :: Int192 -> String # showList :: [Int192] -> ShowS #
Ix Int192 Source #
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 Source #
Associated Types type Rep Int192 :: * -> * # Methods from :: Int192 -> Rep Int192 x # to :: Rep Int192 x -> Int192 #
Bits Int192 Source #
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 Source #
Methods finiteBitSize :: Int192 -> Int # countLeadingZeros :: Int192 -> Int # countTrailingZeros :: Int192 -> Int #
BinaryWord Int192 Source #
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 Source #
Methods hashWithSalt :: Int -> Int192 -> Int # hash :: Int192 -> Int #
DoubleWord Int192 Source #
Associated Types type LoWord Int192 :: * Source # type HiWord Int192 :: * Source # Methods loWord :: Int192 -> LoWord Int192 Source # hiWord :: Int192 -> HiWord Int192 Source # fromHiAndLo :: HiWord Int192 -> LoWord Int192 -> Int192 Source # extendLo :: LoWord Int192 -> Int192 Source # signExtendLo :: SignedWord (LoWord Int192) -> Int192 Source #
type Rep Int192 Source #
type Rep Int192 = D1 * (MetaData "Int192" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Int192" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Int64)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word128))))
type SignedWord Int192 Source #
type SignedWord Int192 = Int192
type UnsignedWord Int192 Source #
type UnsignedWord Int192 = Word192
type LoWord Int192 Source #
type LoWord Int192 = Word128
type HiWord Int192 Source #
type HiWord Int192 = Int64

data Int224 Source #

Constructors

Int224 !Int96 !Word128

Instances

Bounded Int224 Source #
Methods minBound :: Int224 # maxBound :: Int224 #
Enum Int224 Source #
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 Source #
Methods (==) :: Int224 -> Int224 -> Bool # (/=) :: Int224 -> Int224 -> Bool #
Integral Int224 Source #
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 Source #
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 Source #
Methods (+) :: Int224 -> Int224 -> Int224 # (-) :: Int224 -> Int224 -> Int224 # (*) :: Int224 -> Int224 -> Int224 # negate :: Int224 -> Int224 # abs :: Int224 -> Int224 # signum :: Int224 -> Int224 # fromInteger :: Integer -> Int224 #
Ord Int224 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Int224 # readList :: ReadS [Int224] # readPrec :: ReadPrec Int224 # readListPrec :: ReadPrec [Int224] #
Real Int224 Source #
Methods toRational :: Int224 -> Rational #
Show Int224 Source #
Methods showsPrec :: Int -> Int224 -> ShowS # show :: Int224 -> String # showList :: [Int224] -> ShowS #
Ix Int224 Source #
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 Source #
Associated Types type Rep Int224 :: * -> * # Methods from :: Int224 -> Rep Int224 x # to :: Rep Int224 x -> Int224 #
Bits Int224 Source #
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 Source #
Methods finiteBitSize :: Int224 -> Int # countLeadingZeros :: Int224 -> Int # countTrailingZeros :: Int224 -> Int #
BinaryWord Int224 Source #
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 Source #
Methods hashWithSalt :: Int -> Int224 -> Int # hash :: Int224 -> Int #
DoubleWord Int224 Source #
Associated Types type LoWord Int224 :: * Source # type HiWord Int224 :: * Source # Methods loWord :: Int224 -> LoWord Int224 Source # hiWord :: Int224 -> HiWord Int224 Source # fromHiAndLo :: HiWord Int224 -> LoWord Int224 -> Int224 Source # extendLo :: LoWord Int224 -> Int224 Source # signExtendLo :: SignedWord (LoWord Int224) -> Int224 Source #
type Rep Int224 Source #
type Rep Int224 = D1 * (MetaData "Int224" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Int224" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Int96)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word128))))
type SignedWord Int224 Source #
type SignedWord Int224 = Int224
type UnsignedWord Int224 Source #
type UnsignedWord Int224 = Word224
type LoWord Int224 Source #
type LoWord Int224 = Word128
type HiWord Int224 Source #
type HiWord Int224 = Int96

data Int256 Source #

Constructors

Int256 !Int128 !Word128

Instances

Bounded Int256 Source #
Methods minBound :: Int256 # maxBound :: Int256 #
Enum Int256 Source #
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 Source #
Methods (==) :: Int256 -> Int256 -> Bool # (/=) :: Int256 -> Int256 -> Bool #
Integral Int256 Source #
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 Source #
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 Source #
Methods (+) :: Int256 -> Int256 -> Int256 # (-) :: Int256 -> Int256 -> Int256 # (*) :: Int256 -> Int256 -> Int256 # negate :: Int256 -> Int256 # abs :: Int256 -> Int256 # signum :: Int256 -> Int256 # fromInteger :: Integer -> Int256 #
Ord Int256 Source #
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 Source #
Methods readsPrec :: Int -> ReadS Int256 # readList :: ReadS [Int256] # readPrec :: ReadPrec Int256 # readListPrec :: ReadPrec [Int256] #
Real Int256 Source #
Methods toRational :: Int256 -> Rational #
Show Int256 Source #
Methods showsPrec :: Int -> Int256 -> ShowS # show :: Int256 -> String # showList :: [Int256] -> ShowS #
Ix Int256 Source #
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 Source #
Associated Types type Rep Int256 :: * -> * # Methods from :: Int256 -> Rep Int256 x # to :: Rep Int256 x -> Int256 #
Bits Int256 Source #
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 Source #
Methods finiteBitSize :: Int256 -> Int # countLeadingZeros :: Int256 -> Int # countTrailingZeros :: Int256 -> Int #
BinaryWord Int256 Source #
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 Source #
Methods hashWithSalt :: Int -> Int256 -> Int # hash :: Int256 -> Int #
DoubleWord Int256 Source #
Associated Types type LoWord Int256 :: * Source # type HiWord Int256 :: * Source # Methods loWord :: Int256 -> LoWord Int256 Source # hiWord :: Int256 -> HiWord Int256 Source # fromHiAndLo :: HiWord Int256 -> LoWord Int256 -> Int256 Source # extendLo :: LoWord Int256 -> Int256 Source # signExtendLo :: SignedWord (LoWord Int256) -> Int256 Source #
type Rep Int256 Source #
type Rep Int256 = D1 * (MetaData "Int256" "Data.DoubleWord" "data-dword-0.3.1.2-7CsSOXS6igCDCJyxF916Kv" False) (C1 * (MetaCons "Int256" PrefixI False) ((::) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Int128)) (S1 * (MetaSel (Nothing Symbol) SourceUnpack SourceStrict DecidedStrict) (Rec0 * Word128))))
type SignedWord Int256 Source #
type SignedWord Int256 = Int256
type UnsignedWord Int256 Source #
type UnsignedWord Int256 = Word256
type LoWord Int256 Source #
type LoWord Int256 = Word128
type HiWord Int256 Source #
type HiWord Int256 = Int128