Safe Haskell	None
Language	Haskell2010

Data.ShortWord

Description

This module provides signed and unsigned binary word data types of sizes 2, 4, 7, 24, and 48 bits.

Documentation

module Data.BinaryWord

data Word2 Source #

Instances

Bounded Word2 Source #
Methods minBound :: Word2 # maxBound :: Word2 #
Enum Word2 Source #
Methods succ :: Word2 -> Word2 # pred :: Word2 -> Word2 # toEnum :: Int -> Word2 # fromEnum :: Word2 -> Int # enumFrom :: Word2 -> [Word2] # enumFromThen :: Word2 -> Word2 -> [Word2] # enumFromTo :: Word2 -> Word2 -> [Word2] # enumFromThenTo :: Word2 -> Word2 -> Word2 -> [Word2] #
Eq Word2 Source #
Methods (==) :: Word2 -> Word2 -> Bool # (/=) :: Word2 -> Word2 -> Bool #
Integral Word2 Source #
Methods quot :: Word2 -> Word2 -> Word2 # rem :: Word2 -> Word2 -> Word2 # div :: Word2 -> Word2 -> Word2 # mod :: Word2 -> Word2 -> Word2 # quotRem :: Word2 -> Word2 -> (Word2, Word2) # divMod :: Word2 -> Word2 -> (Word2, Word2) # toInteger :: Word2 -> Integer #
Data Word2 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word2 -> c Word2 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word2 # toConstr :: Word2 -> Constr # dataTypeOf :: Word2 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word2) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word2) # gmapT :: (forall b. Data b => b -> b) -> Word2 -> Word2 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word2 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word2 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word2 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word2 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word2 -> m Word2 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word2 -> m Word2 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word2 -> m Word2 #
Num Word2 Source #
Methods (+) :: Word2 -> Word2 -> Word2 # (-) :: Word2 -> Word2 -> Word2 # (*) :: Word2 -> Word2 -> Word2 # negate :: Word2 -> Word2 # abs :: Word2 -> Word2 # signum :: Word2 -> Word2 # fromInteger :: Integer -> Word2 #
Ord Word2 Source #
Methods compare :: Word2 -> Word2 -> Ordering # (<) :: Word2 -> Word2 -> Bool # (<=) :: Word2 -> Word2 -> Bool # (>) :: Word2 -> Word2 -> Bool # (>=) :: Word2 -> Word2 -> Bool # max :: Word2 -> Word2 -> Word2 # min :: Word2 -> Word2 -> Word2 #
Read Word2 Source #
Methods readsPrec :: Int -> ReadS Word2 # readList :: ReadS [Word2] # readPrec :: ReadPrec Word2 # readListPrec :: ReadPrec [Word2] #
Real Word2 Source #
Methods toRational :: Word2 -> Rational #
Show Word2 Source #
Methods showsPrec :: Int -> Word2 -> ShowS # show :: Word2 -> String # showList :: [Word2] -> ShowS #
Ix Word2 Source #
Methods range :: (Word2, Word2) -> [Word2] # index :: (Word2, Word2) -> Word2 -> Int # unsafeIndex :: (Word2, Word2) -> Word2 -> Int inRange :: (Word2, Word2) -> Word2 -> Bool # rangeSize :: (Word2, Word2) -> Int # unsafeRangeSize :: (Word2, Word2) -> Int
Bits Word2 Source #
Methods (.&.) :: Word2 -> Word2 -> Word2 # (.\|.) :: Word2 -> Word2 -> Word2 # xor :: Word2 -> Word2 -> Word2 # complement :: Word2 -> Word2 # shift :: Word2 -> Int -> Word2 # rotate :: Word2 -> Int -> Word2 # zeroBits :: Word2 # bit :: Int -> Word2 # setBit :: Word2 -> Int -> Word2 # clearBit :: Word2 -> Int -> Word2 # complementBit :: Word2 -> Int -> Word2 # testBit :: Word2 -> Int -> Bool # bitSizeMaybe :: Word2 -> Maybe Int # bitSize :: Word2 -> Int # isSigned :: Word2 -> Bool # shiftL :: Word2 -> Int -> Word2 # unsafeShiftL :: Word2 -> Int -> Word2 # shiftR :: Word2 -> Int -> Word2 # unsafeShiftR :: Word2 -> Int -> Word2 # rotateL :: Word2 -> Int -> Word2 # rotateR :: Word2 -> Int -> Word2 # popCount :: Word2 -> Int #
FiniteBits Word2 Source #
Methods finiteBitSize :: Word2 -> Int # countLeadingZeros :: Word2 -> Int # countTrailingZeros :: Word2 -> Int #
BinaryWord Word2 Source #
Associated Types type UnsignedWord Word2 :: * # type SignedWord Word2 :: * # Methods unsignedWord :: Word2 -> UnsignedWord Word2 # signedWord :: Word2 -> SignedWord Word2 # unwrappedAdd :: Word2 -> Word2 -> (Word2, UnsignedWord Word2) # unwrappedMul :: Word2 -> Word2 -> (Word2, UnsignedWord Word2) # leadingZeroes :: Word2 -> Int # trailingZeroes :: Word2 -> Int # allZeroes :: Word2 # allOnes :: Word2 # msb :: Word2 # lsb :: Word2 # testMsb :: Word2 -> Bool # testLsb :: Word2 -> Bool # setMsb :: Word2 -> Word2 # setLsb :: Word2 -> Word2 # clearMsb :: Word2 -> Word2 # clearLsb :: Word2 -> Word2 #
Hashable Word2 Source #
Methods hashWithSalt :: Int -> Word2 -> Int # hash :: Word2 -> Int #
type SignedWord Word2 Source #
type SignedWord Word2 = Int2
type UnsignedWord Word2 Source #
type UnsignedWord Word2 = Word2

data Word4 Source #

Instances

Bounded Word4 Source #
Methods minBound :: Word4 # maxBound :: Word4 #
Enum Word4 Source #
Methods succ :: Word4 -> Word4 # pred :: Word4 -> Word4 # toEnum :: Int -> Word4 # fromEnum :: Word4 -> Int # enumFrom :: Word4 -> [Word4] # enumFromThen :: Word4 -> Word4 -> [Word4] # enumFromTo :: Word4 -> Word4 -> [Word4] # enumFromThenTo :: Word4 -> Word4 -> Word4 -> [Word4] #
Eq Word4 Source #
Methods (==) :: Word4 -> Word4 -> Bool # (/=) :: Word4 -> Word4 -> Bool #
Integral Word4 Source #
Methods quot :: Word4 -> Word4 -> Word4 # rem :: Word4 -> Word4 -> Word4 # div :: Word4 -> Word4 -> Word4 # mod :: Word4 -> Word4 -> Word4 # quotRem :: Word4 -> Word4 -> (Word4, Word4) # divMod :: Word4 -> Word4 -> (Word4, Word4) # toInteger :: Word4 -> Integer #
Data Word4 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word4 -> c Word4 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word4 # toConstr :: Word4 -> Constr # dataTypeOf :: Word4 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word4) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word4) # gmapT :: (forall b. Data b => b -> b) -> Word4 -> Word4 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word4 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word4 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word4 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word4 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word4 -> m Word4 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word4 -> m Word4 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word4 -> m Word4 #
Num Word4 Source #
Methods (+) :: Word4 -> Word4 -> Word4 # (-) :: Word4 -> Word4 -> Word4 # (*) :: Word4 -> Word4 -> Word4 # negate :: Word4 -> Word4 # abs :: Word4 -> Word4 # signum :: Word4 -> Word4 # fromInteger :: Integer -> Word4 #
Ord Word4 Source #
Methods compare :: Word4 -> Word4 -> Ordering # (<) :: Word4 -> Word4 -> Bool # (<=) :: Word4 -> Word4 -> Bool # (>) :: Word4 -> Word4 -> Bool # (>=) :: Word4 -> Word4 -> Bool # max :: Word4 -> Word4 -> Word4 # min :: Word4 -> Word4 -> Word4 #
Read Word4 Source #
Methods readsPrec :: Int -> ReadS Word4 # readList :: ReadS [Word4] # readPrec :: ReadPrec Word4 # readListPrec :: ReadPrec [Word4] #
Real Word4 Source #
Methods toRational :: Word4 -> Rational #
Show Word4 Source #
Methods showsPrec :: Int -> Word4 -> ShowS # show :: Word4 -> String # showList :: [Word4] -> ShowS #
Ix Word4 Source #
Methods range :: (Word4, Word4) -> [Word4] # index :: (Word4, Word4) -> Word4 -> Int # unsafeIndex :: (Word4, Word4) -> Word4 -> Int inRange :: (Word4, Word4) -> Word4 -> Bool # rangeSize :: (Word4, Word4) -> Int # unsafeRangeSize :: (Word4, Word4) -> Int
Bits Word4 Source #
Methods (.&.) :: Word4 -> Word4 -> Word4 # (.\|.) :: Word4 -> Word4 -> Word4 # xor :: Word4 -> Word4 -> Word4 # complement :: Word4 -> Word4 # shift :: Word4 -> Int -> Word4 # rotate :: Word4 -> Int -> Word4 # zeroBits :: Word4 # bit :: Int -> Word4 # setBit :: Word4 -> Int -> Word4 # clearBit :: Word4 -> Int -> Word4 # complementBit :: Word4 -> Int -> Word4 # testBit :: Word4 -> Int -> Bool # bitSizeMaybe :: Word4 -> Maybe Int # bitSize :: Word4 -> Int # isSigned :: Word4 -> Bool # shiftL :: Word4 -> Int -> Word4 # unsafeShiftL :: Word4 -> Int -> Word4 # shiftR :: Word4 -> Int -> Word4 # unsafeShiftR :: Word4 -> Int -> Word4 # rotateL :: Word4 -> Int -> Word4 # rotateR :: Word4 -> Int -> Word4 # popCount :: Word4 -> Int #
FiniteBits Word4 Source #
Methods finiteBitSize :: Word4 -> Int # countLeadingZeros :: Word4 -> Int # countTrailingZeros :: Word4 -> Int #
BinaryWord Word4 Source #
Associated Types type UnsignedWord Word4 :: * # type SignedWord Word4 :: * # Methods unsignedWord :: Word4 -> UnsignedWord Word4 # signedWord :: Word4 -> SignedWord Word4 # unwrappedAdd :: Word4 -> Word4 -> (Word4, UnsignedWord Word4) # unwrappedMul :: Word4 -> Word4 -> (Word4, UnsignedWord Word4) # leadingZeroes :: Word4 -> Int # trailingZeroes :: Word4 -> Int # allZeroes :: Word4 # allOnes :: Word4 # msb :: Word4 # lsb :: Word4 # testMsb :: Word4 -> Bool # testLsb :: Word4 -> Bool # setMsb :: Word4 -> Word4 # setLsb :: Word4 -> Word4 # clearMsb :: Word4 -> Word4 # clearLsb :: Word4 -> Word4 #
Hashable Word4 Source #
Methods hashWithSalt :: Int -> Word4 -> Int # hash :: Word4 -> Int #
type SignedWord Word4 Source #
type SignedWord Word4 = Int4
type UnsignedWord Word4 Source #
type UnsignedWord Word4 = Word4

data Word7 Source #

Instances

Bounded Word7 Source #
Methods minBound :: Word7 # maxBound :: Word7 #
Enum Word7 Source #
Methods succ :: Word7 -> Word7 # pred :: Word7 -> Word7 # toEnum :: Int -> Word7 # fromEnum :: Word7 -> Int # enumFrom :: Word7 -> [Word7] # enumFromThen :: Word7 -> Word7 -> [Word7] # enumFromTo :: Word7 -> Word7 -> [Word7] # enumFromThenTo :: Word7 -> Word7 -> Word7 -> [Word7] #
Eq Word7 Source #
Methods (==) :: Word7 -> Word7 -> Bool # (/=) :: Word7 -> Word7 -> Bool #
Integral Word7 Source #
Methods quot :: Word7 -> Word7 -> Word7 # rem :: Word7 -> Word7 -> Word7 # div :: Word7 -> Word7 -> Word7 # mod :: Word7 -> Word7 -> Word7 # quotRem :: Word7 -> Word7 -> (Word7, Word7) # divMod :: Word7 -> Word7 -> (Word7, Word7) # toInteger :: Word7 -> Integer #
Data Word7 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word7 -> c Word7 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word7 # toConstr :: Word7 -> Constr # dataTypeOf :: Word7 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word7) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word7) # gmapT :: (forall b. Data b => b -> b) -> Word7 -> Word7 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word7 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word7 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word7 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word7 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word7 -> m Word7 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word7 -> m Word7 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word7 -> m Word7 #
Num Word7 Source #
Methods (+) :: Word7 -> Word7 -> Word7 # (-) :: Word7 -> Word7 -> Word7 # (*) :: Word7 -> Word7 -> Word7 # negate :: Word7 -> Word7 # abs :: Word7 -> Word7 # signum :: Word7 -> Word7 # fromInteger :: Integer -> Word7 #
Ord Word7 Source #
Methods compare :: Word7 -> Word7 -> Ordering # (<) :: Word7 -> Word7 -> Bool # (<=) :: Word7 -> Word7 -> Bool # (>) :: Word7 -> Word7 -> Bool # (>=) :: Word7 -> Word7 -> Bool # max :: Word7 -> Word7 -> Word7 # min :: Word7 -> Word7 -> Word7 #
Read Word7 Source #
Methods readsPrec :: Int -> ReadS Word7 # readList :: ReadS [Word7] # readPrec :: ReadPrec Word7 # readListPrec :: ReadPrec [Word7] #
Real Word7 Source #
Methods toRational :: Word7 -> Rational #
Show Word7 Source #
Methods showsPrec :: Int -> Word7 -> ShowS # show :: Word7 -> String # showList :: [Word7] -> ShowS #
Ix Word7 Source #
Methods range :: (Word7, Word7) -> [Word7] # index :: (Word7, Word7) -> Word7 -> Int # unsafeIndex :: (Word7, Word7) -> Word7 -> Int inRange :: (Word7, Word7) -> Word7 -> Bool # rangeSize :: (Word7, Word7) -> Int # unsafeRangeSize :: (Word7, Word7) -> Int
Bits Word7 Source #
Methods (.&.) :: Word7 -> Word7 -> Word7 # (.\|.) :: Word7 -> Word7 -> Word7 # xor :: Word7 -> Word7 -> Word7 # complement :: Word7 -> Word7 # shift :: Word7 -> Int -> Word7 # rotate :: Word7 -> Int -> Word7 # zeroBits :: Word7 # bit :: Int -> Word7 # setBit :: Word7 -> Int -> Word7 # clearBit :: Word7 -> Int -> Word7 # complementBit :: Word7 -> Int -> Word7 # testBit :: Word7 -> Int -> Bool # bitSizeMaybe :: Word7 -> Maybe Int # bitSize :: Word7 -> Int # isSigned :: Word7 -> Bool # shiftL :: Word7 -> Int -> Word7 # unsafeShiftL :: Word7 -> Int -> Word7 # shiftR :: Word7 -> Int -> Word7 # unsafeShiftR :: Word7 -> Int -> Word7 # rotateL :: Word7 -> Int -> Word7 # rotateR :: Word7 -> Int -> Word7 # popCount :: Word7 -> Int #
FiniteBits Word7 Source #
Methods finiteBitSize :: Word7 -> Int # countLeadingZeros :: Word7 -> Int # countTrailingZeros :: Word7 -> Int #
BinaryWord Word7 Source #
Associated Types type UnsignedWord Word7 :: * # type SignedWord Word7 :: * # Methods unsignedWord :: Word7 -> UnsignedWord Word7 # signedWord :: Word7 -> SignedWord Word7 # unwrappedAdd :: Word7 -> Word7 -> (Word7, UnsignedWord Word7) # unwrappedMul :: Word7 -> Word7 -> (Word7, UnsignedWord Word7) # leadingZeroes :: Word7 -> Int # trailingZeroes :: Word7 -> Int # allZeroes :: Word7 # allOnes :: Word7 # msb :: Word7 # lsb :: Word7 # testMsb :: Word7 -> Bool # testLsb :: Word7 -> Bool # setMsb :: Word7 -> Word7 # setLsb :: Word7 -> Word7 # clearMsb :: Word7 -> Word7 # clearLsb :: Word7 -> Word7 #
Hashable Word7 Source #
Methods hashWithSalt :: Int -> Word7 -> Int # hash :: Word7 -> Int #
type SignedWord Word7 Source #
type SignedWord Word7 = Int7
type UnsignedWord Word7 Source #
type UnsignedWord Word7 = Word7

data Word24 Source #

Instances

Bounded Word24 Source #
Methods minBound :: Word24 # maxBound :: Word24 #
Enum Word24 Source #
Methods succ :: Word24 -> Word24 # pred :: Word24 -> Word24 # toEnum :: Int -> Word24 # fromEnum :: Word24 -> Int # enumFrom :: Word24 -> [Word24] # enumFromThen :: Word24 -> Word24 -> [Word24] # enumFromTo :: Word24 -> Word24 -> [Word24] # enumFromThenTo :: Word24 -> Word24 -> Word24 -> [Word24] #
Eq Word24 Source #
Methods (==) :: Word24 -> Word24 -> Bool # (/=) :: Word24 -> Word24 -> Bool #
Integral Word24 Source #
Methods quot :: Word24 -> Word24 -> Word24 # rem :: Word24 -> Word24 -> Word24 # div :: Word24 -> Word24 -> Word24 # mod :: Word24 -> Word24 -> Word24 # quotRem :: Word24 -> Word24 -> (Word24, Word24) # divMod :: Word24 -> Word24 -> (Word24, Word24) # toInteger :: Word24 -> Integer #
Data Word24 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word24 -> c Word24 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word24 # toConstr :: Word24 -> Constr # dataTypeOf :: Word24 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word24) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word24) # gmapT :: (forall b. Data b => b -> b) -> Word24 -> Word24 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word24 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word24 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word24 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word24 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word24 -> m Word24 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word24 -> m Word24 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word24 -> m Word24 #
Num Word24 Source #
Methods (+) :: Word24 -> Word24 -> Word24 # (-) :: Word24 -> Word24 -> Word24 # (*) :: Word24 -> Word24 -> Word24 # negate :: Word24 -> Word24 # abs :: Word24 -> Word24 # signum :: Word24 -> Word24 # fromInteger :: Integer -> Word24 #
Ord Word24 Source #
Methods compare :: Word24 -> Word24 -> Ordering # (<) :: Word24 -> Word24 -> Bool # (<=) :: Word24 -> Word24 -> Bool # (>) :: Word24 -> Word24 -> Bool # (>=) :: Word24 -> Word24 -> Bool # max :: Word24 -> Word24 -> Word24 # min :: Word24 -> Word24 -> Word24 #
Read Word24 Source #
Methods readsPrec :: Int -> ReadS Word24 # readList :: ReadS [Word24] # readPrec :: ReadPrec Word24 # readListPrec :: ReadPrec [Word24] #
Real Word24 Source #
Methods toRational :: Word24 -> Rational #
Show Word24 Source #
Methods showsPrec :: Int -> Word24 -> ShowS # show :: Word24 -> String # showList :: [Word24] -> ShowS #
Ix Word24 Source #
Methods range :: (Word24, Word24) -> [Word24] # index :: (Word24, Word24) -> Word24 -> Int # unsafeIndex :: (Word24, Word24) -> Word24 -> Int inRange :: (Word24, Word24) -> Word24 -> Bool # rangeSize :: (Word24, Word24) -> Int # unsafeRangeSize :: (Word24, Word24) -> Int
Bits Word24 Source #
Methods (.&.) :: Word24 -> Word24 -> Word24 # (.\|.) :: Word24 -> Word24 -> Word24 # xor :: Word24 -> Word24 -> Word24 # complement :: Word24 -> Word24 # shift :: Word24 -> Int -> Word24 # rotate :: Word24 -> Int -> Word24 # zeroBits :: Word24 # bit :: Int -> Word24 # setBit :: Word24 -> Int -> Word24 # clearBit :: Word24 -> Int -> Word24 # complementBit :: Word24 -> Int -> Word24 # testBit :: Word24 -> Int -> Bool # bitSizeMaybe :: Word24 -> Maybe Int # bitSize :: Word24 -> Int # isSigned :: Word24 -> Bool # shiftL :: Word24 -> Int -> Word24 # unsafeShiftL :: Word24 -> Int -> Word24 # shiftR :: Word24 -> Int -> Word24 # unsafeShiftR :: Word24 -> Int -> Word24 # rotateL :: Word24 -> Int -> Word24 # rotateR :: Word24 -> Int -> Word24 # popCount :: Word24 -> Int #
FiniteBits Word24 Source #
Methods finiteBitSize :: Word24 -> Int # countLeadingZeros :: Word24 -> Int # countTrailingZeros :: Word24 -> Int #
BinaryWord Word24 Source #
Associated Types type UnsignedWord Word24 :: * # type SignedWord Word24 :: * # Methods unsignedWord :: Word24 -> UnsignedWord Word24 # signedWord :: Word24 -> SignedWord Word24 # unwrappedAdd :: Word24 -> Word24 -> (Word24, UnsignedWord Word24) # unwrappedMul :: Word24 -> Word24 -> (Word24, UnsignedWord Word24) # leadingZeroes :: Word24 -> Int # trailingZeroes :: Word24 -> Int # allZeroes :: Word24 # allOnes :: Word24 # msb :: Word24 # lsb :: Word24 # testMsb :: Word24 -> Bool # testLsb :: Word24 -> Bool # setMsb :: Word24 -> Word24 # setLsb :: Word24 -> Word24 # clearMsb :: Word24 -> Word24 # clearLsb :: Word24 -> Word24 #
Hashable Word24 Source #
Methods hashWithSalt :: Int -> Word24 -> Int # hash :: Word24 -> Int #
type SignedWord Word24 Source #
type SignedWord Word24 = Int24
type UnsignedWord Word24 Source #
type UnsignedWord Word24 = Word24

data Word48 Source #

Instances

Bounded Word48 Source #
Methods minBound :: Word48 # maxBound :: Word48 #
Enum Word48 Source #
Methods succ :: Word48 -> Word48 # pred :: Word48 -> Word48 # toEnum :: Int -> Word48 # fromEnum :: Word48 -> Int # enumFrom :: Word48 -> [Word48] # enumFromThen :: Word48 -> Word48 -> [Word48] # enumFromTo :: Word48 -> Word48 -> [Word48] # enumFromThenTo :: Word48 -> Word48 -> Word48 -> [Word48] #
Eq Word48 Source #
Methods (==) :: Word48 -> Word48 -> Bool # (/=) :: Word48 -> Word48 -> Bool #
Integral Word48 Source #
Methods quot :: Word48 -> Word48 -> Word48 # rem :: Word48 -> Word48 -> Word48 # div :: Word48 -> Word48 -> Word48 # mod :: Word48 -> Word48 -> Word48 # quotRem :: Word48 -> Word48 -> (Word48, Word48) # divMod :: Word48 -> Word48 -> (Word48, Word48) # toInteger :: Word48 -> Integer #
Data Word48 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word48 -> c Word48 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word48 # toConstr :: Word48 -> Constr # dataTypeOf :: Word48 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Word48) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word48) # gmapT :: (forall b. Data b => b -> b) -> Word48 -> Word48 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word48 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word48 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word48 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word48 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word48 -> m Word48 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word48 -> m Word48 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word48 -> m Word48 #
Num Word48 Source #
Methods (+) :: Word48 -> Word48 -> Word48 # (-) :: Word48 -> Word48 -> Word48 # (*) :: Word48 -> Word48 -> Word48 # negate :: Word48 -> Word48 # abs :: Word48 -> Word48 # signum :: Word48 -> Word48 # fromInteger :: Integer -> Word48 #
Ord Word48 Source #
Methods compare :: Word48 -> Word48 -> Ordering # (<) :: Word48 -> Word48 -> Bool # (<=) :: Word48 -> Word48 -> Bool # (>) :: Word48 -> Word48 -> Bool # (>=) :: Word48 -> Word48 -> Bool # max :: Word48 -> Word48 -> Word48 # min :: Word48 -> Word48 -> Word48 #
Read Word48 Source #
Methods readsPrec :: Int -> ReadS Word48 # readList :: ReadS [Word48] # readPrec :: ReadPrec Word48 # readListPrec :: ReadPrec [Word48] #
Real Word48 Source #
Methods toRational :: Word48 -> Rational #
Show Word48 Source #
Methods showsPrec :: Int -> Word48 -> ShowS # show :: Word48 -> String # showList :: [Word48] -> ShowS #
Ix Word48 Source #
Methods range :: (Word48, Word48) -> [Word48] # index :: (Word48, Word48) -> Word48 -> Int # unsafeIndex :: (Word48, Word48) -> Word48 -> Int inRange :: (Word48, Word48) -> Word48 -> Bool # rangeSize :: (Word48, Word48) -> Int # unsafeRangeSize :: (Word48, Word48) -> Int
Bits Word48 Source #
Methods (.&.) :: Word48 -> Word48 -> Word48 # (.\|.) :: Word48 -> Word48 -> Word48 # xor :: Word48 -> Word48 -> Word48 # complement :: Word48 -> Word48 # shift :: Word48 -> Int -> Word48 # rotate :: Word48 -> Int -> Word48 # zeroBits :: Word48 # bit :: Int -> Word48 # setBit :: Word48 -> Int -> Word48 # clearBit :: Word48 -> Int -> Word48 # complementBit :: Word48 -> Int -> Word48 # testBit :: Word48 -> Int -> Bool # bitSizeMaybe :: Word48 -> Maybe Int # bitSize :: Word48 -> Int # isSigned :: Word48 -> Bool # shiftL :: Word48 -> Int -> Word48 # unsafeShiftL :: Word48 -> Int -> Word48 # shiftR :: Word48 -> Int -> Word48 # unsafeShiftR :: Word48 -> Int -> Word48 # rotateL :: Word48 -> Int -> Word48 # rotateR :: Word48 -> Int -> Word48 # popCount :: Word48 -> Int #
FiniteBits Word48 Source #
Methods finiteBitSize :: Word48 -> Int # countLeadingZeros :: Word48 -> Int # countTrailingZeros :: Word48 -> Int #
BinaryWord Word48 Source #
Associated Types type UnsignedWord Word48 :: * # type SignedWord Word48 :: * # Methods unsignedWord :: Word48 -> UnsignedWord Word48 # signedWord :: Word48 -> SignedWord Word48 # unwrappedAdd :: Word48 -> Word48 -> (Word48, UnsignedWord Word48) # unwrappedMul :: Word48 -> Word48 -> (Word48, UnsignedWord Word48) # leadingZeroes :: Word48 -> Int # trailingZeroes :: Word48 -> Int # allZeroes :: Word48 # allOnes :: Word48 # msb :: Word48 # lsb :: Word48 # testMsb :: Word48 -> Bool # testLsb :: Word48 -> Bool # setMsb :: Word48 -> Word48 # setLsb :: Word48 -> Word48 # clearMsb :: Word48 -> Word48 # clearLsb :: Word48 -> Word48 #
Hashable Word48 Source #
Methods hashWithSalt :: Int -> Word48 -> Int # hash :: Word48 -> Int #
type SignedWord Word48 Source #
type SignedWord Word48 = Int48
type UnsignedWord Word48 Source #
type UnsignedWord Word48 = Word48

data Int2 Source #

Instances

Bounded Int2 Source #
Methods minBound :: Int2 # maxBound :: Int2 #
Enum Int2 Source #
Methods succ :: Int2 -> Int2 # pred :: Int2 -> Int2 # toEnum :: Int -> Int2 # fromEnum :: Int2 -> Int # enumFrom :: Int2 -> [Int2] # enumFromThen :: Int2 -> Int2 -> [Int2] # enumFromTo :: Int2 -> Int2 -> [Int2] # enumFromThenTo :: Int2 -> Int2 -> Int2 -> [Int2] #
Eq Int2 Source #
Methods (==) :: Int2 -> Int2 -> Bool # (/=) :: Int2 -> Int2 -> Bool #
Integral Int2 Source #
Methods quot :: Int2 -> Int2 -> Int2 # rem :: Int2 -> Int2 -> Int2 # div :: Int2 -> Int2 -> Int2 # mod :: Int2 -> Int2 -> Int2 # quotRem :: Int2 -> Int2 -> (Int2, Int2) # divMod :: Int2 -> Int2 -> (Int2, Int2) # toInteger :: Int2 -> Integer #
Data Int2 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int2 -> c Int2 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int2 # toConstr :: Int2 -> Constr # dataTypeOf :: Int2 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int2) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int2) # gmapT :: (forall b. Data b => b -> b) -> Int2 -> Int2 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int2 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int2 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int2 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int2 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int2 -> m Int2 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int2 -> m Int2 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int2 -> m Int2 #
Num Int2 Source #
Methods (+) :: Int2 -> Int2 -> Int2 # (-) :: Int2 -> Int2 -> Int2 # (*) :: Int2 -> Int2 -> Int2 # negate :: Int2 -> Int2 # abs :: Int2 -> Int2 # signum :: Int2 -> Int2 # fromInteger :: Integer -> Int2 #
Ord Int2 Source #
Methods compare :: Int2 -> Int2 -> Ordering # (<) :: Int2 -> Int2 -> Bool # (<=) :: Int2 -> Int2 -> Bool # (>) :: Int2 -> Int2 -> Bool # (>=) :: Int2 -> Int2 -> Bool # max :: Int2 -> Int2 -> Int2 # min :: Int2 -> Int2 -> Int2 #
Read Int2 Source #
Methods readsPrec :: Int -> ReadS Int2 # readList :: ReadS [Int2] # readPrec :: ReadPrec Int2 # readListPrec :: ReadPrec [Int2] #
Real Int2 Source #
Methods toRational :: Int2 -> Rational #
Show Int2 Source #
Methods showsPrec :: Int -> Int2 -> ShowS # show :: Int2 -> String # showList :: [Int2] -> ShowS #
Ix Int2 Source #
Methods range :: (Int2, Int2) -> [Int2] # index :: (Int2, Int2) -> Int2 -> Int # unsafeIndex :: (Int2, Int2) -> Int2 -> Int inRange :: (Int2, Int2) -> Int2 -> Bool # rangeSize :: (Int2, Int2) -> Int # unsafeRangeSize :: (Int2, Int2) -> Int
Bits Int2 Source #
Methods (.&.) :: Int2 -> Int2 -> Int2 # (.\|.) :: Int2 -> Int2 -> Int2 # xor :: Int2 -> Int2 -> Int2 # complement :: Int2 -> Int2 # shift :: Int2 -> Int -> Int2 # rotate :: Int2 -> Int -> Int2 # zeroBits :: Int2 # bit :: Int -> Int2 # setBit :: Int2 -> Int -> Int2 # clearBit :: Int2 -> Int -> Int2 # complementBit :: Int2 -> Int -> Int2 # testBit :: Int2 -> Int -> Bool # bitSizeMaybe :: Int2 -> Maybe Int # bitSize :: Int2 -> Int # isSigned :: Int2 -> Bool # shiftL :: Int2 -> Int -> Int2 # unsafeShiftL :: Int2 -> Int -> Int2 # shiftR :: Int2 -> Int -> Int2 # unsafeShiftR :: Int2 -> Int -> Int2 # rotateL :: Int2 -> Int -> Int2 # rotateR :: Int2 -> Int -> Int2 # popCount :: Int2 -> Int #
FiniteBits Int2 Source #
Methods finiteBitSize :: Int2 -> Int # countLeadingZeros :: Int2 -> Int # countTrailingZeros :: Int2 -> Int #
BinaryWord Int2 Source #
Associated Types type UnsignedWord Int2 :: * # type SignedWord Int2 :: * # Methods unsignedWord :: Int2 -> UnsignedWord Int2 # signedWord :: Int2 -> SignedWord Int2 # unwrappedAdd :: Int2 -> Int2 -> (Int2, UnsignedWord Int2) # unwrappedMul :: Int2 -> Int2 -> (Int2, UnsignedWord Int2) # leadingZeroes :: Int2 -> Int # trailingZeroes :: Int2 -> Int # allZeroes :: Int2 # allOnes :: Int2 # msb :: Int2 # lsb :: Int2 # testMsb :: Int2 -> Bool # testLsb :: Int2 -> Bool # setMsb :: Int2 -> Int2 # setLsb :: Int2 -> Int2 # clearMsb :: Int2 -> Int2 # clearLsb :: Int2 -> Int2 #
Hashable Int2 Source #
Methods hashWithSalt :: Int -> Int2 -> Int # hash :: Int2 -> Int #
type SignedWord Int2 Source #
type SignedWord Int2 = Int2
type UnsignedWord Int2 Source #
type UnsignedWord Int2 = Word2

data Int4 Source #

Instances

Bounded Int4 Source #
Methods minBound :: Int4 # maxBound :: Int4 #
Enum Int4 Source #
Methods succ :: Int4 -> Int4 # pred :: Int4 -> Int4 # toEnum :: Int -> Int4 # fromEnum :: Int4 -> Int # enumFrom :: Int4 -> [Int4] # enumFromThen :: Int4 -> Int4 -> [Int4] # enumFromTo :: Int4 -> Int4 -> [Int4] # enumFromThenTo :: Int4 -> Int4 -> Int4 -> [Int4] #
Eq Int4 Source #
Methods (==) :: Int4 -> Int4 -> Bool # (/=) :: Int4 -> Int4 -> Bool #
Integral Int4 Source #
Methods quot :: Int4 -> Int4 -> Int4 # rem :: Int4 -> Int4 -> Int4 # div :: Int4 -> Int4 -> Int4 # mod :: Int4 -> Int4 -> Int4 # quotRem :: Int4 -> Int4 -> (Int4, Int4) # divMod :: Int4 -> Int4 -> (Int4, Int4) # toInteger :: Int4 -> Integer #
Data Int4 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int4 -> c Int4 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int4 # toConstr :: Int4 -> Constr # dataTypeOf :: Int4 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int4) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int4) # gmapT :: (forall b. Data b => b -> b) -> Int4 -> Int4 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int4 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int4 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int4 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int4 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int4 -> m Int4 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int4 -> m Int4 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int4 -> m Int4 #
Num Int4 Source #
Methods (+) :: Int4 -> Int4 -> Int4 # (-) :: Int4 -> Int4 -> Int4 # (*) :: Int4 -> Int4 -> Int4 # negate :: Int4 -> Int4 # abs :: Int4 -> Int4 # signum :: Int4 -> Int4 # fromInteger :: Integer -> Int4 #
Ord Int4 Source #
Methods compare :: Int4 -> Int4 -> Ordering # (<) :: Int4 -> Int4 -> Bool # (<=) :: Int4 -> Int4 -> Bool # (>) :: Int4 -> Int4 -> Bool # (>=) :: Int4 -> Int4 -> Bool # max :: Int4 -> Int4 -> Int4 # min :: Int4 -> Int4 -> Int4 #
Read Int4 Source #
Methods readsPrec :: Int -> ReadS Int4 # readList :: ReadS [Int4] # readPrec :: ReadPrec Int4 # readListPrec :: ReadPrec [Int4] #
Real Int4 Source #
Methods toRational :: Int4 -> Rational #
Show Int4 Source #
Methods showsPrec :: Int -> Int4 -> ShowS # show :: Int4 -> String # showList :: [Int4] -> ShowS #
Ix Int4 Source #
Methods range :: (Int4, Int4) -> [Int4] # index :: (Int4, Int4) -> Int4 -> Int # unsafeIndex :: (Int4, Int4) -> Int4 -> Int inRange :: (Int4, Int4) -> Int4 -> Bool # rangeSize :: (Int4, Int4) -> Int # unsafeRangeSize :: (Int4, Int4) -> Int
Bits Int4 Source #
Methods (.&.) :: Int4 -> Int4 -> Int4 # (.\|.) :: Int4 -> Int4 -> Int4 # xor :: Int4 -> Int4 -> Int4 # complement :: Int4 -> Int4 # shift :: Int4 -> Int -> Int4 # rotate :: Int4 -> Int -> Int4 # zeroBits :: Int4 # bit :: Int -> Int4 # setBit :: Int4 -> Int -> Int4 # clearBit :: Int4 -> Int -> Int4 # complementBit :: Int4 -> Int -> Int4 # testBit :: Int4 -> Int -> Bool # bitSizeMaybe :: Int4 -> Maybe Int # bitSize :: Int4 -> Int # isSigned :: Int4 -> Bool # shiftL :: Int4 -> Int -> Int4 # unsafeShiftL :: Int4 -> Int -> Int4 # shiftR :: Int4 -> Int -> Int4 # unsafeShiftR :: Int4 -> Int -> Int4 # rotateL :: Int4 -> Int -> Int4 # rotateR :: Int4 -> Int -> Int4 # popCount :: Int4 -> Int #
FiniteBits Int4 Source #
Methods finiteBitSize :: Int4 -> Int # countLeadingZeros :: Int4 -> Int # countTrailingZeros :: Int4 -> Int #
BinaryWord Int4 Source #
Associated Types type UnsignedWord Int4 :: * # type SignedWord Int4 :: * # Methods unsignedWord :: Int4 -> UnsignedWord Int4 # signedWord :: Int4 -> SignedWord Int4 # unwrappedAdd :: Int4 -> Int4 -> (Int4, UnsignedWord Int4) # unwrappedMul :: Int4 -> Int4 -> (Int4, UnsignedWord Int4) # leadingZeroes :: Int4 -> Int # trailingZeroes :: Int4 -> Int # allZeroes :: Int4 # allOnes :: Int4 # msb :: Int4 # lsb :: Int4 # testMsb :: Int4 -> Bool # testLsb :: Int4 -> Bool # setMsb :: Int4 -> Int4 # setLsb :: Int4 -> Int4 # clearMsb :: Int4 -> Int4 # clearLsb :: Int4 -> Int4 #
Hashable Int4 Source #
Methods hashWithSalt :: Int -> Int4 -> Int # hash :: Int4 -> Int #
type SignedWord Int4 Source #
type SignedWord Int4 = Int4
type UnsignedWord Int4 Source #
type UnsignedWord Int4 = Word4

data Int7 Source #

Instances

Bounded Int7 Source #
Methods minBound :: Int7 # maxBound :: Int7 #
Enum Int7 Source #
Methods succ :: Int7 -> Int7 # pred :: Int7 -> Int7 # toEnum :: Int -> Int7 # fromEnum :: Int7 -> Int # enumFrom :: Int7 -> [Int7] # enumFromThen :: Int7 -> Int7 -> [Int7] # enumFromTo :: Int7 -> Int7 -> [Int7] # enumFromThenTo :: Int7 -> Int7 -> Int7 -> [Int7] #
Eq Int7 Source #
Methods (==) :: Int7 -> Int7 -> Bool # (/=) :: Int7 -> Int7 -> Bool #
Integral Int7 Source #
Methods quot :: Int7 -> Int7 -> Int7 # rem :: Int7 -> Int7 -> Int7 # div :: Int7 -> Int7 -> Int7 # mod :: Int7 -> Int7 -> Int7 # quotRem :: Int7 -> Int7 -> (Int7, Int7) # divMod :: Int7 -> Int7 -> (Int7, Int7) # toInteger :: Int7 -> Integer #
Data Int7 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int7 -> c Int7 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int7 # toConstr :: Int7 -> Constr # dataTypeOf :: Int7 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int7) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int7) # gmapT :: (forall b. Data b => b -> b) -> Int7 -> Int7 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int7 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int7 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int7 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int7 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int7 -> m Int7 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int7 -> m Int7 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int7 -> m Int7 #
Num Int7 Source #
Methods (+) :: Int7 -> Int7 -> Int7 # (-) :: Int7 -> Int7 -> Int7 # (*) :: Int7 -> Int7 -> Int7 # negate :: Int7 -> Int7 # abs :: Int7 -> Int7 # signum :: Int7 -> Int7 # fromInteger :: Integer -> Int7 #
Ord Int7 Source #
Methods compare :: Int7 -> Int7 -> Ordering # (<) :: Int7 -> Int7 -> Bool # (<=) :: Int7 -> Int7 -> Bool # (>) :: Int7 -> Int7 -> Bool # (>=) :: Int7 -> Int7 -> Bool # max :: Int7 -> Int7 -> Int7 # min :: Int7 -> Int7 -> Int7 #
Read Int7 Source #
Methods readsPrec :: Int -> ReadS Int7 # readList :: ReadS [Int7] # readPrec :: ReadPrec Int7 # readListPrec :: ReadPrec [Int7] #
Real Int7 Source #
Methods toRational :: Int7 -> Rational #
Show Int7 Source #
Methods showsPrec :: Int -> Int7 -> ShowS # show :: Int7 -> String # showList :: [Int7] -> ShowS #
Ix Int7 Source #
Methods range :: (Int7, Int7) -> [Int7] # index :: (Int7, Int7) -> Int7 -> Int # unsafeIndex :: (Int7, Int7) -> Int7 -> Int inRange :: (Int7, Int7) -> Int7 -> Bool # rangeSize :: (Int7, Int7) -> Int # unsafeRangeSize :: (Int7, Int7) -> Int
Bits Int7 Source #
Methods (.&.) :: Int7 -> Int7 -> Int7 # (.\|.) :: Int7 -> Int7 -> Int7 # xor :: Int7 -> Int7 -> Int7 # complement :: Int7 -> Int7 # shift :: Int7 -> Int -> Int7 # rotate :: Int7 -> Int -> Int7 # zeroBits :: Int7 # bit :: Int -> Int7 # setBit :: Int7 -> Int -> Int7 # clearBit :: Int7 -> Int -> Int7 # complementBit :: Int7 -> Int -> Int7 # testBit :: Int7 -> Int -> Bool # bitSizeMaybe :: Int7 -> Maybe Int # bitSize :: Int7 -> Int # isSigned :: Int7 -> Bool # shiftL :: Int7 -> Int -> Int7 # unsafeShiftL :: Int7 -> Int -> Int7 # shiftR :: Int7 -> Int -> Int7 # unsafeShiftR :: Int7 -> Int -> Int7 # rotateL :: Int7 -> Int -> Int7 # rotateR :: Int7 -> Int -> Int7 # popCount :: Int7 -> Int #
FiniteBits Int7 Source #
Methods finiteBitSize :: Int7 -> Int # countLeadingZeros :: Int7 -> Int # countTrailingZeros :: Int7 -> Int #
BinaryWord Int7 Source #
Associated Types type UnsignedWord Int7 :: * # type SignedWord Int7 :: * # Methods unsignedWord :: Int7 -> UnsignedWord Int7 # signedWord :: Int7 -> SignedWord Int7 # unwrappedAdd :: Int7 -> Int7 -> (Int7, UnsignedWord Int7) # unwrappedMul :: Int7 -> Int7 -> (Int7, UnsignedWord Int7) # leadingZeroes :: Int7 -> Int # trailingZeroes :: Int7 -> Int # allZeroes :: Int7 # allOnes :: Int7 # msb :: Int7 # lsb :: Int7 # testMsb :: Int7 -> Bool # testLsb :: Int7 -> Bool # setMsb :: Int7 -> Int7 # setLsb :: Int7 -> Int7 # clearMsb :: Int7 -> Int7 # clearLsb :: Int7 -> Int7 #
Hashable Int7 Source #
Methods hashWithSalt :: Int -> Int7 -> Int # hash :: Int7 -> Int #
type SignedWord Int7 Source #
type SignedWord Int7 = Int7
type UnsignedWord Int7 Source #
type UnsignedWord Int7 = Word7

data Int24 Source #

Instances

Bounded Int24 Source #
Methods minBound :: Int24 # maxBound :: Int24 #
Enum Int24 Source #
Methods succ :: Int24 -> Int24 # pred :: Int24 -> Int24 # toEnum :: Int -> Int24 # fromEnum :: Int24 -> Int # enumFrom :: Int24 -> [Int24] # enumFromThen :: Int24 -> Int24 -> [Int24] # enumFromTo :: Int24 -> Int24 -> [Int24] # enumFromThenTo :: Int24 -> Int24 -> Int24 -> [Int24] #
Eq Int24 Source #
Methods (==) :: Int24 -> Int24 -> Bool # (/=) :: Int24 -> Int24 -> Bool #
Integral Int24 Source #
Methods quot :: Int24 -> Int24 -> Int24 # rem :: Int24 -> Int24 -> Int24 # div :: Int24 -> Int24 -> Int24 # mod :: Int24 -> Int24 -> Int24 # quotRem :: Int24 -> Int24 -> (Int24, Int24) # divMod :: Int24 -> Int24 -> (Int24, Int24) # toInteger :: Int24 -> Integer #
Data Int24 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int24 -> c Int24 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int24 # toConstr :: Int24 -> Constr # dataTypeOf :: Int24 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int24) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int24) # gmapT :: (forall b. Data b => b -> b) -> Int24 -> Int24 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int24 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int24 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int24 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int24 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int24 -> m Int24 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int24 -> m Int24 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int24 -> m Int24 #
Num Int24 Source #
Methods (+) :: Int24 -> Int24 -> Int24 # (-) :: Int24 -> Int24 -> Int24 # (*) :: Int24 -> Int24 -> Int24 # negate :: Int24 -> Int24 # abs :: Int24 -> Int24 # signum :: Int24 -> Int24 # fromInteger :: Integer -> Int24 #
Ord Int24 Source #
Methods compare :: Int24 -> Int24 -> Ordering # (<) :: Int24 -> Int24 -> Bool # (<=) :: Int24 -> Int24 -> Bool # (>) :: Int24 -> Int24 -> Bool # (>=) :: Int24 -> Int24 -> Bool # max :: Int24 -> Int24 -> Int24 # min :: Int24 -> Int24 -> Int24 #
Read Int24 Source #
Methods readsPrec :: Int -> ReadS Int24 # readList :: ReadS [Int24] # readPrec :: ReadPrec Int24 # readListPrec :: ReadPrec [Int24] #
Real Int24 Source #
Methods toRational :: Int24 -> Rational #
Show Int24 Source #
Methods showsPrec :: Int -> Int24 -> ShowS # show :: Int24 -> String # showList :: [Int24] -> ShowS #
Ix Int24 Source #
Methods range :: (Int24, Int24) -> [Int24] # index :: (Int24, Int24) -> Int24 -> Int # unsafeIndex :: (Int24, Int24) -> Int24 -> Int inRange :: (Int24, Int24) -> Int24 -> Bool # rangeSize :: (Int24, Int24) -> Int # unsafeRangeSize :: (Int24, Int24) -> Int
Bits Int24 Source #
Methods (.&.) :: Int24 -> Int24 -> Int24 # (.\|.) :: Int24 -> Int24 -> Int24 # xor :: Int24 -> Int24 -> Int24 # complement :: Int24 -> Int24 # shift :: Int24 -> Int -> Int24 # rotate :: Int24 -> Int -> Int24 # zeroBits :: Int24 # bit :: Int -> Int24 # setBit :: Int24 -> Int -> Int24 # clearBit :: Int24 -> Int -> Int24 # complementBit :: Int24 -> Int -> Int24 # testBit :: Int24 -> Int -> Bool # bitSizeMaybe :: Int24 -> Maybe Int # bitSize :: Int24 -> Int # isSigned :: Int24 -> Bool # shiftL :: Int24 -> Int -> Int24 # unsafeShiftL :: Int24 -> Int -> Int24 # shiftR :: Int24 -> Int -> Int24 # unsafeShiftR :: Int24 -> Int -> Int24 # rotateL :: Int24 -> Int -> Int24 # rotateR :: Int24 -> Int -> Int24 # popCount :: Int24 -> Int #
FiniteBits Int24 Source #
Methods finiteBitSize :: Int24 -> Int # countLeadingZeros :: Int24 -> Int # countTrailingZeros :: Int24 -> Int #
BinaryWord Int24 Source #
Associated Types type UnsignedWord Int24 :: * # type SignedWord Int24 :: * # Methods unsignedWord :: Int24 -> UnsignedWord Int24 # signedWord :: Int24 -> SignedWord Int24 # unwrappedAdd :: Int24 -> Int24 -> (Int24, UnsignedWord Int24) # unwrappedMul :: Int24 -> Int24 -> (Int24, UnsignedWord Int24) # leadingZeroes :: Int24 -> Int # trailingZeroes :: Int24 -> Int # allZeroes :: Int24 # allOnes :: Int24 # msb :: Int24 # lsb :: Int24 # testMsb :: Int24 -> Bool # testLsb :: Int24 -> Bool # setMsb :: Int24 -> Int24 # setLsb :: Int24 -> Int24 # clearMsb :: Int24 -> Int24 # clearLsb :: Int24 -> Int24 #
Hashable Int24 Source #
Methods hashWithSalt :: Int -> Int24 -> Int # hash :: Int24 -> Int #
type SignedWord Int24 Source #
type SignedWord Int24 = Int24
type UnsignedWord Int24 Source #
type UnsignedWord Int24 = Word24

data Int48 Source #

Instances

Bounded Int48 Source #
Methods minBound :: Int48 # maxBound :: Int48 #
Enum Int48 Source #
Methods succ :: Int48 -> Int48 # pred :: Int48 -> Int48 # toEnum :: Int -> Int48 # fromEnum :: Int48 -> Int # enumFrom :: Int48 -> [Int48] # enumFromThen :: Int48 -> Int48 -> [Int48] # enumFromTo :: Int48 -> Int48 -> [Int48] # enumFromThenTo :: Int48 -> Int48 -> Int48 -> [Int48] #
Eq Int48 Source #
Methods (==) :: Int48 -> Int48 -> Bool # (/=) :: Int48 -> Int48 -> Bool #
Integral Int48 Source #
Methods quot :: Int48 -> Int48 -> Int48 # rem :: Int48 -> Int48 -> Int48 # div :: Int48 -> Int48 -> Int48 # mod :: Int48 -> Int48 -> Int48 # quotRem :: Int48 -> Int48 -> (Int48, Int48) # divMod :: Int48 -> Int48 -> (Int48, Int48) # toInteger :: Int48 -> Integer #
Data Int48 Source #
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int48 -> c Int48 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int48 # toConstr :: Int48 -> Constr # dataTypeOf :: Int48 -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Int48) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int48) # gmapT :: (forall b. Data b => b -> b) -> Int48 -> Int48 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int48 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int48 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int48 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int48 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int48 -> m Int48 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int48 -> m Int48 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int48 -> m Int48 #
Num Int48 Source #
Methods (+) :: Int48 -> Int48 -> Int48 # (-) :: Int48 -> Int48 -> Int48 # (*) :: Int48 -> Int48 -> Int48 # negate :: Int48 -> Int48 # abs :: Int48 -> Int48 # signum :: Int48 -> Int48 # fromInteger :: Integer -> Int48 #
Ord Int48 Source #
Methods compare :: Int48 -> Int48 -> Ordering # (<) :: Int48 -> Int48 -> Bool # (<=) :: Int48 -> Int48 -> Bool # (>) :: Int48 -> Int48 -> Bool # (>=) :: Int48 -> Int48 -> Bool # max :: Int48 -> Int48 -> Int48 # min :: Int48 -> Int48 -> Int48 #
Read Int48 Source #
Methods readsPrec :: Int -> ReadS Int48 # readList :: ReadS [Int48] # readPrec :: ReadPrec Int48 # readListPrec :: ReadPrec [Int48] #
Real Int48 Source #
Methods toRational :: Int48 -> Rational #
Show Int48 Source #
Methods showsPrec :: Int -> Int48 -> ShowS # show :: Int48 -> String # showList :: [Int48] -> ShowS #
Ix Int48 Source #
Methods range :: (Int48, Int48) -> [Int48] # index :: (Int48, Int48) -> Int48 -> Int # unsafeIndex :: (Int48, Int48) -> Int48 -> Int inRange :: (Int48, Int48) -> Int48 -> Bool # rangeSize :: (Int48, Int48) -> Int # unsafeRangeSize :: (Int48, Int48) -> Int
Bits Int48 Source #
Methods (.&.) :: Int48 -> Int48 -> Int48 # (.\|.) :: Int48 -> Int48 -> Int48 # xor :: Int48 -> Int48 -> Int48 # complement :: Int48 -> Int48 # shift :: Int48 -> Int -> Int48 # rotate :: Int48 -> Int -> Int48 # zeroBits :: Int48 # bit :: Int -> Int48 # setBit :: Int48 -> Int -> Int48 # clearBit :: Int48 -> Int -> Int48 # complementBit :: Int48 -> Int -> Int48 # testBit :: Int48 -> Int -> Bool # bitSizeMaybe :: Int48 -> Maybe Int # bitSize :: Int48 -> Int # isSigned :: Int48 -> Bool # shiftL :: Int48 -> Int -> Int48 # unsafeShiftL :: Int48 -> Int -> Int48 # shiftR :: Int48 -> Int -> Int48 # unsafeShiftR :: Int48 -> Int -> Int48 # rotateL :: Int48 -> Int -> Int48 # rotateR :: Int48 -> Int -> Int48 # popCount :: Int48 -> Int #
FiniteBits Int48 Source #
Methods finiteBitSize :: Int48 -> Int # countLeadingZeros :: Int48 -> Int # countTrailingZeros :: Int48 -> Int #
BinaryWord Int48 Source #
Associated Types type UnsignedWord Int48 :: * # type SignedWord Int48 :: * # Methods unsignedWord :: Int48 -> UnsignedWord Int48 # signedWord :: Int48 -> SignedWord Int48 # unwrappedAdd :: Int48 -> Int48 -> (Int48, UnsignedWord Int48) # unwrappedMul :: Int48 -> Int48 -> (Int48, UnsignedWord Int48) # leadingZeroes :: Int48 -> Int # trailingZeroes :: Int48 -> Int # allZeroes :: Int48 # allOnes :: Int48 # msb :: Int48 # lsb :: Int48 # testMsb :: Int48 -> Bool # testLsb :: Int48 -> Bool # setMsb :: Int48 -> Int48 # setLsb :: Int48 -> Int48 # clearMsb :: Int48 -> Int48 # clearLsb :: Int48 -> Int48 #
Hashable Int48 Source #
Methods hashWithSalt :: Int -> Int48 -> Int # hash :: Int48 -> Int #
type SignedWord Int48 Source #
type SignedWord Int48 = Int48
type UnsignedWord Int48 Source #
type UnsignedWord Int48 = Word48