Documentation

Methods

negate :: CChar -> CChar #

Integral CChar

Instance details

Methods

fromInteger :: Integer -> CChar #

NormalForm CChar

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CChar -> () #

Additive CChar

Instance details

Methods

azero :: CChar #

(+) :: CChar -> CChar -> CChar #

scale :: IsNatural n => n -> CChar -> CChar #

IDivisible CChar

Instance details

Methods

div :: CChar -> CChar -> CChar #

mod :: CChar -> CChar -> CChar #

divMod :: CChar -> CChar -> (CChar, CChar) #

Multiplicative CChar

Instance details

Methods

midentity :: CChar #

(*) :: CChar -> CChar -> CChar #

(^) :: (IsNatural n, Enum n, IDivisible n) => CChar -> n -> CChar #

IsIntegral CChar

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CChar -> Integer #

Subtractive CChar

Instance details

Associated Types

type Difference CChar
Instance details Defined in Basement.Numerical.Subtractive type Difference CChar = CChar

Methods

(-) :: CChar -> CChar -> Difference CChar #

PrimMemoryComparable CChar

Instance details

Defined in Basement.PrimType

PrimType CChar

Instance details

Defined in Basement.PrimType

Associated Types

type PrimSize CChar
Instance details Defined in Basement.PrimType type PrimSize CChar = 1

Methods

primSizeInBytes :: Proxy CChar -> CountOf Word8 #

primShiftToBytes :: Proxy CChar -> Int #

primBaUIndex :: ByteArray# -> Offset CChar -> CChar #

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> prim CChar #

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CChar -> CChar -> prim () #

primAddrIndex :: Addr# -> Offset CChar -> CChar #

primAddrRead :: PrimMonad prim => Addr# -> Offset CChar -> prim CChar #

primAddrWrite :: PrimMonad prim => Addr# -> Offset CChar -> CChar -> prim () #

Storable CChar Source #

Instance details

Defined in Foundation.Class.Storable

Methods

peek :: Ptr CChar -> IO CChar Source #

poke :: Ptr CChar -> CChar -> IO () Source #

StorableFixed CChar Source #

Instance details

Defined in Foundation.Class.Storable

Methods

size :: proxy CChar -> CountOf Word8 Source #

alignment :: proxy CChar -> CountOf Word8 Source #

Bits CChar

Instance details

Methods

(.&.) :: CChar -> CChar -> CChar #

(.|.) :: CChar -> CChar -> CChar #

xor :: CChar -> CChar -> CChar #

complement :: CChar -> CChar #

shift :: CChar -> Int -> CChar #

rotate :: CChar -> Int -> CChar #

zeroBits :: CChar #

bit :: Int -> CChar #

setBit :: CChar -> Int -> CChar #

clearBit :: CChar -> Int -> CChar #

complementBit :: CChar -> Int -> CChar #

testBit :: CChar -> Int -> Bool #

bitSizeMaybe :: CChar -> Maybe Int #

bitSize :: CChar -> Int #

isSigned :: CChar -> Bool #

shiftL :: CChar -> Int -> CChar #

unsafeShiftL :: CChar -> Int -> CChar #

shiftR :: CChar -> Int -> CChar #

unsafeShiftR :: CChar -> Int -> CChar #

rotateL :: CChar -> Int -> CChar #

rotateR :: CChar -> Int -> CChar #

popCount :: CChar -> Int #

FiniteBits CChar

Instance details

Methods

finiteBitSize :: CChar -> Int

countLeadingZeros :: CChar -> Int

countTrailingZeros :: CChar -> Int

Bounded CChar

Instance details

Methods

minBound :: CChar #

maxBound :: CChar #

Enum CChar

Instance details

Methods

succ :: CChar -> CChar #

pred :: CChar -> CChar #

toEnum :: Int -> CChar #

fromEnum :: CChar -> Int #

enumFrom :: CChar -> [CChar] #

enumFromThen :: CChar -> CChar -> [CChar] #

enumFromTo :: CChar -> CChar -> [CChar] #

enumFromThenTo :: CChar -> CChar -> CChar -> [CChar] #

Storable CChar

Instance details

Methods

sizeOf :: CChar -> Int

alignment :: CChar -> Int

peekElemOff :: Ptr CChar -> Int -> IO CChar

pokeElemOff :: Ptr CChar -> Int -> CChar -> IO ()

peekByteOff :: Ptr b -> Int -> IO CChar

pokeByteOff :: Ptr b -> Int -> CChar -> IO ()

peek :: Ptr CChar -> IO CChar

poke :: Ptr CChar -> CChar -> IO ()

Ix CChar

Instance details

Methods

range :: (CChar, CChar) -> [CChar]

index :: (CChar, CChar) -> CChar -> Int

unsafeIndex :: (CChar, CChar) -> CChar -> Int

inRange :: (CChar, CChar) -> CChar -> Bool

rangeSize :: (CChar, CChar) -> Int

unsafeRangeSize :: (CChar, CChar) -> Int

Num CChar

Instance details

Methods

(+) :: CChar -> CChar -> CChar

(-) :: CChar -> CChar -> CChar

(*) :: CChar -> CChar -> CChar

negate :: CChar -> CChar

abs :: CChar -> CChar

signum :: CChar -> CChar

fromInteger :: Integer -> CChar

Read CChar

Instance details

Methods

readsPrec :: Int -> ReadS CChar

readList :: ReadS [CChar]

readPrec :: ReadPrec CChar

readListPrec :: ReadPrec [CChar]

Integral CChar

Instance details

Methods

quot :: CChar -> CChar -> CChar

rem :: CChar -> CChar -> CChar

div :: CChar -> CChar -> CChar

mod :: CChar -> CChar -> CChar

quotRem :: CChar -> CChar -> (CChar, CChar)

divMod :: CChar -> CChar -> (CChar, CChar)

toInteger :: CChar -> Integer

Real CChar

Instance details

Methods

toRational :: CChar -> Rational

Show CChar

Instance details

Methods

showsPrec :: Int -> CChar -> ShowS

show :: CChar -> String

showList :: [CChar] -> ShowS

Eq CChar

Instance details

Methods

(==) :: CChar -> CChar -> Bool #

(/=) :: CChar -> CChar -> Bool #

Ord CChar

Instance details

Methods

compare :: CChar -> CChar -> Ordering #

(<) :: CChar -> CChar -> Bool #

(<=) :: CChar -> CChar -> Bool #

(>) :: CChar -> CChar -> Bool #

(>=) :: CChar -> CChar -> Bool #

max :: CChar -> CChar -> CChar #

min :: CChar -> CChar -> CChar #

type Difference CChar

Instance details

type Difference CChar = CChar

type PrimSize CChar

Instance details

Defined in Basement.PrimType

type PrimSize CChar = 1

newtype CUChar #

Constructors

CUChar Word8

Instances

Instances details

Integral CUChar

Instance details

Methods

fromInteger :: Integer -> CUChar #

NormalForm CUChar

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CUChar -> () #

Additive CUChar

Instance details

Methods

azero :: CUChar #

(+) :: CUChar -> CUChar -> CUChar #

scale :: IsNatural n => n -> CUChar -> CUChar #

IDivisible CUChar

Instance details

Methods

div :: CUChar -> CUChar -> CUChar #

mod :: CUChar -> CUChar -> CUChar #

divMod :: CUChar -> CUChar -> (CUChar, CUChar) #

Multiplicative CUChar

Instance details

Methods

midentity :: CUChar #

(*) :: CUChar -> CUChar -> CUChar #

(^) :: (IsNatural n, Enum n, IDivisible n) => CUChar -> n -> CUChar #

IsIntegral CUChar

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CUChar -> Integer #

IsNatural CUChar

Instance details

Defined in Basement.Numerical.Number

Methods

toNatural :: CUChar -> Natural #

Subtractive CUChar

Instance details

Associated Types

type Difference CUChar
Instance details Defined in Basement.Numerical.Subtractive type Difference CUChar = CUChar

Methods

(-) :: CUChar -> CUChar -> Difference CUChar #

PrimMemoryComparable CUChar

Instance details

Defined in Basement.PrimType

PrimType CUChar

Instance details

Defined in Basement.PrimType

Associated Types

type PrimSize CUChar
Instance details Defined in Basement.PrimType type PrimSize CUChar = 1

Methods

primSizeInBytes :: Proxy CUChar -> CountOf Word8 #

primShiftToBytes :: Proxy CUChar -> Int #

primBaUIndex :: ByteArray# -> Offset CUChar -> CUChar #

primMbaURead :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> prim CUChar #

primMbaUWrite :: PrimMonad prim => MutableByteArray# (PrimState prim) -> Offset CUChar -> CUChar -> prim () #

primAddrIndex :: Addr# -> Offset CUChar -> CUChar #

primAddrRead :: PrimMonad prim => Addr# -> Offset CUChar -> prim CUChar #

primAddrWrite :: PrimMonad prim => Addr# -> Offset CUChar -> CUChar -> prim () #

Storable CUChar Source #

Instance details

Defined in Foundation.Class.Storable

Methods

peek :: Ptr CUChar -> IO CUChar Source #

poke :: Ptr CUChar -> CUChar -> IO () Source #

StorableFixed CUChar Source #

Instance details

Defined in Foundation.Class.Storable

Methods

size :: proxy CUChar -> CountOf Word8 Source #

alignment :: proxy CUChar -> CountOf Word8 Source #

Bits CUChar

Instance details

Methods

(.&.) :: CUChar -> CUChar -> CUChar #

(.|.) :: CUChar -> CUChar -> CUChar #

xor :: CUChar -> CUChar -> CUChar #

complement :: CUChar -> CUChar #

shift :: CUChar -> Int -> CUChar #

rotate :: CUChar -> Int -> CUChar #

zeroBits :: CUChar #

bit :: Int -> CUChar #

setBit :: CUChar -> Int -> CUChar #

clearBit :: CUChar -> Int -> CUChar #

complementBit :: CUChar -> Int -> CUChar #

testBit :: CUChar -> Int -> Bool #

bitSizeMaybe :: CUChar -> Maybe Int #

bitSize :: CUChar -> Int #

isSigned :: CUChar -> Bool #

shiftL :: CUChar -> Int -> CUChar #

unsafeShiftL :: CUChar -> Int -> CUChar #

shiftR :: CUChar -> Int -> CUChar #

unsafeShiftR :: CUChar -> Int -> CUChar #

rotateL :: CUChar -> Int -> CUChar #

rotateR :: CUChar -> Int -> CUChar #

popCount :: CUChar -> Int #

FiniteBits CUChar

Instance details

Methods

finiteBitSize :: CUChar -> Int

countLeadingZeros :: CUChar -> Int

countTrailingZeros :: CUChar -> Int

Bounded CUChar

Instance details

Methods

minBound :: CUChar #

maxBound :: CUChar #

Enum CUChar

Instance details

Methods

succ :: CUChar -> CUChar #

pred :: CUChar -> CUChar #

toEnum :: Int -> CUChar #

fromEnum :: CUChar -> Int #

enumFrom :: CUChar -> [CUChar] #

enumFromThen :: CUChar -> CUChar -> [CUChar] #

enumFromTo :: CUChar -> CUChar -> [CUChar] #

enumFromThenTo :: CUChar -> CUChar -> CUChar -> [CUChar] #

Storable CUChar

Instance details

Methods

sizeOf :: CUChar -> Int

alignment :: CUChar -> Int

peekElemOff :: Ptr CUChar -> Int -> IO CUChar

pokeElemOff :: Ptr CUChar -> Int -> CUChar -> IO ()

peekByteOff :: Ptr b -> Int -> IO CUChar

pokeByteOff :: Ptr b -> Int -> CUChar -> IO ()

peek :: Ptr CUChar -> IO CUChar

poke :: Ptr CUChar -> CUChar -> IO ()

Ix CUChar

Instance details

Methods

range :: (CUChar, CUChar) -> [CUChar]

index :: (CUChar, CUChar) -> CUChar -> Int

unsafeIndex :: (CUChar, CUChar) -> CUChar -> Int

inRange :: (CUChar, CUChar) -> CUChar -> Bool

rangeSize :: (CUChar, CUChar) -> Int

unsafeRangeSize :: (CUChar, CUChar) -> Int

Num CUChar

Instance details

Methods

(+) :: CUChar -> CUChar -> CUChar

(-) :: CUChar -> CUChar -> CUChar

(*) :: CUChar -> CUChar -> CUChar

negate :: CUChar -> CUChar

abs :: CUChar -> CUChar

signum :: CUChar -> CUChar

fromInteger :: Integer -> CUChar

Read CUChar

Instance details

Methods

readsPrec :: Int -> ReadS CUChar

readList :: ReadS [CUChar]

readPrec :: ReadPrec CUChar

readListPrec :: ReadPrec [CUChar]

Integral CUChar

Instance details

Methods

quot :: CUChar -> CUChar -> CUChar

rem :: CUChar -> CUChar -> CUChar

div :: CUChar -> CUChar -> CUChar

mod :: CUChar -> CUChar -> CUChar

quotRem :: CUChar -> CUChar -> (CUChar, CUChar)

divMod :: CUChar -> CUChar -> (CUChar, CUChar)

toInteger :: CUChar -> Integer

Real CUChar

Instance details

Methods

toRational :: CUChar -> Rational

Show CUChar

Instance details

Methods

showsPrec :: Int -> CUChar -> ShowS

show :: CUChar -> String

showList :: [CUChar] -> ShowS

Eq CUChar

Instance details

Methods

(==) :: CUChar -> CUChar -> Bool #

(/=) :: CUChar -> CUChar -> Bool #

Ord CUChar

Instance details

Methods

compare :: CUChar -> CUChar -> Ordering #

(<) :: CUChar -> CUChar -> Bool #

(<=) :: CUChar -> CUChar -> Bool #

(>) :: CUChar -> CUChar -> Bool #

(>=) :: CUChar -> CUChar -> Bool #

max :: CUChar -> CUChar -> CUChar #

min :: CUChar -> CUChar -> CUChar #

type Difference CUChar

Instance details

type Difference CUChar = CUChar

type PrimSize CUChar

Instance details

Defined in Basement.PrimType

type PrimSize CUChar = 1

newtype COff #

Constructors

COff Int64

Instances

Instances details

Integral COff

Instance details

Methods

fromInteger :: Integer -> COff #

Additive COff

Instance details

Methods

azero :: COff #

(+) :: COff -> COff -> COff #

scale :: IsNatural n => n -> COff -> COff #

Multiplicative COff

Instance details

Methods

midentity :: COff #

(*) :: COff -> COff -> COff #

(^) :: (IsNatural n, Enum n, IDivisible n) => COff -> n -> COff #

Subtractive COff

Instance details

Associated Types

type Difference COff
Instance details Defined in Basement.Numerical.Subtractive type Difference COff = COff

Methods

(-) :: COff -> COff -> Difference COff #

Bits COff

Instance details

Methods

(.&.) :: COff -> COff -> COff #

(.|.) :: COff -> COff -> COff #

xor :: COff -> COff -> COff #

complement :: COff -> COff #

shift :: COff -> Int -> COff #

rotate :: COff -> Int -> COff #

zeroBits :: COff #

bit :: Int -> COff #

setBit :: COff -> Int -> COff #

clearBit :: COff -> Int -> COff #

complementBit :: COff -> Int -> COff #

testBit :: COff -> Int -> Bool #

bitSizeMaybe :: COff -> Maybe Int #

bitSize :: COff -> Int #

isSigned :: COff -> Bool #

shiftL :: COff -> Int -> COff #

unsafeShiftL :: COff -> Int -> COff #

shiftR :: COff -> Int -> COff #

unsafeShiftR :: COff -> Int -> COff #

rotateL :: COff -> Int -> COff #

rotateR :: COff -> Int -> COff #

popCount :: COff -> Int #

FiniteBits COff

Instance details

Methods

finiteBitSize :: COff -> Int

countLeadingZeros :: COff -> Int

countTrailingZeros :: COff -> Int

Bounded COff

Instance details

Methods

minBound :: COff #

maxBound :: COff #

Enum COff

Instance details

Methods

succ :: COff -> COff #

pred :: COff -> COff #

toEnum :: Int -> COff #

fromEnum :: COff -> Int #

enumFrom :: COff -> [COff] #

enumFromThen :: COff -> COff -> [COff] #

enumFromTo :: COff -> COff -> [COff] #

enumFromThenTo :: COff -> COff -> COff -> [COff] #

Storable COff

Instance details

Methods

sizeOf :: COff -> Int

alignment :: COff -> Int

peekElemOff :: Ptr COff -> Int -> IO COff

pokeElemOff :: Ptr COff -> Int -> COff -> IO ()

peekByteOff :: Ptr b -> Int -> IO COff

pokeByteOff :: Ptr b -> Int -> COff -> IO ()

peek :: Ptr COff -> IO COff

poke :: Ptr COff -> COff -> IO ()

Ix COff

Instance details

Methods

range :: (COff, COff) -> [COff]

index :: (COff, COff) -> COff -> Int

unsafeIndex :: (COff, COff) -> COff -> Int

inRange :: (COff, COff) -> COff -> Bool

rangeSize :: (COff, COff) -> Int

unsafeRangeSize :: (COff, COff) -> Int

Num COff

Instance details

Methods

(+) :: COff -> COff -> COff

(-) :: COff -> COff -> COff

(*) :: COff -> COff -> COff

negate :: COff -> COff

abs :: COff -> COff

signum :: COff -> COff

fromInteger :: Integer -> COff

Read COff

Instance details

Methods

readsPrec :: Int -> ReadS COff

readList :: ReadS [COff]

readPrec :: ReadPrec COff

readListPrec :: ReadPrec [COff]

Integral COff

Instance details

Methods

quot :: COff -> COff -> COff

rem :: COff -> COff -> COff

div :: COff -> COff -> COff

mod :: COff -> COff -> COff

quotRem :: COff -> COff -> (COff, COff)

divMod :: COff -> COff -> (COff, COff)

toInteger :: COff -> Integer

Real COff

Instance details

Methods

toRational :: COff -> Rational

Show COff

Instance details

Methods

showsPrec :: Int -> COff -> ShowS

show :: COff -> String

showList :: [COff] -> ShowS

Eq COff

Instance details

Methods

(==) :: COff -> COff -> Bool #

(/=) :: COff -> COff -> Bool #

Ord COff

Instance details

Methods

compare :: COff -> COff -> Ordering #

(<) :: COff -> COff -> Bool #

(<=) :: COff -> COff -> Bool #

(>) :: COff -> COff -> Bool #

(>=) :: COff -> COff -> Bool #

max :: COff -> COff -> COff #

min :: COff -> COff -> COff #

type Difference COff

Instance details

type Difference COff = COff

newtype CMode #

Constructors

CMode Word32

Instances

Instances details

Bits CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods (.&.) :: CMode -> CMode -> CMode # (.\|.) :: CMode -> CMode -> CMode # xor :: CMode -> CMode -> CMode # complement :: CMode -> CMode # shift :: CMode -> Int -> CMode # rotate :: CMode -> Int -> CMode # zeroBits :: CMode # bit :: Int -> CMode # setBit :: CMode -> Int -> CMode # clearBit :: CMode -> Int -> CMode # complementBit :: CMode -> Int -> CMode # testBit :: CMode -> Int -> Bool # bitSizeMaybe :: CMode -> Maybe Int # bitSize :: CMode -> Int # isSigned :: CMode -> Bool # shiftL :: CMode -> Int -> CMode # unsafeShiftL :: CMode -> Int -> CMode # shiftR :: CMode -> Int -> CMode # unsafeShiftR :: CMode -> Int -> CMode # rotateL :: CMode -> Int -> CMode # rotateR :: CMode -> Int -> CMode # popCount :: CMode -> Int #
FiniteBits CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods finiteBitSize :: CMode -> Int countLeadingZeros :: CMode -> Int countTrailingZeros :: CMode -> Int
Bounded CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods minBound :: CMode # maxBound :: CMode #
Enum CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods succ :: CMode -> CMode # pred :: CMode -> CMode # toEnum :: Int -> CMode # fromEnum :: CMode -> Int # enumFrom :: CMode -> [CMode] # enumFromThen :: CMode -> CMode -> [CMode] # enumFromTo :: CMode -> CMode -> [CMode] # enumFromThenTo :: CMode -> CMode -> CMode -> [CMode] #
Storable CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods sizeOf :: CMode -> Int alignment :: CMode -> Int peekElemOff :: Ptr CMode -> Int -> IO CMode pokeElemOff :: Ptr CMode -> Int -> CMode -> IO () peekByteOff :: Ptr b -> Int -> IO CMode pokeByteOff :: Ptr b -> Int -> CMode -> IO () peek :: Ptr CMode -> IO CMode poke :: Ptr CMode -> CMode -> IO ()
Ix CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods range :: (CMode, CMode) -> [CMode] index :: (CMode, CMode) -> CMode -> Int unsafeIndex :: (CMode, CMode) -> CMode -> Int inRange :: (CMode, CMode) -> CMode -> Bool rangeSize :: (CMode, CMode) -> Int unsafeRangeSize :: (CMode, CMode) -> Int
Num CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods (+) :: CMode -> CMode -> CMode (-) :: CMode -> CMode -> CMode (*) :: CMode -> CMode -> CMode negate :: CMode -> CMode abs :: CMode -> CMode signum :: CMode -> CMode fromInteger :: Integer -> CMode
Read CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods readsPrec :: Int -> ReadS CMode readList :: ReadS [CMode] readPrec :: ReadPrec CMode readListPrec :: ReadPrec [CMode]
Integral CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods quot :: CMode -> CMode -> CMode rem :: CMode -> CMode -> CMode div :: CMode -> CMode -> CMode mod :: CMode -> CMode -> CMode quotRem :: CMode -> CMode -> (CMode, CMode) divMod :: CMode -> CMode -> (CMode, CMode) toInteger :: CMode -> Integer
Real CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods toRational :: CMode -> Rational
Show CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods showsPrec :: Int -> CMode -> ShowS show :: CMode -> String showList :: [CMode] -> ShowS
Eq CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods (==) :: CMode -> CMode -> Bool # (/=) :: CMode -> CMode -> Bool #
Ord CMode
Instance details Defined in GHC.Internal.System.Posix.Types Methods compare :: CMode -> CMode -> Ordering # (<) :: CMode -> CMode -> Bool # (<=) :: CMode -> CMode -> Bool # (>) :: CMode -> CMode -> Bool # (>=) :: CMode -> CMode -> Bool # max :: CMode -> CMode -> CMode # min :: CMode -> CMode -> CMode #

newtype CInt #

Constructors

CInt Int32

Instances

Instances details

HasNegation CInt

Instance details

Methods

negate :: CInt -> CInt #

Integral CInt

Instance details

Methods

fromInteger :: Integer -> CInt #

NormalForm CInt

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CInt -> () #

Additive CInt

Instance details

Methods

azero :: CInt #

(+) :: CInt -> CInt -> CInt #

scale :: IsNatural n => n -> CInt -> CInt #

IDivisible CInt

Instance details

Methods

div :: CInt -> CInt -> CInt #

mod :: CInt -> CInt -> CInt #

divMod :: CInt -> CInt -> (CInt, CInt) #

Multiplicative CInt

Instance details

Methods

midentity :: CInt #

(*) :: CInt -> CInt -> CInt #

(^) :: (IsNatural n, Enum n, IDivisible n) => CInt -> n -> CInt #

IsIntegral CInt

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CInt -> Integer #

Subtractive CInt

Instance details

Associated Types

type Difference CInt
Instance details Defined in Basement.Numerical.Subtractive type Difference CInt = CInt

Methods

(-) :: CInt -> CInt -> Difference CInt #

Bits CInt

Instance details

Methods

(.&.) :: CInt -> CInt -> CInt #

(.|.) :: CInt -> CInt -> CInt #

xor :: CInt -> CInt -> CInt #

complement :: CInt -> CInt #

shift :: CInt -> Int -> CInt #

rotate :: CInt -> Int -> CInt #

zeroBits :: CInt #

bit :: Int -> CInt #

setBit :: CInt -> Int -> CInt #

clearBit :: CInt -> Int -> CInt #

complementBit :: CInt -> Int -> CInt #

testBit :: CInt -> Int -> Bool #

bitSizeMaybe :: CInt -> Maybe Int #

bitSize :: CInt -> Int #

isSigned :: CInt -> Bool #

shiftL :: CInt -> Int -> CInt #

unsafeShiftL :: CInt -> Int -> CInt #

shiftR :: CInt -> Int -> CInt #

unsafeShiftR :: CInt -> Int -> CInt #

rotateL :: CInt -> Int -> CInt #

rotateR :: CInt -> Int -> CInt #

popCount :: CInt -> Int #

FiniteBits CInt

Instance details

Methods

finiteBitSize :: CInt -> Int

countLeadingZeros :: CInt -> Int

countTrailingZeros :: CInt -> Int

Bounded CInt

Instance details

Methods

minBound :: CInt #

maxBound :: CInt #

Enum CInt

Instance details

Methods

succ :: CInt -> CInt #

pred :: CInt -> CInt #

toEnum :: Int -> CInt #

fromEnum :: CInt -> Int #

enumFrom :: CInt -> [CInt] #

enumFromThen :: CInt -> CInt -> [CInt] #

enumFromTo :: CInt -> CInt -> [CInt] #

enumFromThenTo :: CInt -> CInt -> CInt -> [CInt] #

Storable CInt

Instance details

Methods

sizeOf :: CInt -> Int

alignment :: CInt -> Int

peekElemOff :: Ptr CInt -> Int -> IO CInt

pokeElemOff :: Ptr CInt -> Int -> CInt -> IO ()

peekByteOff :: Ptr b -> Int -> IO CInt

pokeByteOff :: Ptr b -> Int -> CInt -> IO ()

peek :: Ptr CInt -> IO CInt

poke :: Ptr CInt -> CInt -> IO ()

Ix CInt

Instance details

Methods

range :: (CInt, CInt) -> [CInt]

index :: (CInt, CInt) -> CInt -> Int

unsafeIndex :: (CInt, CInt) -> CInt -> Int

inRange :: (CInt, CInt) -> CInt -> Bool

rangeSize :: (CInt, CInt) -> Int

unsafeRangeSize :: (CInt, CInt) -> Int

Num CInt

Instance details

Methods

(+) :: CInt -> CInt -> CInt

(-) :: CInt -> CInt -> CInt

(*) :: CInt -> CInt -> CInt

negate :: CInt -> CInt

abs :: CInt -> CInt

signum :: CInt -> CInt

fromInteger :: Integer -> CInt

Read CInt

Instance details

Methods

readsPrec :: Int -> ReadS CInt

readList :: ReadS [CInt]

readPrec :: ReadPrec CInt

readListPrec :: ReadPrec [CInt]

Integral CInt

Instance details

Methods

quot :: CInt -> CInt -> CInt

rem :: CInt -> CInt -> CInt

div :: CInt -> CInt -> CInt

mod :: CInt -> CInt -> CInt

quotRem :: CInt -> CInt -> (CInt, CInt)

divMod :: CInt -> CInt -> (CInt, CInt)

toInteger :: CInt -> Integer

Real CInt

Instance details

Methods

toRational :: CInt -> Rational

Show CInt

Instance details

Methods

showsPrec :: Int -> CInt -> ShowS

show :: CInt -> String

showList :: [CInt] -> ShowS

Eq CInt

Instance details

Methods

(==) :: CInt -> CInt -> Bool #

(/=) :: CInt -> CInt -> Bool #

Ord CInt

Instance details

Methods

compare :: CInt -> CInt -> Ordering #

(<) :: CInt -> CInt -> Bool #

(<=) :: CInt -> CInt -> Bool #

(>) :: CInt -> CInt -> Bool #

(>=) :: CInt -> CInt -> Bool #

max :: CInt -> CInt -> CInt #

min :: CInt -> CInt -> CInt #

type Difference CInt

Instance details

type Difference CInt = CInt

newtype CSize #

Constructors

CSize Word32

Instances

Instances details

Integral CSize

Instance details

Methods

fromInteger :: Integer -> CSize #

Additive CSize

Instance details

Methods

azero :: CSize #

(+) :: CSize -> CSize -> CSize #

scale :: IsNatural n => n -> CSize -> CSize #

IDivisible CSize

Instance details

Methods

div :: CSize -> CSize -> CSize #

mod :: CSize -> CSize -> CSize #

divMod :: CSize -> CSize -> (CSize, CSize) #

Multiplicative CSize

Instance details

Methods

midentity :: CSize #

(*) :: CSize -> CSize -> CSize #

(^) :: (IsNatural n, Enum n, IDivisible n) => CSize -> n -> CSize #

IsIntegral CSize

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CSize -> Integer #

IsNatural CSize

Instance details

Defined in Basement.Numerical.Number

Methods

toNatural :: CSize -> Natural #

Subtractive CSize

Instance details

Associated Types

type Difference CSize
Instance details Defined in Basement.Numerical.Subtractive type Difference CSize = CSize

Methods

(-) :: CSize -> CSize -> Difference CSize #

Bits CSize

Instance details

Methods

(.&.) :: CSize -> CSize -> CSize #

(.|.) :: CSize -> CSize -> CSize #

xor :: CSize -> CSize -> CSize #

complement :: CSize -> CSize #

shift :: CSize -> Int -> CSize #

rotate :: CSize -> Int -> CSize #

zeroBits :: CSize #

bit :: Int -> CSize #

setBit :: CSize -> Int -> CSize #

clearBit :: CSize -> Int -> CSize #

complementBit :: CSize -> Int -> CSize #

testBit :: CSize -> Int -> Bool #

bitSizeMaybe :: CSize -> Maybe Int #

bitSize :: CSize -> Int #

isSigned :: CSize -> Bool #

shiftL :: CSize -> Int -> CSize #

unsafeShiftL :: CSize -> Int -> CSize #

shiftR :: CSize -> Int -> CSize #

unsafeShiftR :: CSize -> Int -> CSize #

rotateL :: CSize -> Int -> CSize #

rotateR :: CSize -> Int -> CSize #

popCount :: CSize -> Int #

FiniteBits CSize

Instance details

Methods

finiteBitSize :: CSize -> Int

countLeadingZeros :: CSize -> Int

countTrailingZeros :: CSize -> Int

Bounded CSize

Instance details

Methods

minBound :: CSize #

maxBound :: CSize #

Enum CSize

Instance details

Methods

succ :: CSize -> CSize #

pred :: CSize -> CSize #

toEnum :: Int -> CSize #

fromEnum :: CSize -> Int #

enumFrom :: CSize -> [CSize] #

enumFromThen :: CSize -> CSize -> [CSize] #

enumFromTo :: CSize -> CSize -> [CSize] #

enumFromThenTo :: CSize -> CSize -> CSize -> [CSize] #

Storable CSize

Instance details

Methods

sizeOf :: CSize -> Int

alignment :: CSize -> Int

peekElemOff :: Ptr CSize -> Int -> IO CSize

pokeElemOff :: Ptr CSize -> Int -> CSize -> IO ()

peekByteOff :: Ptr b -> Int -> IO CSize

pokeByteOff :: Ptr b -> Int -> CSize -> IO ()

peek :: Ptr CSize -> IO CSize

poke :: Ptr CSize -> CSize -> IO ()

Ix CSize

Instance details

Methods

range :: (CSize, CSize) -> [CSize]

index :: (CSize, CSize) -> CSize -> Int

unsafeIndex :: (CSize, CSize) -> CSize -> Int

inRange :: (CSize, CSize) -> CSize -> Bool

rangeSize :: (CSize, CSize) -> Int

unsafeRangeSize :: (CSize, CSize) -> Int

Num CSize

Instance details

Methods

(+) :: CSize -> CSize -> CSize

(-) :: CSize -> CSize -> CSize

(*) :: CSize -> CSize -> CSize

negate :: CSize -> CSize

abs :: CSize -> CSize

signum :: CSize -> CSize

fromInteger :: Integer -> CSize

Read CSize

Instance details

Methods

readsPrec :: Int -> ReadS CSize

readList :: ReadS [CSize]

readPrec :: ReadPrec CSize

readListPrec :: ReadPrec [CSize]

Integral CSize

Instance details

Methods

quot :: CSize -> CSize -> CSize

rem :: CSize -> CSize -> CSize

div :: CSize -> CSize -> CSize

mod :: CSize -> CSize -> CSize

quotRem :: CSize -> CSize -> (CSize, CSize)

divMod :: CSize -> CSize -> (CSize, CSize)

toInteger :: CSize -> Integer

Real CSize

Instance details

Methods

toRational :: CSize -> Rational

Show CSize

Instance details

Methods

showsPrec :: Int -> CSize -> ShowS

show :: CSize -> String

showList :: [CSize] -> ShowS

Eq CSize

Instance details

Methods

(==) :: CSize -> CSize -> Bool #

(/=) :: CSize -> CSize -> Bool #

Ord CSize

Instance details

Methods

compare :: CSize -> CSize -> Ordering #

(<) :: CSize -> CSize -> Bool #

(<=) :: CSize -> CSize -> Bool #

(>) :: CSize -> CSize -> Bool #

(>=) :: CSize -> CSize -> Bool #

max :: CSize -> CSize -> CSize #

min :: CSize -> CSize -> CSize #

type Difference CSize

Instance details

type Difference CSize = CSize

newtype CBool #

Constructors

CBool Word8

Instances

Instances details

Integral CBool

Instance details

Methods

fromInteger :: Integer -> CBool #

IsIntegral CBool

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CBool -> Integer #

Subtractive CBool

Instance details

Associated Types

type Difference CBool
Instance details Defined in Basement.Numerical.Subtractive type Difference CBool = CBool

Methods

(-) :: CBool -> CBool -> Difference CBool #

Bits CBool

Instance details

Methods

(.&.) :: CBool -> CBool -> CBool #

(.|.) :: CBool -> CBool -> CBool #

xor :: CBool -> CBool -> CBool #

complement :: CBool -> CBool #

shift :: CBool -> Int -> CBool #

rotate :: CBool -> Int -> CBool #

zeroBits :: CBool #

bit :: Int -> CBool #

setBit :: CBool -> Int -> CBool #

clearBit :: CBool -> Int -> CBool #

complementBit :: CBool -> Int -> CBool #

testBit :: CBool -> Int -> Bool #

bitSizeMaybe :: CBool -> Maybe Int #

bitSize :: CBool -> Int #

isSigned :: CBool -> Bool #

shiftL :: CBool -> Int -> CBool #

unsafeShiftL :: CBool -> Int -> CBool #

shiftR :: CBool -> Int -> CBool #

unsafeShiftR :: CBool -> Int -> CBool #

rotateL :: CBool -> Int -> CBool #

rotateR :: CBool -> Int -> CBool #

popCount :: CBool -> Int #

FiniteBits CBool

Instance details

Methods

finiteBitSize :: CBool -> Int

countLeadingZeros :: CBool -> Int

countTrailingZeros :: CBool -> Int

Bounded CBool

Instance details

Methods

minBound :: CBool #

maxBound :: CBool #

Enum CBool

Instance details

Methods

succ :: CBool -> CBool #

pred :: CBool -> CBool #

toEnum :: Int -> CBool #

fromEnum :: CBool -> Int #

enumFrom :: CBool -> [CBool] #

enumFromThen :: CBool -> CBool -> [CBool] #

enumFromTo :: CBool -> CBool -> [CBool] #

enumFromThenTo :: CBool -> CBool -> CBool -> [CBool] #

Storable CBool

Instance details

Methods

sizeOf :: CBool -> Int

alignment :: CBool -> Int

peekElemOff :: Ptr CBool -> Int -> IO CBool

pokeElemOff :: Ptr CBool -> Int -> CBool -> IO ()

peekByteOff :: Ptr b -> Int -> IO CBool

pokeByteOff :: Ptr b -> Int -> CBool -> IO ()

peek :: Ptr CBool -> IO CBool

poke :: Ptr CBool -> CBool -> IO ()

Ix CBool

Instance details

Methods

range :: (CBool, CBool) -> [CBool]

index :: (CBool, CBool) -> CBool -> Int

unsafeIndex :: (CBool, CBool) -> CBool -> Int

inRange :: (CBool, CBool) -> CBool -> Bool

rangeSize :: (CBool, CBool) -> Int

unsafeRangeSize :: (CBool, CBool) -> Int

Num CBool

Instance details

Methods

(+) :: CBool -> CBool -> CBool

(-) :: CBool -> CBool -> CBool

(*) :: CBool -> CBool -> CBool

negate :: CBool -> CBool

abs :: CBool -> CBool

signum :: CBool -> CBool

fromInteger :: Integer -> CBool

Read CBool

Instance details

Methods

readsPrec :: Int -> ReadS CBool

readList :: ReadS [CBool]

readPrec :: ReadPrec CBool

readListPrec :: ReadPrec [CBool]

Integral CBool

Instance details

Methods

quot :: CBool -> CBool -> CBool

rem :: CBool -> CBool -> CBool

div :: CBool -> CBool -> CBool

mod :: CBool -> CBool -> CBool

quotRem :: CBool -> CBool -> (CBool, CBool)

divMod :: CBool -> CBool -> (CBool, CBool)

toInteger :: CBool -> Integer

Real CBool

Instance details

Methods

toRational :: CBool -> Rational

Show CBool

Instance details

Methods

showsPrec :: Int -> CBool -> ShowS

show :: CBool -> String

showList :: [CBool] -> ShowS

Eq CBool

Instance details

Methods

(==) :: CBool -> CBool -> Bool #

(/=) :: CBool -> CBool -> Bool #

Ord CBool

Instance details

Methods

compare :: CBool -> CBool -> Ordering #

(<) :: CBool -> CBool -> Bool #

(<=) :: CBool -> CBool -> Bool #

(>) :: CBool -> CBool -> Bool #

(>=) :: CBool -> CBool -> Bool #

max :: CBool -> CBool -> CBool #

min :: CBool -> CBool -> CBool #

type Difference CBool

Instance details

type Difference CBool = CBool

newtype CClock #

Constructors

CClock Int32

Instances

Instances details

Integral CClock

Instance details

Methods

fromInteger :: Integer -> CClock #

Additive CClock

Instance details

Methods

azero :: CClock #

(+) :: CClock -> CClock -> CClock #

scale :: IsNatural n => n -> CClock -> CClock #

Multiplicative CClock

Instance details

Methods

midentity :: CClock #

(*) :: CClock -> CClock -> CClock #

(^) :: (IsNatural n, Enum n, IDivisible n) => CClock -> n -> CClock #

Subtractive CClock

Instance details

Associated Types

type Difference CClock
Instance details Defined in Basement.Numerical.Subtractive type Difference CClock = CClock

Methods

(-) :: CClock -> CClock -> Difference CClock #

Enum CClock

Instance details

Methods

succ :: CClock -> CClock #

pred :: CClock -> CClock #

toEnum :: Int -> CClock #

fromEnum :: CClock -> Int #

enumFrom :: CClock -> [CClock] #

enumFromThen :: CClock -> CClock -> [CClock] #

enumFromTo :: CClock -> CClock -> [CClock] #

enumFromThenTo :: CClock -> CClock -> CClock -> [CClock] #

Storable CClock

Instance details

Methods

sizeOf :: CClock -> Int

alignment :: CClock -> Int

peekElemOff :: Ptr CClock -> Int -> IO CClock

pokeElemOff :: Ptr CClock -> Int -> CClock -> IO ()

peekByteOff :: Ptr b -> Int -> IO CClock

pokeByteOff :: Ptr b -> Int -> CClock -> IO ()

peek :: Ptr CClock -> IO CClock

poke :: Ptr CClock -> CClock -> IO ()

Num CClock

Instance details

Methods

(+) :: CClock -> CClock -> CClock

(-) :: CClock -> CClock -> CClock

(*) :: CClock -> CClock -> CClock

negate :: CClock -> CClock

abs :: CClock -> CClock

signum :: CClock -> CClock

fromInteger :: Integer -> CClock

Read CClock

Instance details

Methods

readsPrec :: Int -> ReadS CClock

readList :: ReadS [CClock]

readPrec :: ReadPrec CClock

readListPrec :: ReadPrec [CClock]

Real CClock

Instance details

Methods

toRational :: CClock -> Rational

Show CClock

Instance details

Methods

showsPrec :: Int -> CClock -> ShowS

show :: CClock -> String

showList :: [CClock] -> ShowS

Eq CClock

Instance details

Methods

(==) :: CClock -> CClock -> Bool #

(/=) :: CClock -> CClock -> Bool #

Ord CClock

Instance details

Methods

compare :: CClock -> CClock -> Ordering #

(<) :: CClock -> CClock -> Bool #

(<=) :: CClock -> CClock -> Bool #

(>) :: CClock -> CClock -> Bool #

(>=) :: CClock -> CClock -> Bool #

max :: CClock -> CClock -> CClock #

min :: CClock -> CClock -> CClock #

type Difference CClock

Instance details

type Difference CClock = CClock

data CDouble #

Instances

Instances details

Fractional CDouble

Instance details

Methods

fromRational :: Rational -> CDouble #

HasNegation CDouble

Instance details

Methods

negate :: CDouble -> CDouble #

Integral CDouble

Instance details

Methods

fromInteger :: Integer -> CDouble #

NormalForm CDouble

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CDouble -> () #

Additive CDouble

Instance details

Methods

azero :: CDouble #

(+) :: CDouble -> CDouble -> CDouble #

scale :: IsNatural n => n -> CDouble -> CDouble #

Divisible CDouble

Instance details

Methods

(/) :: CDouble -> CDouble -> CDouble #

Multiplicative CDouble

Instance details

Methods

midentity :: CDouble #

(*) :: CDouble -> CDouble -> CDouble #

(^) :: (IsNatural n, Enum n, IDivisible n) => CDouble -> n -> CDouble #

Subtractive CDouble

Instance details

Associated Types

type Difference CDouble
Instance details Defined in Basement.Numerical.Subtractive type Difference CDouble = CDouble

Methods

(-) :: CDouble -> CDouble -> Difference CDouble #

Enum CDouble

Instance details

Methods

succ :: CDouble -> CDouble #

pred :: CDouble -> CDouble #

toEnum :: Int -> CDouble #

fromEnum :: CDouble -> Int #

enumFrom :: CDouble -> [CDouble] #

enumFromThen :: CDouble -> CDouble -> [CDouble] #

enumFromTo :: CDouble -> CDouble -> [CDouble] #

enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] #

Floating CDouble

Instance details

Methods

pi :: CDouble

exp :: CDouble -> CDouble

log :: CDouble -> CDouble

sqrt :: CDouble -> CDouble

(**) :: CDouble -> CDouble -> CDouble

logBase :: CDouble -> CDouble -> CDouble

sin :: CDouble -> CDouble

cos :: CDouble -> CDouble

tan :: CDouble -> CDouble

asin :: CDouble -> CDouble

acos :: CDouble -> CDouble

atan :: CDouble -> CDouble

sinh :: CDouble -> CDouble

cosh :: CDouble -> CDouble

tanh :: CDouble -> CDouble

asinh :: CDouble -> CDouble

acosh :: CDouble -> CDouble

atanh :: CDouble -> CDouble

log1p :: CDouble -> CDouble

expm1 :: CDouble -> CDouble

log1pexp :: CDouble -> CDouble

log1mexp :: CDouble -> CDouble

RealFloat CDouble

Instance details

Methods

floatRadix :: CDouble -> Integer

floatDigits :: CDouble -> Int

floatRange :: CDouble -> (Int, Int)

decodeFloat :: CDouble -> (Integer, Int)

encodeFloat :: Integer -> Int -> CDouble

exponent :: CDouble -> Int

significand :: CDouble -> CDouble

scaleFloat :: Int -> CDouble -> CDouble

isNaN :: CDouble -> Bool

isInfinite :: CDouble -> Bool

isDenormalized :: CDouble -> Bool

isNegativeZero :: CDouble -> Bool

isIEEE :: CDouble -> Bool

atan2 :: CDouble -> CDouble -> CDouble

Storable CDouble

Instance details

Methods

sizeOf :: CDouble -> Int

alignment :: CDouble -> Int

peekElemOff :: Ptr CDouble -> Int -> IO CDouble

pokeElemOff :: Ptr CDouble -> Int -> CDouble -> IO ()

peekByteOff :: Ptr b -> Int -> IO CDouble

pokeByteOff :: Ptr b -> Int -> CDouble -> IO ()

peek :: Ptr CDouble -> IO CDouble

poke :: Ptr CDouble -> CDouble -> IO ()

Num CDouble

Instance details

Methods

(+) :: CDouble -> CDouble -> CDouble

(-) :: CDouble -> CDouble -> CDouble

(*) :: CDouble -> CDouble -> CDouble

negate :: CDouble -> CDouble

abs :: CDouble -> CDouble

signum :: CDouble -> CDouble

fromInteger :: Integer -> CDouble

Read CDouble

Instance details

Methods

readsPrec :: Int -> ReadS CDouble

readList :: ReadS [CDouble]

readPrec :: ReadPrec CDouble

readListPrec :: ReadPrec [CDouble]

Fractional CDouble

Instance details

Methods

(/) :: CDouble -> CDouble -> CDouble

recip :: CDouble -> CDouble

fromRational :: Rational -> CDouble

Real CDouble

Instance details

Methods

toRational :: CDouble -> Rational

RealFrac CDouble

Instance details

Methods

properFraction :: Integral b => CDouble -> (b, CDouble)

truncate :: Integral b => CDouble -> b

round :: Integral b => CDouble -> b

ceiling :: Integral b => CDouble -> b

floor :: Integral b => CDouble -> b

Show CDouble

Instance details

Methods

showsPrec :: Int -> CDouble -> ShowS

show :: CDouble -> String

showList :: [CDouble] -> ShowS

Eq CDouble

Instance details

Methods

(==) :: CDouble -> CDouble -> Bool #

(/=) :: CDouble -> CDouble -> Bool #

Ord CDouble

Instance details

Methods

compare :: CDouble -> CDouble -> Ordering #

(<) :: CDouble -> CDouble -> Bool #

(<=) :: CDouble -> CDouble -> Bool #

(>) :: CDouble -> CDouble -> Bool #

(>=) :: CDouble -> CDouble -> Bool #

max :: CDouble -> CDouble -> CDouble #

min :: CDouble -> CDouble -> CDouble #

type Difference CDouble

Instance details

type Difference CDouble = CDouble

newtype CFloat #

Constructors

CFloat Float

Instances

Instances details

Fractional CFloat

Instance details

Methods

fromRational :: Rational -> CFloat #

HasNegation CFloat

Instance details

Methods

negate :: CFloat -> CFloat #

Integral CFloat

Instance details

Methods

fromInteger :: Integer -> CFloat #

NormalForm CFloat

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CFloat -> () #

Additive CFloat

Instance details

Methods

azero :: CFloat #

(+) :: CFloat -> CFloat -> CFloat #

scale :: IsNatural n => n -> CFloat -> CFloat #

Divisible CFloat

Instance details

Methods

(/) :: CFloat -> CFloat -> CFloat #

Multiplicative CFloat

Instance details

Methods

midentity :: CFloat #

(*) :: CFloat -> CFloat -> CFloat #

(^) :: (IsNatural n, Enum n, IDivisible n) => CFloat -> n -> CFloat #

Subtractive CFloat

Instance details

Associated Types

type Difference CFloat
Instance details Defined in Basement.Numerical.Subtractive type Difference CFloat = CFloat

Methods

(-) :: CFloat -> CFloat -> Difference CFloat #

Enum CFloat

Instance details

Methods

succ :: CFloat -> CFloat #

pred :: CFloat -> CFloat #

toEnum :: Int -> CFloat #

fromEnum :: CFloat -> Int #

enumFrom :: CFloat -> [CFloat] #

enumFromThen :: CFloat -> CFloat -> [CFloat] #

enumFromTo :: CFloat -> CFloat -> [CFloat] #

enumFromThenTo :: CFloat -> CFloat -> CFloat -> [CFloat] #

Floating CFloat

Instance details

Methods

pi :: CFloat

exp :: CFloat -> CFloat

log :: CFloat -> CFloat

sqrt :: CFloat -> CFloat

(**) :: CFloat -> CFloat -> CFloat

logBase :: CFloat -> CFloat -> CFloat

sin :: CFloat -> CFloat

cos :: CFloat -> CFloat

tan :: CFloat -> CFloat

asin :: CFloat -> CFloat

acos :: CFloat -> CFloat

atan :: CFloat -> CFloat

sinh :: CFloat -> CFloat

cosh :: CFloat -> CFloat

tanh :: CFloat -> CFloat

asinh :: CFloat -> CFloat

acosh :: CFloat -> CFloat

atanh :: CFloat -> CFloat

log1p :: CFloat -> CFloat

expm1 :: CFloat -> CFloat

log1pexp :: CFloat -> CFloat

log1mexp :: CFloat -> CFloat

RealFloat CFloat

Instance details

Methods

floatRadix :: CFloat -> Integer

floatDigits :: CFloat -> Int

floatRange :: CFloat -> (Int, Int)

decodeFloat :: CFloat -> (Integer, Int)

encodeFloat :: Integer -> Int -> CFloat

exponent :: CFloat -> Int

significand :: CFloat -> CFloat

scaleFloat :: Int -> CFloat -> CFloat

isNaN :: CFloat -> Bool

isInfinite :: CFloat -> Bool

isDenormalized :: CFloat -> Bool

isNegativeZero :: CFloat -> Bool

isIEEE :: CFloat -> Bool

atan2 :: CFloat -> CFloat -> CFloat

Storable CFloat

Instance details

Methods

sizeOf :: CFloat -> Int

alignment :: CFloat -> Int

peekElemOff :: Ptr CFloat -> Int -> IO CFloat

pokeElemOff :: Ptr CFloat -> Int -> CFloat -> IO ()

peekByteOff :: Ptr b -> Int -> IO CFloat

pokeByteOff :: Ptr b -> Int -> CFloat -> IO ()

peek :: Ptr CFloat -> IO CFloat

poke :: Ptr CFloat -> CFloat -> IO ()

Num CFloat

Instance details

Methods

(+) :: CFloat -> CFloat -> CFloat

(-) :: CFloat -> CFloat -> CFloat

(*) :: CFloat -> CFloat -> CFloat

negate :: CFloat -> CFloat

abs :: CFloat -> CFloat

signum :: CFloat -> CFloat

fromInteger :: Integer -> CFloat

Read CFloat

Instance details

Methods

readsPrec :: Int -> ReadS CFloat

readList :: ReadS [CFloat]

readPrec :: ReadPrec CFloat

readListPrec :: ReadPrec [CFloat]

Fractional CFloat

Instance details

Methods

(/) :: CFloat -> CFloat -> CFloat

recip :: CFloat -> CFloat

fromRational :: Rational -> CFloat

Real CFloat

Instance details

Methods

toRational :: CFloat -> Rational

RealFrac CFloat

Instance details

Methods

properFraction :: Integral b => CFloat -> (b, CFloat)

truncate :: Integral b => CFloat -> b

round :: Integral b => CFloat -> b

ceiling :: Integral b => CFloat -> b

floor :: Integral b => CFloat -> b

Show CFloat

Instance details

Methods

showsPrec :: Int -> CFloat -> ShowS

show :: CFloat -> String

showList :: [CFloat] -> ShowS

Eq CFloat

Instance details

Methods

(==) :: CFloat -> CFloat -> Bool #

(/=) :: CFloat -> CFloat -> Bool #

Ord CFloat

Instance details

Methods

compare :: CFloat -> CFloat -> Ordering #

(<) :: CFloat -> CFloat -> Bool #

(<=) :: CFloat -> CFloat -> Bool #

(>) :: CFloat -> CFloat -> Bool #

(>=) :: CFloat -> CFloat -> Bool #

max :: CFloat -> CFloat -> CFloat #

min :: CFloat -> CFloat -> CFloat #

type Difference CFloat

Instance details

type Difference CFloat = CFloat

newtype CIntMax #

Constructors

CIntMax Int64

Instances

Instances details

HasNegation CIntMax

Instance details

Methods

negate :: CIntMax -> CIntMax #

Integral CIntMax

Instance details

Methods

fromInteger :: Integer -> CIntMax #

Additive CIntMax

Instance details

Methods

azero :: CIntMax #

(+) :: CIntMax -> CIntMax -> CIntMax #

scale :: IsNatural n => n -> CIntMax -> CIntMax #

IDivisible CIntMax

Instance details

Methods

div :: CIntMax -> CIntMax -> CIntMax #

mod :: CIntMax -> CIntMax -> CIntMax #

divMod :: CIntMax -> CIntMax -> (CIntMax, CIntMax) #

Multiplicative CIntMax

Instance details

Methods

midentity :: CIntMax #

(*) :: CIntMax -> CIntMax -> CIntMax #

(^) :: (IsNatural n, Enum n, IDivisible n) => CIntMax -> n -> CIntMax #

IsIntegral CIntMax

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CIntMax -> Integer #

Subtractive CIntMax

Instance details

Associated Types

type Difference CIntMax
Instance details Defined in Basement.Numerical.Subtractive type Difference CIntMax = CIntMax

Methods

(-) :: CIntMax -> CIntMax -> Difference CIntMax #

Bits CIntMax

Instance details

Methods

(.&.) :: CIntMax -> CIntMax -> CIntMax #

(.|.) :: CIntMax -> CIntMax -> CIntMax #

xor :: CIntMax -> CIntMax -> CIntMax #

complement :: CIntMax -> CIntMax #

shift :: CIntMax -> Int -> CIntMax #

rotate :: CIntMax -> Int -> CIntMax #

zeroBits :: CIntMax #

bit :: Int -> CIntMax #

setBit :: CIntMax -> Int -> CIntMax #

clearBit :: CIntMax -> Int -> CIntMax #

complementBit :: CIntMax -> Int -> CIntMax #

testBit :: CIntMax -> Int -> Bool #

bitSizeMaybe :: CIntMax -> Maybe Int #

bitSize :: CIntMax -> Int #

isSigned :: CIntMax -> Bool #

shiftL :: CIntMax -> Int -> CIntMax #

unsafeShiftL :: CIntMax -> Int -> CIntMax #

shiftR :: CIntMax -> Int -> CIntMax #

unsafeShiftR :: CIntMax -> Int -> CIntMax #

rotateL :: CIntMax -> Int -> CIntMax #

rotateR :: CIntMax -> Int -> CIntMax #

popCount :: CIntMax -> Int #

FiniteBits CIntMax

Instance details

Methods

finiteBitSize :: CIntMax -> Int

countLeadingZeros :: CIntMax -> Int

countTrailingZeros :: CIntMax -> Int

Bounded CIntMax

Instance details

Methods

minBound :: CIntMax #

maxBound :: CIntMax #

Enum CIntMax

Instance details

Methods

succ :: CIntMax -> CIntMax #

pred :: CIntMax -> CIntMax #

toEnum :: Int -> CIntMax #

fromEnum :: CIntMax -> Int #

enumFrom :: CIntMax -> [CIntMax] #

enumFromThen :: CIntMax -> CIntMax -> [CIntMax] #

enumFromTo :: CIntMax -> CIntMax -> [CIntMax] #

enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] #

Storable CIntMax

Instance details

Methods

sizeOf :: CIntMax -> Int

alignment :: CIntMax -> Int

peekElemOff :: Ptr CIntMax -> Int -> IO CIntMax

pokeElemOff :: Ptr CIntMax -> Int -> CIntMax -> IO ()

peekByteOff :: Ptr b -> Int -> IO CIntMax

pokeByteOff :: Ptr b -> Int -> CIntMax -> IO ()

peek :: Ptr CIntMax -> IO CIntMax

poke :: Ptr CIntMax -> CIntMax -> IO ()

Ix CIntMax

Instance details

Methods

range :: (CIntMax, CIntMax) -> [CIntMax]

index :: (CIntMax, CIntMax) -> CIntMax -> Int

unsafeIndex :: (CIntMax, CIntMax) -> CIntMax -> Int

inRange :: (CIntMax, CIntMax) -> CIntMax -> Bool

rangeSize :: (CIntMax, CIntMax) -> Int

unsafeRangeSize :: (CIntMax, CIntMax) -> Int

Num CIntMax

Instance details

Methods

(+) :: CIntMax -> CIntMax -> CIntMax

(-) :: CIntMax -> CIntMax -> CIntMax

(*) :: CIntMax -> CIntMax -> CIntMax

negate :: CIntMax -> CIntMax

abs :: CIntMax -> CIntMax

signum :: CIntMax -> CIntMax

fromInteger :: Integer -> CIntMax

Read CIntMax

Instance details

Methods

readsPrec :: Int -> ReadS CIntMax

readList :: ReadS [CIntMax]

readPrec :: ReadPrec CIntMax

readListPrec :: ReadPrec [CIntMax]

Integral CIntMax

Instance details

Methods

quot :: CIntMax -> CIntMax -> CIntMax

rem :: CIntMax -> CIntMax -> CIntMax

div :: CIntMax -> CIntMax -> CIntMax

mod :: CIntMax -> CIntMax -> CIntMax

quotRem :: CIntMax -> CIntMax -> (CIntMax, CIntMax)

divMod :: CIntMax -> CIntMax -> (CIntMax, CIntMax)

toInteger :: CIntMax -> Integer

Real CIntMax

Instance details

Methods

toRational :: CIntMax -> Rational

Show CIntMax

Instance details

Methods

showsPrec :: Int -> CIntMax -> ShowS

show :: CIntMax -> String

showList :: [CIntMax] -> ShowS

Eq CIntMax

Instance details

Methods

(==) :: CIntMax -> CIntMax -> Bool #

(/=) :: CIntMax -> CIntMax -> Bool #

Ord CIntMax

Instance details

Methods

compare :: CIntMax -> CIntMax -> Ordering #

(<) :: CIntMax -> CIntMax -> Bool #

(<=) :: CIntMax -> CIntMax -> Bool #

(>) :: CIntMax -> CIntMax -> Bool #

(>=) :: CIntMax -> CIntMax -> Bool #

max :: CIntMax -> CIntMax -> CIntMax #

min :: CIntMax -> CIntMax -> CIntMax #

type Difference CIntMax

Instance details

type Difference CIntMax = CIntMax

newtype CIntPtr #

Constructors

CIntPtr Int32

Instances

Instances details

Integral CIntPtr

Instance details

Methods

fromInteger :: Integer -> CIntPtr #

Additive CIntPtr

Instance details

Methods

azero :: CIntPtr #

(+) :: CIntPtr -> CIntPtr -> CIntPtr #

scale :: IsNatural n => n -> CIntPtr -> CIntPtr #

IDivisible CIntPtr

Instance details

Methods

div :: CIntPtr -> CIntPtr -> CIntPtr #

mod :: CIntPtr -> CIntPtr -> CIntPtr #

divMod :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr) #

Multiplicative CIntPtr

Instance details

Methods

midentity :: CIntPtr #

(*) :: CIntPtr -> CIntPtr -> CIntPtr #

(^) :: (IsNatural n, Enum n, IDivisible n) => CIntPtr -> n -> CIntPtr #

IsIntegral CIntPtr

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CIntPtr -> Integer #

Subtractive CIntPtr

Instance details

Associated Types

type Difference CIntPtr
Instance details Defined in Basement.Numerical.Subtractive type Difference CIntPtr = CIntPtr

Methods

(-) :: CIntPtr -> CIntPtr -> Difference CIntPtr #

Bits CIntPtr

Instance details

Methods

(.&.) :: CIntPtr -> CIntPtr -> CIntPtr #

(.|.) :: CIntPtr -> CIntPtr -> CIntPtr #

xor :: CIntPtr -> CIntPtr -> CIntPtr #

complement :: CIntPtr -> CIntPtr #

shift :: CIntPtr -> Int -> CIntPtr #

rotate :: CIntPtr -> Int -> CIntPtr #

zeroBits :: CIntPtr #

bit :: Int -> CIntPtr #

setBit :: CIntPtr -> Int -> CIntPtr #

clearBit :: CIntPtr -> Int -> CIntPtr #

complementBit :: CIntPtr -> Int -> CIntPtr #

testBit :: CIntPtr -> Int -> Bool #

bitSizeMaybe :: CIntPtr -> Maybe Int #

bitSize :: CIntPtr -> Int #

isSigned :: CIntPtr -> Bool #

shiftL :: CIntPtr -> Int -> CIntPtr #

unsafeShiftL :: CIntPtr -> Int -> CIntPtr #

shiftR :: CIntPtr -> Int -> CIntPtr #

unsafeShiftR :: CIntPtr -> Int -> CIntPtr #

rotateL :: CIntPtr -> Int -> CIntPtr #

rotateR :: CIntPtr -> Int -> CIntPtr #

popCount :: CIntPtr -> Int #

FiniteBits CIntPtr

Instance details

Methods

finiteBitSize :: CIntPtr -> Int

countLeadingZeros :: CIntPtr -> Int

countTrailingZeros :: CIntPtr -> Int

Bounded CIntPtr

Instance details

Methods

minBound :: CIntPtr #

maxBound :: CIntPtr #

Enum CIntPtr

Instance details

Methods

succ :: CIntPtr -> CIntPtr #

pred :: CIntPtr -> CIntPtr #

toEnum :: Int -> CIntPtr #

fromEnum :: CIntPtr -> Int #

enumFrom :: CIntPtr -> [CIntPtr] #

enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] #

enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] #

enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] #

Storable CIntPtr

Instance details

Methods

sizeOf :: CIntPtr -> Int

alignment :: CIntPtr -> Int

peekElemOff :: Ptr CIntPtr -> Int -> IO CIntPtr

pokeElemOff :: Ptr CIntPtr -> Int -> CIntPtr -> IO ()

peekByteOff :: Ptr b -> Int -> IO CIntPtr

pokeByteOff :: Ptr b -> Int -> CIntPtr -> IO ()

peek :: Ptr CIntPtr -> IO CIntPtr

poke :: Ptr CIntPtr -> CIntPtr -> IO ()

Ix CIntPtr

Instance details

Methods

range :: (CIntPtr, CIntPtr) -> [CIntPtr]

index :: (CIntPtr, CIntPtr) -> CIntPtr -> Int

unsafeIndex :: (CIntPtr, CIntPtr) -> CIntPtr -> Int

inRange :: (CIntPtr, CIntPtr) -> CIntPtr -> Bool

rangeSize :: (CIntPtr, CIntPtr) -> Int

unsafeRangeSize :: (CIntPtr, CIntPtr) -> Int

Num CIntPtr

Instance details

Methods

(+) :: CIntPtr -> CIntPtr -> CIntPtr

(-) :: CIntPtr -> CIntPtr -> CIntPtr

(*) :: CIntPtr -> CIntPtr -> CIntPtr

negate :: CIntPtr -> CIntPtr

abs :: CIntPtr -> CIntPtr

signum :: CIntPtr -> CIntPtr

fromInteger :: Integer -> CIntPtr

Read CIntPtr

Instance details

Methods

readsPrec :: Int -> ReadS CIntPtr

readList :: ReadS [CIntPtr]

readPrec :: ReadPrec CIntPtr

readListPrec :: ReadPrec [CIntPtr]

Integral CIntPtr

Instance details

Methods

quot :: CIntPtr -> CIntPtr -> CIntPtr

rem :: CIntPtr -> CIntPtr -> CIntPtr

div :: CIntPtr -> CIntPtr -> CIntPtr

mod :: CIntPtr -> CIntPtr -> CIntPtr

quotRem :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr)

divMod :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr)

toInteger :: CIntPtr -> Integer

Real CIntPtr

Instance details

Methods

toRational :: CIntPtr -> Rational

Show CIntPtr

Instance details

Methods

showsPrec :: Int -> CIntPtr -> ShowS

show :: CIntPtr -> String

showList :: [CIntPtr] -> ShowS

Eq CIntPtr

Instance details

Methods

(==) :: CIntPtr -> CIntPtr -> Bool #

(/=) :: CIntPtr -> CIntPtr -> Bool #

Ord CIntPtr

Instance details

Methods

compare :: CIntPtr -> CIntPtr -> Ordering #

(<) :: CIntPtr -> CIntPtr -> Bool #

(<=) :: CIntPtr -> CIntPtr -> Bool #

(>) :: CIntPtr -> CIntPtr -> Bool #

(>=) :: CIntPtr -> CIntPtr -> Bool #

max :: CIntPtr -> CIntPtr -> CIntPtr #

min :: CIntPtr -> CIntPtr -> CIntPtr #

type Difference CIntPtr

Instance details

type Difference CIntPtr = CIntPtr

newtype CLLong #

Constructors

CLLong Int64

Instances

Instances details

HasNegation CLLong

Instance details

Methods

negate :: CLLong -> CLLong #

Integral CLLong

Instance details

Methods

fromInteger :: Integer -> CLLong #

NormalForm CLLong

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CLLong -> () #

Additive CLLong

Instance details

Methods

azero :: CLLong #

(+) :: CLLong -> CLLong -> CLLong #

scale :: IsNatural n => n -> CLLong -> CLLong #

IDivisible CLLong

Instance details

Methods

div :: CLLong -> CLLong -> CLLong #

mod :: CLLong -> CLLong -> CLLong #

divMod :: CLLong -> CLLong -> (CLLong, CLLong) #

Multiplicative CLLong

Instance details

Methods

midentity :: CLLong #

(*) :: CLLong -> CLLong -> CLLong #

(^) :: (IsNatural n, Enum n, IDivisible n) => CLLong -> n -> CLLong #

IsIntegral CLLong

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CLLong -> Integer #

Subtractive CLLong

Instance details

Associated Types

type Difference CLLong
Instance details Defined in Basement.Numerical.Subtractive type Difference CLLong = CLLong

Methods

(-) :: CLLong -> CLLong -> Difference CLLong #

Bits CLLong

Instance details

Methods

(.&.) :: CLLong -> CLLong -> CLLong #

(.|.) :: CLLong -> CLLong -> CLLong #

xor :: CLLong -> CLLong -> CLLong #

complement :: CLLong -> CLLong #

shift :: CLLong -> Int -> CLLong #

rotate :: CLLong -> Int -> CLLong #

zeroBits :: CLLong #

bit :: Int -> CLLong #

setBit :: CLLong -> Int -> CLLong #

clearBit :: CLLong -> Int -> CLLong #

complementBit :: CLLong -> Int -> CLLong #

testBit :: CLLong -> Int -> Bool #

bitSizeMaybe :: CLLong -> Maybe Int #

bitSize :: CLLong -> Int #

isSigned :: CLLong -> Bool #

shiftL :: CLLong -> Int -> CLLong #

unsafeShiftL :: CLLong -> Int -> CLLong #

shiftR :: CLLong -> Int -> CLLong #

unsafeShiftR :: CLLong -> Int -> CLLong #

rotateL :: CLLong -> Int -> CLLong #

rotateR :: CLLong -> Int -> CLLong #

popCount :: CLLong -> Int #

FiniteBits CLLong

Instance details

Methods

finiteBitSize :: CLLong -> Int

countLeadingZeros :: CLLong -> Int

countTrailingZeros :: CLLong -> Int

Bounded CLLong

Instance details

Methods

minBound :: CLLong #

maxBound :: CLLong #

Enum CLLong

Instance details

Methods

succ :: CLLong -> CLLong #

pred :: CLLong -> CLLong #

toEnum :: Int -> CLLong #

fromEnum :: CLLong -> Int #

enumFrom :: CLLong -> [CLLong] #

enumFromThen :: CLLong -> CLLong -> [CLLong] #

enumFromTo :: CLLong -> CLLong -> [CLLong] #

enumFromThenTo :: CLLong -> CLLong -> CLLong -> [CLLong] #

Storable CLLong

Instance details

Methods

sizeOf :: CLLong -> Int

alignment :: CLLong -> Int

peekElemOff :: Ptr CLLong -> Int -> IO CLLong

pokeElemOff :: Ptr CLLong -> Int -> CLLong -> IO ()

peekByteOff :: Ptr b -> Int -> IO CLLong

pokeByteOff :: Ptr b -> Int -> CLLong -> IO ()

peek :: Ptr CLLong -> IO CLLong

poke :: Ptr CLLong -> CLLong -> IO ()

Ix CLLong

Instance details

Methods

range :: (CLLong, CLLong) -> [CLLong]

index :: (CLLong, CLLong) -> CLLong -> Int

unsafeIndex :: (CLLong, CLLong) -> CLLong -> Int

inRange :: (CLLong, CLLong) -> CLLong -> Bool

rangeSize :: (CLLong, CLLong) -> Int

unsafeRangeSize :: (CLLong, CLLong) -> Int

Num CLLong

Instance details

Methods

(+) :: CLLong -> CLLong -> CLLong

(-) :: CLLong -> CLLong -> CLLong

(*) :: CLLong -> CLLong -> CLLong

negate :: CLLong -> CLLong

abs :: CLLong -> CLLong

signum :: CLLong -> CLLong

fromInteger :: Integer -> CLLong

Read CLLong

Instance details

Methods

readsPrec :: Int -> ReadS CLLong

readList :: ReadS [CLLong]

readPrec :: ReadPrec CLLong

readListPrec :: ReadPrec [CLLong]

Integral CLLong

Instance details

Methods

quot :: CLLong -> CLLong -> CLLong

rem :: CLLong -> CLLong -> CLLong

div :: CLLong -> CLLong -> CLLong

mod :: CLLong -> CLLong -> CLLong

quotRem :: CLLong -> CLLong -> (CLLong, CLLong)

divMod :: CLLong -> CLLong -> (CLLong, CLLong)

toInteger :: CLLong -> Integer

Real CLLong

Instance details

Methods

toRational :: CLLong -> Rational

Show CLLong

Instance details

Methods

showsPrec :: Int -> CLLong -> ShowS

show :: CLLong -> String

showList :: [CLLong] -> ShowS

Eq CLLong

Instance details

Methods

(==) :: CLLong -> CLLong -> Bool #

(/=) :: CLLong -> CLLong -> Bool #

Ord CLLong

Instance details

Methods

compare :: CLLong -> CLLong -> Ordering #

(<) :: CLLong -> CLLong -> Bool #

(<=) :: CLLong -> CLLong -> Bool #

(>) :: CLLong -> CLLong -> Bool #

(>=) :: CLLong -> CLLong -> Bool #

max :: CLLong -> CLLong -> CLLong #

min :: CLLong -> CLLong -> CLLong #

type Difference CLLong

Instance details

type Difference CLLong = CLLong

newtype CLong #

Constructors

CLong Int32

Instances

Instances details

HasNegation CLong

Instance details

Methods

negate :: CLong -> CLong #

Integral CLong

Instance details

Methods

fromInteger :: Integer -> CLong #

NormalForm CLong

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CLong -> () #

Additive CLong

Instance details

Methods

azero :: CLong #

(+) :: CLong -> CLong -> CLong #

scale :: IsNatural n => n -> CLong -> CLong #

IDivisible CLong

Instance details

Methods

div :: CLong -> CLong -> CLong #

mod :: CLong -> CLong -> CLong #

divMod :: CLong -> CLong -> (CLong, CLong) #

Multiplicative CLong

Instance details

Methods

midentity :: CLong #

(*) :: CLong -> CLong -> CLong #

(^) :: (IsNatural n, Enum n, IDivisible n) => CLong -> n -> CLong #

IsIntegral CLong

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CLong -> Integer #

Subtractive CLong

Instance details

Associated Types

type Difference CLong
Instance details Defined in Basement.Numerical.Subtractive type Difference CLong = CLong

Methods

(-) :: CLong -> CLong -> Difference CLong #

Bits CLong

Instance details

Methods

(.&.) :: CLong -> CLong -> CLong #

(.|.) :: CLong -> CLong -> CLong #

xor :: CLong -> CLong -> CLong #

complement :: CLong -> CLong #

shift :: CLong -> Int -> CLong #

rotate :: CLong -> Int -> CLong #

zeroBits :: CLong #

bit :: Int -> CLong #

setBit :: CLong -> Int -> CLong #

clearBit :: CLong -> Int -> CLong #

complementBit :: CLong -> Int -> CLong #

testBit :: CLong -> Int -> Bool #

bitSizeMaybe :: CLong -> Maybe Int #

bitSize :: CLong -> Int #

isSigned :: CLong -> Bool #

shiftL :: CLong -> Int -> CLong #

unsafeShiftL :: CLong -> Int -> CLong #

shiftR :: CLong -> Int -> CLong #

unsafeShiftR :: CLong -> Int -> CLong #

rotateL :: CLong -> Int -> CLong #

rotateR :: CLong -> Int -> CLong #

popCount :: CLong -> Int #

FiniteBits CLong

Instance details

Methods

finiteBitSize :: CLong -> Int

countLeadingZeros :: CLong -> Int

countTrailingZeros :: CLong -> Int

Bounded CLong

Instance details

Methods

minBound :: CLong #

maxBound :: CLong #

Enum CLong

Instance details

Methods

succ :: CLong -> CLong #

pred :: CLong -> CLong #

toEnum :: Int -> CLong #

fromEnum :: CLong -> Int #

enumFrom :: CLong -> [CLong] #

enumFromThen :: CLong -> CLong -> [CLong] #

enumFromTo :: CLong -> CLong -> [CLong] #

enumFromThenTo :: CLong -> CLong -> CLong -> [CLong] #

Storable CLong

Instance details

Methods

sizeOf :: CLong -> Int

alignment :: CLong -> Int

peekElemOff :: Ptr CLong -> Int -> IO CLong

pokeElemOff :: Ptr CLong -> Int -> CLong -> IO ()

peekByteOff :: Ptr b -> Int -> IO CLong

pokeByteOff :: Ptr b -> Int -> CLong -> IO ()

peek :: Ptr CLong -> IO CLong

poke :: Ptr CLong -> CLong -> IO ()

Ix CLong

Instance details

Methods

range :: (CLong, CLong) -> [CLong]

index :: (CLong, CLong) -> CLong -> Int

unsafeIndex :: (CLong, CLong) -> CLong -> Int

inRange :: (CLong, CLong) -> CLong -> Bool

rangeSize :: (CLong, CLong) -> Int

unsafeRangeSize :: (CLong, CLong) -> Int

Num CLong

Instance details

Methods

(+) :: CLong -> CLong -> CLong

(-) :: CLong -> CLong -> CLong

(*) :: CLong -> CLong -> CLong

negate :: CLong -> CLong

abs :: CLong -> CLong

signum :: CLong -> CLong

fromInteger :: Integer -> CLong

Read CLong

Instance details

Methods

readsPrec :: Int -> ReadS CLong

readList :: ReadS [CLong]

readPrec :: ReadPrec CLong

readListPrec :: ReadPrec [CLong]

Integral CLong

Instance details

Methods

quot :: CLong -> CLong -> CLong

rem :: CLong -> CLong -> CLong

div :: CLong -> CLong -> CLong

mod :: CLong -> CLong -> CLong

quotRem :: CLong -> CLong -> (CLong, CLong)

divMod :: CLong -> CLong -> (CLong, CLong)

toInteger :: CLong -> Integer

Real CLong

Instance details

Methods

toRational :: CLong -> Rational

Show CLong

Instance details

Methods

showsPrec :: Int -> CLong -> ShowS

show :: CLong -> String

showList :: [CLong] -> ShowS

Eq CLong

Instance details

Methods

(==) :: CLong -> CLong -> Bool #

(/=) :: CLong -> CLong -> Bool #

Ord CLong

Instance details

Methods

compare :: CLong -> CLong -> Ordering #

(<) :: CLong -> CLong -> Bool #

(<=) :: CLong -> CLong -> Bool #

(>) :: CLong -> CLong -> Bool #

(>=) :: CLong -> CLong -> Bool #

max :: CLong -> CLong -> CLong #

min :: CLong -> CLong -> CLong #

type Difference CLong

Instance details

type Difference CLong = CLong

newtype CPtrdiff #

Constructors

CPtrdiff Int32

Instances

Instances details

HasNegation CPtrdiff

Instance details

Methods

negate :: CPtrdiff -> CPtrdiff #

Integral CPtrdiff

Instance details

Methods

fromInteger :: Integer -> CPtrdiff #

Additive CPtrdiff

Instance details

Methods

azero :: CPtrdiff #

(+) :: CPtrdiff -> CPtrdiff -> CPtrdiff #

scale :: IsNatural n => n -> CPtrdiff -> CPtrdiff #

IDivisible CPtrdiff

Instance details

Methods

div :: CPtrdiff -> CPtrdiff -> CPtrdiff #

mod :: CPtrdiff -> CPtrdiff -> CPtrdiff #

divMod :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff) #

Multiplicative CPtrdiff

Instance details

Methods

midentity :: CPtrdiff #

(*) :: CPtrdiff -> CPtrdiff -> CPtrdiff #

(^) :: (IsNatural n, Enum n, IDivisible n) => CPtrdiff -> n -> CPtrdiff #

IsIntegral CPtrdiff

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CPtrdiff -> Integer #

Subtractive CPtrdiff

Instance details

Associated Types

type Difference CPtrdiff
Instance details Defined in Basement.Numerical.Subtractive type Difference CPtrdiff = CPtrdiff

Methods

(-) :: CPtrdiff -> CPtrdiff -> Difference CPtrdiff #

Bits CPtrdiff

Instance details

Methods

(.&.) :: CPtrdiff -> CPtrdiff -> CPtrdiff #

(.|.) :: CPtrdiff -> CPtrdiff -> CPtrdiff #

xor :: CPtrdiff -> CPtrdiff -> CPtrdiff #

complement :: CPtrdiff -> CPtrdiff #

shift :: CPtrdiff -> Int -> CPtrdiff #

rotate :: CPtrdiff -> Int -> CPtrdiff #

zeroBits :: CPtrdiff #

bit :: Int -> CPtrdiff #

setBit :: CPtrdiff -> Int -> CPtrdiff #

clearBit :: CPtrdiff -> Int -> CPtrdiff #

complementBit :: CPtrdiff -> Int -> CPtrdiff #

testBit :: CPtrdiff -> Int -> Bool #

bitSizeMaybe :: CPtrdiff -> Maybe Int #

bitSize :: CPtrdiff -> Int #

isSigned :: CPtrdiff -> Bool #

shiftL :: CPtrdiff -> Int -> CPtrdiff #

unsafeShiftL :: CPtrdiff -> Int -> CPtrdiff #

shiftR :: CPtrdiff -> Int -> CPtrdiff #

unsafeShiftR :: CPtrdiff -> Int -> CPtrdiff #

rotateL :: CPtrdiff -> Int -> CPtrdiff #

rotateR :: CPtrdiff -> Int -> CPtrdiff #

popCount :: CPtrdiff -> Int #

FiniteBits CPtrdiff

Instance details

Methods

finiteBitSize :: CPtrdiff -> Int

countLeadingZeros :: CPtrdiff -> Int

countTrailingZeros :: CPtrdiff -> Int

Bounded CPtrdiff

Instance details

Methods

minBound :: CPtrdiff #

maxBound :: CPtrdiff #

Enum CPtrdiff

Instance details

Methods

succ :: CPtrdiff -> CPtrdiff #

pred :: CPtrdiff -> CPtrdiff #

toEnum :: Int -> CPtrdiff #

fromEnum :: CPtrdiff -> Int #

enumFrom :: CPtrdiff -> [CPtrdiff] #

enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] #

enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] #

enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] #

Storable CPtrdiff

Instance details

Methods

sizeOf :: CPtrdiff -> Int

alignment :: CPtrdiff -> Int

peekElemOff :: Ptr CPtrdiff -> Int -> IO CPtrdiff

pokeElemOff :: Ptr CPtrdiff -> Int -> CPtrdiff -> IO ()

peekByteOff :: Ptr b -> Int -> IO CPtrdiff

pokeByteOff :: Ptr b -> Int -> CPtrdiff -> IO ()

peek :: Ptr CPtrdiff -> IO CPtrdiff

poke :: Ptr CPtrdiff -> CPtrdiff -> IO ()

Ix CPtrdiff

Instance details

Methods

range :: (CPtrdiff, CPtrdiff) -> [CPtrdiff]

index :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Int

unsafeIndex :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Int

inRange :: (CPtrdiff, CPtrdiff) -> CPtrdiff -> Bool

rangeSize :: (CPtrdiff, CPtrdiff) -> Int

unsafeRangeSize :: (CPtrdiff, CPtrdiff) -> Int

Num CPtrdiff

Instance details

Methods

(+) :: CPtrdiff -> CPtrdiff -> CPtrdiff

(-) :: CPtrdiff -> CPtrdiff -> CPtrdiff

(*) :: CPtrdiff -> CPtrdiff -> CPtrdiff

negate :: CPtrdiff -> CPtrdiff

abs :: CPtrdiff -> CPtrdiff

signum :: CPtrdiff -> CPtrdiff

fromInteger :: Integer -> CPtrdiff

Read CPtrdiff

Instance details

Methods

readsPrec :: Int -> ReadS CPtrdiff

readList :: ReadS [CPtrdiff]

readPrec :: ReadPrec CPtrdiff

readListPrec :: ReadPrec [CPtrdiff]

Integral CPtrdiff

Instance details

Methods

quot :: CPtrdiff -> CPtrdiff -> CPtrdiff

rem :: CPtrdiff -> CPtrdiff -> CPtrdiff

div :: CPtrdiff -> CPtrdiff -> CPtrdiff

mod :: CPtrdiff -> CPtrdiff -> CPtrdiff

quotRem :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff)

divMod :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff)

toInteger :: CPtrdiff -> Integer

Real CPtrdiff

Instance details

Methods

toRational :: CPtrdiff -> Rational

Show CPtrdiff

Instance details

Methods

showsPrec :: Int -> CPtrdiff -> ShowS

show :: CPtrdiff -> String

showList :: [CPtrdiff] -> ShowS

Eq CPtrdiff

Instance details

Methods

(==) :: CPtrdiff -> CPtrdiff -> Bool #

(/=) :: CPtrdiff -> CPtrdiff -> Bool #

Ord CPtrdiff

Instance details

Methods

compare :: CPtrdiff -> CPtrdiff -> Ordering #

(<) :: CPtrdiff -> CPtrdiff -> Bool #

(<=) :: CPtrdiff -> CPtrdiff -> Bool #

(>) :: CPtrdiff -> CPtrdiff -> Bool #

(>=) :: CPtrdiff -> CPtrdiff -> Bool #

max :: CPtrdiff -> CPtrdiff -> CPtrdiff #

min :: CPtrdiff -> CPtrdiff -> CPtrdiff #

type Difference CPtrdiff

Instance details

type Difference CPtrdiff = CPtrdiff

newtype CSChar #

Constructors

CSChar Int8

Instances

Instances details

HasNegation CSChar

Instance details

Methods

negate :: CSChar -> CSChar #

Integral CSChar

Instance details

Methods

fromInteger :: Integer -> CSChar #

NormalForm CSChar

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CSChar -> () #

Additive CSChar

Instance details

Methods

azero :: CSChar #

(+) :: CSChar -> CSChar -> CSChar #

scale :: IsNatural n => n -> CSChar -> CSChar #

IDivisible CSChar

Instance details

Methods

div :: CSChar -> CSChar -> CSChar #

mod :: CSChar -> CSChar -> CSChar #

divMod :: CSChar -> CSChar -> (CSChar, CSChar) #

Multiplicative CSChar

Instance details

Methods

midentity :: CSChar #

(*) :: CSChar -> CSChar -> CSChar #

(^) :: (IsNatural n, Enum n, IDivisible n) => CSChar -> n -> CSChar #

IsIntegral CSChar

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CSChar -> Integer #

Subtractive CSChar

Instance details

Associated Types

type Difference CSChar
Instance details Defined in Basement.Numerical.Subtractive type Difference CSChar = CSChar

Methods

(-) :: CSChar -> CSChar -> Difference CSChar #

Bits CSChar

Instance details

Methods

(.&.) :: CSChar -> CSChar -> CSChar #

(.|.) :: CSChar -> CSChar -> CSChar #

xor :: CSChar -> CSChar -> CSChar #

complement :: CSChar -> CSChar #

shift :: CSChar -> Int -> CSChar #

rotate :: CSChar -> Int -> CSChar #

zeroBits :: CSChar #

bit :: Int -> CSChar #

setBit :: CSChar -> Int -> CSChar #

clearBit :: CSChar -> Int -> CSChar #

complementBit :: CSChar -> Int -> CSChar #

testBit :: CSChar -> Int -> Bool #

bitSizeMaybe :: CSChar -> Maybe Int #

bitSize :: CSChar -> Int #

isSigned :: CSChar -> Bool #

shiftL :: CSChar -> Int -> CSChar #

unsafeShiftL :: CSChar -> Int -> CSChar #

shiftR :: CSChar -> Int -> CSChar #

unsafeShiftR :: CSChar -> Int -> CSChar #

rotateL :: CSChar -> Int -> CSChar #

rotateR :: CSChar -> Int -> CSChar #

popCount :: CSChar -> Int #

FiniteBits CSChar

Instance details

Methods

finiteBitSize :: CSChar -> Int

countLeadingZeros :: CSChar -> Int

countTrailingZeros :: CSChar -> Int

Bounded CSChar

Instance details

Methods

minBound :: CSChar #

maxBound :: CSChar #

Enum CSChar

Instance details

Methods

succ :: CSChar -> CSChar #

pred :: CSChar -> CSChar #

toEnum :: Int -> CSChar #

fromEnum :: CSChar -> Int #

enumFrom :: CSChar -> [CSChar] #

enumFromThen :: CSChar -> CSChar -> [CSChar] #

enumFromTo :: CSChar -> CSChar -> [CSChar] #

enumFromThenTo :: CSChar -> CSChar -> CSChar -> [CSChar] #

Storable CSChar

Instance details

Methods

sizeOf :: CSChar -> Int

alignment :: CSChar -> Int

peekElemOff :: Ptr CSChar -> Int -> IO CSChar

pokeElemOff :: Ptr CSChar -> Int -> CSChar -> IO ()

peekByteOff :: Ptr b -> Int -> IO CSChar

pokeByteOff :: Ptr b -> Int -> CSChar -> IO ()

peek :: Ptr CSChar -> IO CSChar

poke :: Ptr CSChar -> CSChar -> IO ()

Ix CSChar

Instance details

Methods

range :: (CSChar, CSChar) -> [CSChar]

index :: (CSChar, CSChar) -> CSChar -> Int

unsafeIndex :: (CSChar, CSChar) -> CSChar -> Int

inRange :: (CSChar, CSChar) -> CSChar -> Bool

rangeSize :: (CSChar, CSChar) -> Int

unsafeRangeSize :: (CSChar, CSChar) -> Int

Num CSChar

Instance details

Methods

(+) :: CSChar -> CSChar -> CSChar

(-) :: CSChar -> CSChar -> CSChar

(*) :: CSChar -> CSChar -> CSChar

negate :: CSChar -> CSChar

abs :: CSChar -> CSChar

signum :: CSChar -> CSChar

fromInteger :: Integer -> CSChar

Read CSChar

Instance details

Methods

readsPrec :: Int -> ReadS CSChar

readList :: ReadS [CSChar]

readPrec :: ReadPrec CSChar

readListPrec :: ReadPrec [CSChar]

Integral CSChar

Instance details

Methods

quot :: CSChar -> CSChar -> CSChar

rem :: CSChar -> CSChar -> CSChar

div :: CSChar -> CSChar -> CSChar

mod :: CSChar -> CSChar -> CSChar

quotRem :: CSChar -> CSChar -> (CSChar, CSChar)

divMod :: CSChar -> CSChar -> (CSChar, CSChar)

toInteger :: CSChar -> Integer

Real CSChar

Instance details

Methods

toRational :: CSChar -> Rational

Show CSChar

Instance details

Methods

showsPrec :: Int -> CSChar -> ShowS

show :: CSChar -> String

showList :: [CSChar] -> ShowS

Eq CSChar

Instance details

Methods

(==) :: CSChar -> CSChar -> Bool #

(/=) :: CSChar -> CSChar -> Bool #

Ord CSChar

Instance details

Methods

compare :: CSChar -> CSChar -> Ordering #

(<) :: CSChar -> CSChar -> Bool #

(<=) :: CSChar -> CSChar -> Bool #

(>) :: CSChar -> CSChar -> Bool #

(>=) :: CSChar -> CSChar -> Bool #

max :: CSChar -> CSChar -> CSChar #

min :: CSChar -> CSChar -> CSChar #

type Difference CSChar

Instance details

type Difference CSChar = CSChar

newtype CSUSeconds #

Constructors

CSUSeconds Int32

Instances

Instances details

Integral CSUSeconds

Instance details

Methods

fromInteger :: Integer -> CSUSeconds #

Additive CSUSeconds

Instance details

Multiplicative CSUSeconds

Methods

azero :: CSUSeconds #

(+) :: CSUSeconds -> CSUSeconds -> CSUSeconds #

scale :: IsNatural n => n -> CSUSeconds -> CSUSeconds #

Instance details

Methods

midentity :: CSUSeconds #

(*) :: CSUSeconds -> CSUSeconds -> CSUSeconds #

(^) :: (IsNatural n, Enum n, IDivisible n) => CSUSeconds -> n -> CSUSeconds #

Subtractive CSUSeconds

Instance details

Associated Types

type Difference CSUSeconds
Instance details Defined in Basement.Numerical.Subtractive type Difference CSUSeconds = CSUSeconds

Methods

(-) :: CSUSeconds -> CSUSeconds -> Difference CSUSeconds #

Enum CSUSeconds

Instance details

Methods

succ :: CSUSeconds -> CSUSeconds #

pred :: CSUSeconds -> CSUSeconds #

toEnum :: Int -> CSUSeconds #

fromEnum :: CSUSeconds -> Int #

enumFrom :: CSUSeconds -> [CSUSeconds] #

enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] #

enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] #

enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] #

Storable CSUSeconds

Instance details

Methods

sizeOf :: CSUSeconds -> Int

alignment :: CSUSeconds -> Int

peekElemOff :: Ptr CSUSeconds -> Int -> IO CSUSeconds

pokeElemOff :: Ptr CSUSeconds -> Int -> CSUSeconds -> IO ()

peekByteOff :: Ptr b -> Int -> IO CSUSeconds

pokeByteOff :: Ptr b -> Int -> CSUSeconds -> IO ()

peek :: Ptr CSUSeconds -> IO CSUSeconds

poke :: Ptr CSUSeconds -> CSUSeconds -> IO ()

Num CSUSeconds

Instance details

Methods

(+) :: CSUSeconds -> CSUSeconds -> CSUSeconds

(-) :: CSUSeconds -> CSUSeconds -> CSUSeconds

(*) :: CSUSeconds -> CSUSeconds -> CSUSeconds

negate :: CSUSeconds -> CSUSeconds

abs :: CSUSeconds -> CSUSeconds

signum :: CSUSeconds -> CSUSeconds

fromInteger :: Integer -> CSUSeconds

Read CSUSeconds

Instance details

Methods

readsPrec :: Int -> ReadS CSUSeconds

readList :: ReadS [CSUSeconds]

readPrec :: ReadPrec CSUSeconds

readListPrec :: ReadPrec [CSUSeconds]

Real CSUSeconds

Instance details

Methods

toRational :: CSUSeconds -> Rational

Show CSUSeconds

Instance details

Methods

showsPrec :: Int -> CSUSeconds -> ShowS

show :: CSUSeconds -> String

showList :: [CSUSeconds] -> ShowS

Eq CSUSeconds

Instance details

Methods

(==) :: CSUSeconds -> CSUSeconds -> Bool #

(/=) :: CSUSeconds -> CSUSeconds -> Bool #

Ord CSUSeconds

Instance details

Methods

compare :: CSUSeconds -> CSUSeconds -> Ordering #

(<) :: CSUSeconds -> CSUSeconds -> Bool #

(<=) :: CSUSeconds -> CSUSeconds -> Bool #

(>) :: CSUSeconds -> CSUSeconds -> Bool #

(>=) :: CSUSeconds -> CSUSeconds -> Bool #

max :: CSUSeconds -> CSUSeconds -> CSUSeconds #

min :: CSUSeconds -> CSUSeconds -> CSUSeconds #

type Difference CSUSeconds

Instance details

type Difference CSUSeconds = CSUSeconds

newtype CShort #

Constructors

CShort Int16

Instances

Instances details

HasNegation CShort

Instance details

Methods

negate :: CShort -> CShort #

Integral CShort

Instance details

Methods

fromInteger :: Integer -> CShort #

NormalForm CShort

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CShort -> () #

Additive CShort

Instance details

Methods

azero :: CShort #

(+) :: CShort -> CShort -> CShort #

scale :: IsNatural n => n -> CShort -> CShort #

IDivisible CShort

Instance details

Methods

div :: CShort -> CShort -> CShort #

mod :: CShort -> CShort -> CShort #

divMod :: CShort -> CShort -> (CShort, CShort) #

Multiplicative CShort

Instance details

Methods

midentity :: CShort #

(*) :: CShort -> CShort -> CShort #

(^) :: (IsNatural n, Enum n, IDivisible n) => CShort -> n -> CShort #

IsIntegral CShort

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CShort -> Integer #

Subtractive CShort

Instance details

Associated Types

type Difference CShort
Instance details Defined in Basement.Numerical.Subtractive type Difference CShort = CShort

Methods

(-) :: CShort -> CShort -> Difference CShort #

Bits CShort

Instance details

Methods

(.&.) :: CShort -> CShort -> CShort #

(.|.) :: CShort -> CShort -> CShort #

xor :: CShort -> CShort -> CShort #

complement :: CShort -> CShort #

shift :: CShort -> Int -> CShort #

rotate :: CShort -> Int -> CShort #

zeroBits :: CShort #

bit :: Int -> CShort #

setBit :: CShort -> Int -> CShort #

clearBit :: CShort -> Int -> CShort #

complementBit :: CShort -> Int -> CShort #

testBit :: CShort -> Int -> Bool #

bitSizeMaybe :: CShort -> Maybe Int #

bitSize :: CShort -> Int #

isSigned :: CShort -> Bool #

shiftL :: CShort -> Int -> CShort #

unsafeShiftL :: CShort -> Int -> CShort #

shiftR :: CShort -> Int -> CShort #

unsafeShiftR :: CShort -> Int -> CShort #

rotateL :: CShort -> Int -> CShort #

rotateR :: CShort -> Int -> CShort #

popCount :: CShort -> Int #

FiniteBits CShort

Instance details

Methods

finiteBitSize :: CShort -> Int

countLeadingZeros :: CShort -> Int

countTrailingZeros :: CShort -> Int

Bounded CShort

Instance details

Methods

minBound :: CShort #

maxBound :: CShort #

Enum CShort

Instance details

Methods

succ :: CShort -> CShort #

pred :: CShort -> CShort #

toEnum :: Int -> CShort #

fromEnum :: CShort -> Int #

enumFrom :: CShort -> [CShort] #

enumFromThen :: CShort -> CShort -> [CShort] #

enumFromTo :: CShort -> CShort -> [CShort] #

enumFromThenTo :: CShort -> CShort -> CShort -> [CShort] #

Storable CShort

Instance details

Methods

sizeOf :: CShort -> Int

alignment :: CShort -> Int

peekElemOff :: Ptr CShort -> Int -> IO CShort

pokeElemOff :: Ptr CShort -> Int -> CShort -> IO ()

peekByteOff :: Ptr b -> Int -> IO CShort

pokeByteOff :: Ptr b -> Int -> CShort -> IO ()

peek :: Ptr CShort -> IO CShort

poke :: Ptr CShort -> CShort -> IO ()

Ix CShort

Instance details

Methods

range :: (CShort, CShort) -> [CShort]

index :: (CShort, CShort) -> CShort -> Int

unsafeIndex :: (CShort, CShort) -> CShort -> Int

inRange :: (CShort, CShort) -> CShort -> Bool

rangeSize :: (CShort, CShort) -> Int

unsafeRangeSize :: (CShort, CShort) -> Int

Num CShort

Instance details

Methods

(+) :: CShort -> CShort -> CShort

(-) :: CShort -> CShort -> CShort

(*) :: CShort -> CShort -> CShort

negate :: CShort -> CShort

abs :: CShort -> CShort

signum :: CShort -> CShort

fromInteger :: Integer -> CShort

Read CShort

Instance details

Methods

readsPrec :: Int -> ReadS CShort

readList :: ReadS [CShort]

readPrec :: ReadPrec CShort

readListPrec :: ReadPrec [CShort]

Integral CShort

Instance details

Methods

quot :: CShort -> CShort -> CShort

rem :: CShort -> CShort -> CShort

div :: CShort -> CShort -> CShort

mod :: CShort -> CShort -> CShort

quotRem :: CShort -> CShort -> (CShort, CShort)

divMod :: CShort -> CShort -> (CShort, CShort)

toInteger :: CShort -> Integer

Real CShort

Instance details

Methods

toRational :: CShort -> Rational

Show CShort

Instance details

Methods

showsPrec :: Int -> CShort -> ShowS

show :: CShort -> String

showList :: [CShort] -> ShowS

Eq CShort

Instance details

Methods

(==) :: CShort -> CShort -> Bool #

(/=) :: CShort -> CShort -> Bool #

Ord CShort

Instance details

Methods

compare :: CShort -> CShort -> Ordering #

(<) :: CShort -> CShort -> Bool #

(<=) :: CShort -> CShort -> Bool #

(>) :: CShort -> CShort -> Bool #

(>=) :: CShort -> CShort -> Bool #

max :: CShort -> CShort -> CShort #

min :: CShort -> CShort -> CShort #

type Difference CShort

Instance details

type Difference CShort = CShort

newtype CSigAtomic #

Constructors

CSigAtomic Int32

Instances

Instances details

Integral CSigAtomic

Instance details

Methods

fromInteger :: Integer -> CSigAtomic #

Additive CSigAtomic

Instance details

Methods

azero :: CSigAtomic #

(+) :: CSigAtomic -> CSigAtomic -> CSigAtomic #

scale :: IsNatural n => n -> CSigAtomic -> CSigAtomic #

IDivisible CSigAtomic

Instance details

Multiplicative CSigAtomic

Methods

div :: CSigAtomic -> CSigAtomic -> CSigAtomic #

mod :: CSigAtomic -> CSigAtomic -> CSigAtomic #

divMod :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic) #

Instance details

Methods

midentity :: CSigAtomic #

(*) :: CSigAtomic -> CSigAtomic -> CSigAtomic #

(^) :: (IsNatural n, Enum n, IDivisible n) => CSigAtomic -> n -> CSigAtomic #

IsIntegral CSigAtomic

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CSigAtomic -> Integer #

Subtractive CSigAtomic

Instance details

Associated Types

type Difference CSigAtomic
Instance details Defined in Basement.Numerical.Subtractive type Difference CSigAtomic = CSigAtomic

Methods

(-) :: CSigAtomic -> CSigAtomic -> Difference CSigAtomic #

Bits CSigAtomic

Instance details

Methods

(.&.) :: CSigAtomic -> CSigAtomic -> CSigAtomic #

(.|.) :: CSigAtomic -> CSigAtomic -> CSigAtomic #

xor :: CSigAtomic -> CSigAtomic -> CSigAtomic #

complement :: CSigAtomic -> CSigAtomic #

shift :: CSigAtomic -> Int -> CSigAtomic #

rotate :: CSigAtomic -> Int -> CSigAtomic #

zeroBits :: CSigAtomic #

bit :: Int -> CSigAtomic #

setBit :: CSigAtomic -> Int -> CSigAtomic #

clearBit :: CSigAtomic -> Int -> CSigAtomic #

complementBit :: CSigAtomic -> Int -> CSigAtomic #

testBit :: CSigAtomic -> Int -> Bool #

bitSizeMaybe :: CSigAtomic -> Maybe Int #

bitSize :: CSigAtomic -> Int #

isSigned :: CSigAtomic -> Bool #

shiftL :: CSigAtomic -> Int -> CSigAtomic #

unsafeShiftL :: CSigAtomic -> Int -> CSigAtomic #

shiftR :: CSigAtomic -> Int -> CSigAtomic #

unsafeShiftR :: CSigAtomic -> Int -> CSigAtomic #

rotateL :: CSigAtomic -> Int -> CSigAtomic #

rotateR :: CSigAtomic -> Int -> CSigAtomic #

popCount :: CSigAtomic -> Int #

FiniteBits CSigAtomic

Instance details

Methods

finiteBitSize :: CSigAtomic -> Int

countLeadingZeros :: CSigAtomic -> Int

countTrailingZeros :: CSigAtomic -> Int

Bounded CSigAtomic

Instance details

Methods

minBound :: CSigAtomic #

maxBound :: CSigAtomic #

Enum CSigAtomic

Instance details

Methods

succ :: CSigAtomic -> CSigAtomic #

pred :: CSigAtomic -> CSigAtomic #

toEnum :: Int -> CSigAtomic #

fromEnum :: CSigAtomic -> Int #

enumFrom :: CSigAtomic -> [CSigAtomic] #

enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] #

enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] #

enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] #

Storable CSigAtomic

Instance details

Methods

sizeOf :: CSigAtomic -> Int

alignment :: CSigAtomic -> Int

peekElemOff :: Ptr CSigAtomic -> Int -> IO CSigAtomic

pokeElemOff :: Ptr CSigAtomic -> Int -> CSigAtomic -> IO ()

peekByteOff :: Ptr b -> Int -> IO CSigAtomic

pokeByteOff :: Ptr b -> Int -> CSigAtomic -> IO ()

peek :: Ptr CSigAtomic -> IO CSigAtomic

poke :: Ptr CSigAtomic -> CSigAtomic -> IO ()

Ix CSigAtomic

Instance details

Methods

range :: (CSigAtomic, CSigAtomic) -> [CSigAtomic]

index :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Int

unsafeIndex :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Int

inRange :: (CSigAtomic, CSigAtomic) -> CSigAtomic -> Bool

rangeSize :: (CSigAtomic, CSigAtomic) -> Int

unsafeRangeSize :: (CSigAtomic, CSigAtomic) -> Int

Num CSigAtomic

Instance details

Methods

(+) :: CSigAtomic -> CSigAtomic -> CSigAtomic

(-) :: CSigAtomic -> CSigAtomic -> CSigAtomic

(*) :: CSigAtomic -> CSigAtomic -> CSigAtomic

negate :: CSigAtomic -> CSigAtomic

abs :: CSigAtomic -> CSigAtomic

signum :: CSigAtomic -> CSigAtomic

fromInteger :: Integer -> CSigAtomic

Read CSigAtomic

Instance details

Methods

readsPrec :: Int -> ReadS CSigAtomic

readList :: ReadS [CSigAtomic]

readPrec :: ReadPrec CSigAtomic

readListPrec :: ReadPrec [CSigAtomic]

Integral CSigAtomic

Instance details

Methods

quot :: CSigAtomic -> CSigAtomic -> CSigAtomic

rem :: CSigAtomic -> CSigAtomic -> CSigAtomic

div :: CSigAtomic -> CSigAtomic -> CSigAtomic

mod :: CSigAtomic -> CSigAtomic -> CSigAtomic

quotRem :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic)

divMod :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic)

toInteger :: CSigAtomic -> Integer

Real CSigAtomic

Instance details

Methods

toRational :: CSigAtomic -> Rational

Show CSigAtomic

Instance details

Methods

showsPrec :: Int -> CSigAtomic -> ShowS

show :: CSigAtomic -> String

showList :: [CSigAtomic] -> ShowS

Eq CSigAtomic

Instance details

Methods

(==) :: CSigAtomic -> CSigAtomic -> Bool #

(/=) :: CSigAtomic -> CSigAtomic -> Bool #

Ord CSigAtomic

Instance details

Methods

compare :: CSigAtomic -> CSigAtomic -> Ordering #

(<) :: CSigAtomic -> CSigAtomic -> Bool #

(<=) :: CSigAtomic -> CSigAtomic -> Bool #

(>) :: CSigAtomic -> CSigAtomic -> Bool #

(>=) :: CSigAtomic -> CSigAtomic -> Bool #

max :: CSigAtomic -> CSigAtomic -> CSigAtomic #

min :: CSigAtomic -> CSigAtomic -> CSigAtomic #

type Difference CSigAtomic

Instance details

type Difference CSigAtomic = CSigAtomic

newtype CTime #

Constructors

CTime Int32

Instances

Instances details

Integral CTime

Instance details

Methods

fromInteger :: Integer -> CTime #

Additive CTime

Instance details

Methods

azero :: CTime #

(+) :: CTime -> CTime -> CTime #

scale :: IsNatural n => n -> CTime -> CTime #

Multiplicative CTime

Instance details

Methods

midentity :: CTime #

(*) :: CTime -> CTime -> CTime #

(^) :: (IsNatural n, Enum n, IDivisible n) => CTime -> n -> CTime #

Subtractive CTime

Instance details

Associated Types

type Difference CTime
Instance details Defined in Basement.Numerical.Subtractive type Difference CTime = CTime

Methods

(-) :: CTime -> CTime -> Difference CTime #

Enum CTime

Instance details

Methods

succ :: CTime -> CTime #

pred :: CTime -> CTime #

toEnum :: Int -> CTime #

fromEnum :: CTime -> Int #

enumFrom :: CTime -> [CTime] #

enumFromThen :: CTime -> CTime -> [CTime] #

enumFromTo :: CTime -> CTime -> [CTime] #

enumFromThenTo :: CTime -> CTime -> CTime -> [CTime] #

Storable CTime

Instance details

Methods

sizeOf :: CTime -> Int

alignment :: CTime -> Int

peekElemOff :: Ptr CTime -> Int -> IO CTime

pokeElemOff :: Ptr CTime -> Int -> CTime -> IO ()

peekByteOff :: Ptr b -> Int -> IO CTime

pokeByteOff :: Ptr b -> Int -> CTime -> IO ()

peek :: Ptr CTime -> IO CTime

poke :: Ptr CTime -> CTime -> IO ()

Num CTime

Instance details

Methods

(+) :: CTime -> CTime -> CTime

(-) :: CTime -> CTime -> CTime

(*) :: CTime -> CTime -> CTime

negate :: CTime -> CTime

abs :: CTime -> CTime

signum :: CTime -> CTime

fromInteger :: Integer -> CTime

Read CTime

Instance details

Methods

readsPrec :: Int -> ReadS CTime

readList :: ReadS [CTime]

readPrec :: ReadPrec CTime

readListPrec :: ReadPrec [CTime]

Real CTime

Instance details

Methods

toRational :: CTime -> Rational

Show CTime

Instance details

Methods

showsPrec :: Int -> CTime -> ShowS

show :: CTime -> String

showList :: [CTime] -> ShowS

Eq CTime

Instance details

Methods

(==) :: CTime -> CTime -> Bool #

(/=) :: CTime -> CTime -> Bool #

Ord CTime

Instance details

Methods

compare :: CTime -> CTime -> Ordering #

(<) :: CTime -> CTime -> Bool #

(<=) :: CTime -> CTime -> Bool #

(>) :: CTime -> CTime -> Bool #

(>=) :: CTime -> CTime -> Bool #

max :: CTime -> CTime -> CTime #

min :: CTime -> CTime -> CTime #

type Difference CTime

Instance details

type Difference CTime = CTime

newtype CUInt #

Constructors

CUInt Word32

Instances

Instances details

Integral CUInt

Instance details

Methods

fromInteger :: Integer -> CUInt #

NormalForm CUInt

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CUInt -> () #

Additive CUInt

Instance details

Methods

azero :: CUInt #

(+) :: CUInt -> CUInt -> CUInt #

scale :: IsNatural n => n -> CUInt -> CUInt #

IDivisible CUInt

Instance details

Methods

div :: CUInt -> CUInt -> CUInt #

mod :: CUInt -> CUInt -> CUInt #

divMod :: CUInt -> CUInt -> (CUInt, CUInt) #

Multiplicative CUInt

Instance details

Methods

midentity :: CUInt #

(*) :: CUInt -> CUInt -> CUInt #

(^) :: (IsNatural n, Enum n, IDivisible n) => CUInt -> n -> CUInt #

IsIntegral CUInt

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CUInt -> Integer #

IsNatural CUInt

Instance details

Defined in Basement.Numerical.Number

Methods

toNatural :: CUInt -> Natural #

Subtractive CUInt

Instance details

Associated Types

type Difference CUInt
Instance details Defined in Basement.Numerical.Subtractive type Difference CUInt = CUInt

Methods

(-) :: CUInt -> CUInt -> Difference CUInt #

Bits CUInt

Instance details

Methods

(.&.) :: CUInt -> CUInt -> CUInt #

(.|.) :: CUInt -> CUInt -> CUInt #

xor :: CUInt -> CUInt -> CUInt #

complement :: CUInt -> CUInt #

shift :: CUInt -> Int -> CUInt #

rotate :: CUInt -> Int -> CUInt #

zeroBits :: CUInt #

bit :: Int -> CUInt #

setBit :: CUInt -> Int -> CUInt #

clearBit :: CUInt -> Int -> CUInt #

complementBit :: CUInt -> Int -> CUInt #

testBit :: CUInt -> Int -> Bool #

bitSizeMaybe :: CUInt -> Maybe Int #

bitSize :: CUInt -> Int #

isSigned :: CUInt -> Bool #

shiftL :: CUInt -> Int -> CUInt #

unsafeShiftL :: CUInt -> Int -> CUInt #

shiftR :: CUInt -> Int -> CUInt #

unsafeShiftR :: CUInt -> Int -> CUInt #

rotateL :: CUInt -> Int -> CUInt #

rotateR :: CUInt -> Int -> CUInt #

popCount :: CUInt -> Int #

FiniteBits CUInt

Instance details

Methods

finiteBitSize :: CUInt -> Int

countLeadingZeros :: CUInt -> Int

countTrailingZeros :: CUInt -> Int

Bounded CUInt

Instance details

Methods

minBound :: CUInt #

maxBound :: CUInt #

Enum CUInt

Instance details

Methods

succ :: CUInt -> CUInt #

pred :: CUInt -> CUInt #

toEnum :: Int -> CUInt #

fromEnum :: CUInt -> Int #

enumFrom :: CUInt -> [CUInt] #

enumFromThen :: CUInt -> CUInt -> [CUInt] #

enumFromTo :: CUInt -> CUInt -> [CUInt] #

enumFromThenTo :: CUInt -> CUInt -> CUInt -> [CUInt] #

Storable CUInt

Instance details

Methods

sizeOf :: CUInt -> Int

alignment :: CUInt -> Int

peekElemOff :: Ptr CUInt -> Int -> IO CUInt

pokeElemOff :: Ptr CUInt -> Int -> CUInt -> IO ()

peekByteOff :: Ptr b -> Int -> IO CUInt

pokeByteOff :: Ptr b -> Int -> CUInt -> IO ()

peek :: Ptr CUInt -> IO CUInt

poke :: Ptr CUInt -> CUInt -> IO ()

Ix CUInt

Instance details

Methods

range :: (CUInt, CUInt) -> [CUInt]

index :: (CUInt, CUInt) -> CUInt -> Int

unsafeIndex :: (CUInt, CUInt) -> CUInt -> Int

inRange :: (CUInt, CUInt) -> CUInt -> Bool

rangeSize :: (CUInt, CUInt) -> Int

unsafeRangeSize :: (CUInt, CUInt) -> Int

Num CUInt

Instance details

Methods

(+) :: CUInt -> CUInt -> CUInt

(-) :: CUInt -> CUInt -> CUInt

(*) :: CUInt -> CUInt -> CUInt

negate :: CUInt -> CUInt

abs :: CUInt -> CUInt

signum :: CUInt -> CUInt

fromInteger :: Integer -> CUInt

Read CUInt

Instance details

Methods

readsPrec :: Int -> ReadS CUInt

readList :: ReadS [CUInt]

readPrec :: ReadPrec CUInt

readListPrec :: ReadPrec [CUInt]

Integral CUInt

Instance details

Methods

quot :: CUInt -> CUInt -> CUInt

rem :: CUInt -> CUInt -> CUInt

div :: CUInt -> CUInt -> CUInt

mod :: CUInt -> CUInt -> CUInt

quotRem :: CUInt -> CUInt -> (CUInt, CUInt)

divMod :: CUInt -> CUInt -> (CUInt, CUInt)

toInteger :: CUInt -> Integer

Real CUInt

Instance details

Methods

toRational :: CUInt -> Rational

Show CUInt

Instance details

Methods

showsPrec :: Int -> CUInt -> ShowS

show :: CUInt -> String

showList :: [CUInt] -> ShowS

Eq CUInt

Instance details

Methods

(==) :: CUInt -> CUInt -> Bool #

(/=) :: CUInt -> CUInt -> Bool #

Ord CUInt

Instance details

Methods

compare :: CUInt -> CUInt -> Ordering #

(<) :: CUInt -> CUInt -> Bool #

(<=) :: CUInt -> CUInt -> Bool #

(>) :: CUInt -> CUInt -> Bool #

(>=) :: CUInt -> CUInt -> Bool #

max :: CUInt -> CUInt -> CUInt #

min :: CUInt -> CUInt -> CUInt #

type Difference CUInt

Instance details

type Difference CUInt = CUInt

newtype CUIntMax #

Constructors

CUIntMax Word64

Instances

Instances details

Integral CUIntMax

Instance details

Methods

fromInteger :: Integer -> CUIntMax #

Additive CUIntMax

Instance details

Methods

azero :: CUIntMax #

(+) :: CUIntMax -> CUIntMax -> CUIntMax #

scale :: IsNatural n => n -> CUIntMax -> CUIntMax #

IDivisible CUIntMax

Instance details

Methods

div :: CUIntMax -> CUIntMax -> CUIntMax #

mod :: CUIntMax -> CUIntMax -> CUIntMax #

divMod :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax) #

Multiplicative CUIntMax

Instance details

Methods

midentity :: CUIntMax #

(*) :: CUIntMax -> CUIntMax -> CUIntMax #

(^) :: (IsNatural n, Enum n, IDivisible n) => CUIntMax -> n -> CUIntMax #

IsIntegral CUIntMax

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CUIntMax -> Integer #

IsNatural CUIntMax

Instance details

Defined in Basement.Numerical.Number

Methods

toNatural :: CUIntMax -> Natural #

Subtractive CUIntMax

Instance details

Associated Types

type Difference CUIntMax
Instance details Defined in Basement.Numerical.Subtractive type Difference CUIntMax = CUIntMax

Methods

(-) :: CUIntMax -> CUIntMax -> Difference CUIntMax #

Bits CUIntMax

Instance details

Methods

(.&.) :: CUIntMax -> CUIntMax -> CUIntMax #

(.|.) :: CUIntMax -> CUIntMax -> CUIntMax #

xor :: CUIntMax -> CUIntMax -> CUIntMax #

complement :: CUIntMax -> CUIntMax #

shift :: CUIntMax -> Int -> CUIntMax #

rotate :: CUIntMax -> Int -> CUIntMax #

zeroBits :: CUIntMax #

bit :: Int -> CUIntMax #

setBit :: CUIntMax -> Int -> CUIntMax #

clearBit :: CUIntMax -> Int -> CUIntMax #

complementBit :: CUIntMax -> Int -> CUIntMax #

testBit :: CUIntMax -> Int -> Bool #

bitSizeMaybe :: CUIntMax -> Maybe Int #

bitSize :: CUIntMax -> Int #

isSigned :: CUIntMax -> Bool #

shiftL :: CUIntMax -> Int -> CUIntMax #

unsafeShiftL :: CUIntMax -> Int -> CUIntMax #

shiftR :: CUIntMax -> Int -> CUIntMax #

unsafeShiftR :: CUIntMax -> Int -> CUIntMax #

rotateL :: CUIntMax -> Int -> CUIntMax #

rotateR :: CUIntMax -> Int -> CUIntMax #

popCount :: CUIntMax -> Int #

FiniteBits CUIntMax

Instance details

Methods

finiteBitSize :: CUIntMax -> Int

countLeadingZeros :: CUIntMax -> Int

countTrailingZeros :: CUIntMax -> Int

Bounded CUIntMax

Instance details

Methods

minBound :: CUIntMax #

maxBound :: CUIntMax #

Enum CUIntMax

Instance details

Methods

succ :: CUIntMax -> CUIntMax #

pred :: CUIntMax -> CUIntMax #

toEnum :: Int -> CUIntMax #

fromEnum :: CUIntMax -> Int #

enumFrom :: CUIntMax -> [CUIntMax] #

enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] #

enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] #

enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] #

Storable CUIntMax

Instance details

Methods

sizeOf :: CUIntMax -> Int

alignment :: CUIntMax -> Int

peekElemOff :: Ptr CUIntMax -> Int -> IO CUIntMax

pokeElemOff :: Ptr CUIntMax -> Int -> CUIntMax -> IO ()

peekByteOff :: Ptr b -> Int -> IO CUIntMax

pokeByteOff :: Ptr b -> Int -> CUIntMax -> IO ()

peek :: Ptr CUIntMax -> IO CUIntMax

poke :: Ptr CUIntMax -> CUIntMax -> IO ()

Ix CUIntMax

Instance details

Methods

range :: (CUIntMax, CUIntMax) -> [CUIntMax]

index :: (CUIntMax, CUIntMax) -> CUIntMax -> Int

unsafeIndex :: (CUIntMax, CUIntMax) -> CUIntMax -> Int

inRange :: (CUIntMax, CUIntMax) -> CUIntMax -> Bool

rangeSize :: (CUIntMax, CUIntMax) -> Int

unsafeRangeSize :: (CUIntMax, CUIntMax) -> Int

Num CUIntMax

Instance details

Methods

(+) :: CUIntMax -> CUIntMax -> CUIntMax

(-) :: CUIntMax -> CUIntMax -> CUIntMax

(*) :: CUIntMax -> CUIntMax -> CUIntMax

negate :: CUIntMax -> CUIntMax

abs :: CUIntMax -> CUIntMax

signum :: CUIntMax -> CUIntMax

fromInteger :: Integer -> CUIntMax

Read CUIntMax

Instance details

Methods

readsPrec :: Int -> ReadS CUIntMax

readList :: ReadS [CUIntMax]

readPrec :: ReadPrec CUIntMax

readListPrec :: ReadPrec [CUIntMax]

Integral CUIntMax

Instance details

Methods

quot :: CUIntMax -> CUIntMax -> CUIntMax

rem :: CUIntMax -> CUIntMax -> CUIntMax

div :: CUIntMax -> CUIntMax -> CUIntMax

mod :: CUIntMax -> CUIntMax -> CUIntMax

quotRem :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax)

divMod :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax)

toInteger :: CUIntMax -> Integer

Real CUIntMax

Instance details

Methods

toRational :: CUIntMax -> Rational

Show CUIntMax

Instance details

Methods

showsPrec :: Int -> CUIntMax -> ShowS

show :: CUIntMax -> String

showList :: [CUIntMax] -> ShowS

Eq CUIntMax

Instance details

Methods

(==) :: CUIntMax -> CUIntMax -> Bool #

(/=) :: CUIntMax -> CUIntMax -> Bool #

Ord CUIntMax

Instance details

Methods

compare :: CUIntMax -> CUIntMax -> Ordering #

(<) :: CUIntMax -> CUIntMax -> Bool #

(<=) :: CUIntMax -> CUIntMax -> Bool #

(>) :: CUIntMax -> CUIntMax -> Bool #

(>=) :: CUIntMax -> CUIntMax -> Bool #

max :: CUIntMax -> CUIntMax -> CUIntMax #

min :: CUIntMax -> CUIntMax -> CUIntMax #

type Difference CUIntMax

Instance details

type Difference CUIntMax = CUIntMax

newtype CUIntPtr #

Constructors

CUIntPtr Word32

Instances

Instances details

Integral CUIntPtr

Instance details

Methods

fromInteger :: Integer -> CUIntPtr #

Additive CUIntPtr

Instance details

Methods

azero :: CUIntPtr #

(+) :: CUIntPtr -> CUIntPtr -> CUIntPtr #

scale :: IsNatural n => n -> CUIntPtr -> CUIntPtr #

IDivisible CUIntPtr

Instance details

Methods

div :: CUIntPtr -> CUIntPtr -> CUIntPtr #

mod :: CUIntPtr -> CUIntPtr -> CUIntPtr #

divMod :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr) #

Multiplicative CUIntPtr

Instance details

Methods

midentity :: CUIntPtr #

(*) :: CUIntPtr -> CUIntPtr -> CUIntPtr #

(^) :: (IsNatural n, Enum n, IDivisible n) => CUIntPtr -> n -> CUIntPtr #

IsIntegral CUIntPtr

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CUIntPtr -> Integer #

IsNatural CUIntPtr

Instance details

Defined in Basement.Numerical.Number

Methods

toNatural :: CUIntPtr -> Natural #

Subtractive CUIntPtr

Instance details

Associated Types

type Difference CUIntPtr
Instance details Defined in Basement.Numerical.Subtractive type Difference CUIntPtr = CUIntPtr

Methods

(-) :: CUIntPtr -> CUIntPtr -> Difference CUIntPtr #

Bits CUIntPtr

Instance details

Methods

(.&.) :: CUIntPtr -> CUIntPtr -> CUIntPtr #

(.|.) :: CUIntPtr -> CUIntPtr -> CUIntPtr #

xor :: CUIntPtr -> CUIntPtr -> CUIntPtr #

complement :: CUIntPtr -> CUIntPtr #

shift :: CUIntPtr -> Int -> CUIntPtr #

rotate :: CUIntPtr -> Int -> CUIntPtr #

zeroBits :: CUIntPtr #

bit :: Int -> CUIntPtr #

setBit :: CUIntPtr -> Int -> CUIntPtr #

clearBit :: CUIntPtr -> Int -> CUIntPtr #

complementBit :: CUIntPtr -> Int -> CUIntPtr #

testBit :: CUIntPtr -> Int -> Bool #

bitSizeMaybe :: CUIntPtr -> Maybe Int #

bitSize :: CUIntPtr -> Int #

isSigned :: CUIntPtr -> Bool #

shiftL :: CUIntPtr -> Int -> CUIntPtr #

unsafeShiftL :: CUIntPtr -> Int -> CUIntPtr #

shiftR :: CUIntPtr -> Int -> CUIntPtr #

unsafeShiftR :: CUIntPtr -> Int -> CUIntPtr #

rotateL :: CUIntPtr -> Int -> CUIntPtr #

rotateR :: CUIntPtr -> Int -> CUIntPtr #

popCount :: CUIntPtr -> Int #

FiniteBits CUIntPtr

Instance details

Methods

finiteBitSize :: CUIntPtr -> Int

countLeadingZeros :: CUIntPtr -> Int

countTrailingZeros :: CUIntPtr -> Int

Bounded CUIntPtr

Instance details

Methods

minBound :: CUIntPtr #

maxBound :: CUIntPtr #

Enum CUIntPtr

Instance details

Methods

succ :: CUIntPtr -> CUIntPtr #

pred :: CUIntPtr -> CUIntPtr #

toEnum :: Int -> CUIntPtr #

fromEnum :: CUIntPtr -> Int #

enumFrom :: CUIntPtr -> [CUIntPtr] #

enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] #

enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] #

enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] #

Storable CUIntPtr

Instance details

Methods

sizeOf :: CUIntPtr -> Int

alignment :: CUIntPtr -> Int

peekElemOff :: Ptr CUIntPtr -> Int -> IO CUIntPtr

pokeElemOff :: Ptr CUIntPtr -> Int -> CUIntPtr -> IO ()

peekByteOff :: Ptr b -> Int -> IO CUIntPtr

pokeByteOff :: Ptr b -> Int -> CUIntPtr -> IO ()

peek :: Ptr CUIntPtr -> IO CUIntPtr

poke :: Ptr CUIntPtr -> CUIntPtr -> IO ()

Ix CUIntPtr

Instance details

Methods

range :: (CUIntPtr, CUIntPtr) -> [CUIntPtr]

index :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Int

unsafeIndex :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Int

inRange :: (CUIntPtr, CUIntPtr) -> CUIntPtr -> Bool

rangeSize :: (CUIntPtr, CUIntPtr) -> Int

unsafeRangeSize :: (CUIntPtr, CUIntPtr) -> Int

Num CUIntPtr

Instance details

Methods

(+) :: CUIntPtr -> CUIntPtr -> CUIntPtr

(-) :: CUIntPtr -> CUIntPtr -> CUIntPtr

(*) :: CUIntPtr -> CUIntPtr -> CUIntPtr

negate :: CUIntPtr -> CUIntPtr

abs :: CUIntPtr -> CUIntPtr

signum :: CUIntPtr -> CUIntPtr

fromInteger :: Integer -> CUIntPtr

Read CUIntPtr

Instance details

Methods

readsPrec :: Int -> ReadS CUIntPtr

readList :: ReadS [CUIntPtr]

readPrec :: ReadPrec CUIntPtr

readListPrec :: ReadPrec [CUIntPtr]

Integral CUIntPtr

Instance details

Methods

quot :: CUIntPtr -> CUIntPtr -> CUIntPtr

rem :: CUIntPtr -> CUIntPtr -> CUIntPtr

div :: CUIntPtr -> CUIntPtr -> CUIntPtr

mod :: CUIntPtr -> CUIntPtr -> CUIntPtr

quotRem :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr)

divMod :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr)

toInteger :: CUIntPtr -> Integer

Real CUIntPtr

Instance details

Methods

toRational :: CUIntPtr -> Rational

Show CUIntPtr

Instance details

Methods

showsPrec :: Int -> CUIntPtr -> ShowS

show :: CUIntPtr -> String

showList :: [CUIntPtr] -> ShowS

Eq CUIntPtr

Instance details

Methods

(==) :: CUIntPtr -> CUIntPtr -> Bool #

(/=) :: CUIntPtr -> CUIntPtr -> Bool #

Ord CUIntPtr

Instance details

Methods

compare :: CUIntPtr -> CUIntPtr -> Ordering #

(<) :: CUIntPtr -> CUIntPtr -> Bool #

(<=) :: CUIntPtr -> CUIntPtr -> Bool #

(>) :: CUIntPtr -> CUIntPtr -> Bool #

(>=) :: CUIntPtr -> CUIntPtr -> Bool #

max :: CUIntPtr -> CUIntPtr -> CUIntPtr #

min :: CUIntPtr -> CUIntPtr -> CUIntPtr #

type Difference CUIntPtr

Instance details

type Difference CUIntPtr = CUIntPtr

newtype CULLong #

Constructors

CULLong Word64

Instances

Instances details

Integral CULLong

Instance details

Methods

fromInteger :: Integer -> CULLong #

NormalForm CULLong

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CULLong -> () #

Additive CULLong

Instance details

Methods

azero :: CULLong #

(+) :: CULLong -> CULLong -> CULLong #

scale :: IsNatural n => n -> CULLong -> CULLong #

IDivisible CULLong

Instance details

Methods

div :: CULLong -> CULLong -> CULLong #

mod :: CULLong -> CULLong -> CULLong #

divMod :: CULLong -> CULLong -> (CULLong, CULLong) #

Multiplicative CULLong

Instance details

Methods

midentity :: CULLong #

(*) :: CULLong -> CULLong -> CULLong #

(^) :: (IsNatural n, Enum n, IDivisible n) => CULLong -> n -> CULLong #

IsIntegral CULLong

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CULLong -> Integer #

IsNatural CULLong

Instance details

Defined in Basement.Numerical.Number

Methods

toNatural :: CULLong -> Natural #

Subtractive CULLong

Instance details

Associated Types

type Difference CULLong
Instance details Defined in Basement.Numerical.Subtractive type Difference CULLong = CULLong

Methods

(-) :: CULLong -> CULLong -> Difference CULLong #

Bits CULLong

Instance details

Methods

(.&.) :: CULLong -> CULLong -> CULLong #

(.|.) :: CULLong -> CULLong -> CULLong #

xor :: CULLong -> CULLong -> CULLong #

complement :: CULLong -> CULLong #

shift :: CULLong -> Int -> CULLong #

rotate :: CULLong -> Int -> CULLong #

zeroBits :: CULLong #

bit :: Int -> CULLong #

setBit :: CULLong -> Int -> CULLong #

clearBit :: CULLong -> Int -> CULLong #

complementBit :: CULLong -> Int -> CULLong #

testBit :: CULLong -> Int -> Bool #

bitSizeMaybe :: CULLong -> Maybe Int #

bitSize :: CULLong -> Int #

isSigned :: CULLong -> Bool #

shiftL :: CULLong -> Int -> CULLong #

unsafeShiftL :: CULLong -> Int -> CULLong #

shiftR :: CULLong -> Int -> CULLong #

unsafeShiftR :: CULLong -> Int -> CULLong #

rotateL :: CULLong -> Int -> CULLong #

rotateR :: CULLong -> Int -> CULLong #

popCount :: CULLong -> Int #

FiniteBits CULLong

Instance details

Methods

finiteBitSize :: CULLong -> Int

countLeadingZeros :: CULLong -> Int

countTrailingZeros :: CULLong -> Int

Bounded CULLong

Instance details

Methods

minBound :: CULLong #

maxBound :: CULLong #

Enum CULLong

Instance details

Methods

succ :: CULLong -> CULLong #

pred :: CULLong -> CULLong #

toEnum :: Int -> CULLong #

fromEnum :: CULLong -> Int #

enumFrom :: CULLong -> [CULLong] #

enumFromThen :: CULLong -> CULLong -> [CULLong] #

enumFromTo :: CULLong -> CULLong -> [CULLong] #

enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] #

Storable CULLong

Instance details

Methods

sizeOf :: CULLong -> Int

alignment :: CULLong -> Int

peekElemOff :: Ptr CULLong -> Int -> IO CULLong

pokeElemOff :: Ptr CULLong -> Int -> CULLong -> IO ()

peekByteOff :: Ptr b -> Int -> IO CULLong

pokeByteOff :: Ptr b -> Int -> CULLong -> IO ()

peek :: Ptr CULLong -> IO CULLong

poke :: Ptr CULLong -> CULLong -> IO ()

Ix CULLong

Instance details

Methods

range :: (CULLong, CULLong) -> [CULLong]

index :: (CULLong, CULLong) -> CULLong -> Int

unsafeIndex :: (CULLong, CULLong) -> CULLong -> Int

inRange :: (CULLong, CULLong) -> CULLong -> Bool

rangeSize :: (CULLong, CULLong) -> Int

unsafeRangeSize :: (CULLong, CULLong) -> Int

Num CULLong

Instance details

Methods

(+) :: CULLong -> CULLong -> CULLong

(-) :: CULLong -> CULLong -> CULLong

(*) :: CULLong -> CULLong -> CULLong

negate :: CULLong -> CULLong

abs :: CULLong -> CULLong

signum :: CULLong -> CULLong

fromInteger :: Integer -> CULLong

Read CULLong

Instance details

Methods

readsPrec :: Int -> ReadS CULLong

readList :: ReadS [CULLong]

readPrec :: ReadPrec CULLong

readListPrec :: ReadPrec [CULLong]

Integral CULLong

Instance details

Methods

quot :: CULLong -> CULLong -> CULLong

rem :: CULLong -> CULLong -> CULLong

div :: CULLong -> CULLong -> CULLong

mod :: CULLong -> CULLong -> CULLong

quotRem :: CULLong -> CULLong -> (CULLong, CULLong)

divMod :: CULLong -> CULLong -> (CULLong, CULLong)

toInteger :: CULLong -> Integer

Real CULLong

Instance details

Methods

toRational :: CULLong -> Rational

Show CULLong

Instance details

Methods

showsPrec :: Int -> CULLong -> ShowS

show :: CULLong -> String

showList :: [CULLong] -> ShowS

Eq CULLong

Instance details

Methods

(==) :: CULLong -> CULLong -> Bool #

(/=) :: CULLong -> CULLong -> Bool #

Ord CULLong

Instance details

Methods

compare :: CULLong -> CULLong -> Ordering #

(<) :: CULLong -> CULLong -> Bool #

(<=) :: CULLong -> CULLong -> Bool #

(>) :: CULLong -> CULLong -> Bool #

(>=) :: CULLong -> CULLong -> Bool #

max :: CULLong -> CULLong -> CULLong #

min :: CULLong -> CULLong -> CULLong #

type Difference CULLong

Instance details

type Difference CULLong = CULLong

newtype CULong #

Constructors

CULong Word32

Instances

Instances details

Integral CULong

Instance details

Methods

fromInteger :: Integer -> CULong #

NormalForm CULong

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CULong -> () #

Additive CULong

Instance details

Methods

azero :: CULong #

(+) :: CULong -> CULong -> CULong #

scale :: IsNatural n => n -> CULong -> CULong #

IDivisible CULong

Instance details

Methods

div :: CULong -> CULong -> CULong #

mod :: CULong -> CULong -> CULong #

divMod :: CULong -> CULong -> (CULong, CULong) #

Multiplicative CULong

Instance details

Methods

midentity :: CULong #

(*) :: CULong -> CULong -> CULong #

(^) :: (IsNatural n, Enum n, IDivisible n) => CULong -> n -> CULong #

IsIntegral CULong

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CULong -> Integer #

IsNatural CULong

Instance details

Defined in Basement.Numerical.Number

Methods

toNatural :: CULong -> Natural #

Subtractive CULong

Instance details

Associated Types

type Difference CULong
Instance details Defined in Basement.Numerical.Subtractive type Difference CULong = CULong

Methods

(-) :: CULong -> CULong -> Difference CULong #

Bits CULong

Instance details

Methods

(.&.) :: CULong -> CULong -> CULong #

(.|.) :: CULong -> CULong -> CULong #

xor :: CULong -> CULong -> CULong #

complement :: CULong -> CULong #

shift :: CULong -> Int -> CULong #

rotate :: CULong -> Int -> CULong #

zeroBits :: CULong #

bit :: Int -> CULong #

setBit :: CULong -> Int -> CULong #

clearBit :: CULong -> Int -> CULong #

complementBit :: CULong -> Int -> CULong #

testBit :: CULong -> Int -> Bool #

bitSizeMaybe :: CULong -> Maybe Int #

bitSize :: CULong -> Int #

isSigned :: CULong -> Bool #

shiftL :: CULong -> Int -> CULong #

unsafeShiftL :: CULong -> Int -> CULong #

shiftR :: CULong -> Int -> CULong #

unsafeShiftR :: CULong -> Int -> CULong #

rotateL :: CULong -> Int -> CULong #

rotateR :: CULong -> Int -> CULong #

popCount :: CULong -> Int #

FiniteBits CULong

Instance details

Methods

finiteBitSize :: CULong -> Int

countLeadingZeros :: CULong -> Int

countTrailingZeros :: CULong -> Int

Bounded CULong

Instance details

Methods

minBound :: CULong #

maxBound :: CULong #

Enum CULong

Instance details

Methods

succ :: CULong -> CULong #

pred :: CULong -> CULong #

toEnum :: Int -> CULong #

fromEnum :: CULong -> Int #

enumFrom :: CULong -> [CULong] #

enumFromThen :: CULong -> CULong -> [CULong] #

enumFromTo :: CULong -> CULong -> [CULong] #

enumFromThenTo :: CULong -> CULong -> CULong -> [CULong] #

Storable CULong

Instance details

Methods

sizeOf :: CULong -> Int

alignment :: CULong -> Int

peekElemOff :: Ptr CULong -> Int -> IO CULong

pokeElemOff :: Ptr CULong -> Int -> CULong -> IO ()

peekByteOff :: Ptr b -> Int -> IO CULong

pokeByteOff :: Ptr b -> Int -> CULong -> IO ()

peek :: Ptr CULong -> IO CULong

poke :: Ptr CULong -> CULong -> IO ()

Ix CULong

Instance details

Methods

range :: (CULong, CULong) -> [CULong]

index :: (CULong, CULong) -> CULong -> Int

unsafeIndex :: (CULong, CULong) -> CULong -> Int

inRange :: (CULong, CULong) -> CULong -> Bool

rangeSize :: (CULong, CULong) -> Int

unsafeRangeSize :: (CULong, CULong) -> Int

Num CULong

Instance details

Methods

(+) :: CULong -> CULong -> CULong

(-) :: CULong -> CULong -> CULong

(*) :: CULong -> CULong -> CULong

negate :: CULong -> CULong

abs :: CULong -> CULong

signum :: CULong -> CULong

fromInteger :: Integer -> CULong

Read CULong

Instance details

Methods

readsPrec :: Int -> ReadS CULong

readList :: ReadS [CULong]

readPrec :: ReadPrec CULong

readListPrec :: ReadPrec [CULong]

Integral CULong

Instance details

Methods

quot :: CULong -> CULong -> CULong

rem :: CULong -> CULong -> CULong

div :: CULong -> CULong -> CULong

mod :: CULong -> CULong -> CULong

quotRem :: CULong -> CULong -> (CULong, CULong)

divMod :: CULong -> CULong -> (CULong, CULong)

toInteger :: CULong -> Integer

Real CULong

Instance details

Methods

toRational :: CULong -> Rational

Show CULong

Instance details

Methods

showsPrec :: Int -> CULong -> ShowS

show :: CULong -> String

showList :: [CULong] -> ShowS

Eq CULong

Instance details

Methods

(==) :: CULong -> CULong -> Bool #

(/=) :: CULong -> CULong -> Bool #

Ord CULong

Instance details

Methods

compare :: CULong -> CULong -> Ordering #

(<) :: CULong -> CULong -> Bool #

(<=) :: CULong -> CULong -> Bool #

(>) :: CULong -> CULong -> Bool #

(>=) :: CULong -> CULong -> Bool #

max :: CULong -> CULong -> CULong #

min :: CULong -> CULong -> CULong #

type Difference CULong

Instance details

type Difference CULong = CULong

newtype CUSeconds #

Constructors

CUSeconds Word32

Instances

Instances details

Integral CUSeconds

Instance details

Methods

fromInteger :: Integer -> CUSeconds #

Additive CUSeconds

Instance details

Methods

azero :: CUSeconds #

(+) :: CUSeconds -> CUSeconds -> CUSeconds #

scale :: IsNatural n => n -> CUSeconds -> CUSeconds #

Multiplicative CUSeconds

Instance details

Methods

midentity :: CUSeconds #

(*) :: CUSeconds -> CUSeconds -> CUSeconds #

(^) :: (IsNatural n, Enum n, IDivisible n) => CUSeconds -> n -> CUSeconds #

Subtractive CUSeconds

Instance details

Associated Types

type Difference CUSeconds
Instance details Defined in Basement.Numerical.Subtractive type Difference CUSeconds = CUSeconds

Methods

(-) :: CUSeconds -> CUSeconds -> Difference CUSeconds #

Enum CUSeconds

Instance details

Methods

succ :: CUSeconds -> CUSeconds #

pred :: CUSeconds -> CUSeconds #

toEnum :: Int -> CUSeconds #

fromEnum :: CUSeconds -> Int #

enumFrom :: CUSeconds -> [CUSeconds] #

enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] #

enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] #

enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] #

Storable CUSeconds

Instance details

Methods

sizeOf :: CUSeconds -> Int

alignment :: CUSeconds -> Int

peekElemOff :: Ptr CUSeconds -> Int -> IO CUSeconds

pokeElemOff :: Ptr CUSeconds -> Int -> CUSeconds -> IO ()

peekByteOff :: Ptr b -> Int -> IO CUSeconds

pokeByteOff :: Ptr b -> Int -> CUSeconds -> IO ()

peek :: Ptr CUSeconds -> IO CUSeconds

poke :: Ptr CUSeconds -> CUSeconds -> IO ()

Num CUSeconds

Instance details

Methods

(+) :: CUSeconds -> CUSeconds -> CUSeconds

(-) :: CUSeconds -> CUSeconds -> CUSeconds

(*) :: CUSeconds -> CUSeconds -> CUSeconds

negate :: CUSeconds -> CUSeconds

abs :: CUSeconds -> CUSeconds

signum :: CUSeconds -> CUSeconds

fromInteger :: Integer -> CUSeconds

Read CUSeconds

Instance details

Methods

readsPrec :: Int -> ReadS CUSeconds

readList :: ReadS [CUSeconds]

readPrec :: ReadPrec CUSeconds

readListPrec :: ReadPrec [CUSeconds]

Real CUSeconds

Instance details

Methods

toRational :: CUSeconds -> Rational

Show CUSeconds

Instance details

Methods

showsPrec :: Int -> CUSeconds -> ShowS

show :: CUSeconds -> String

showList :: [CUSeconds] -> ShowS

Eq CUSeconds

Instance details

Methods

(==) :: CUSeconds -> CUSeconds -> Bool #

(/=) :: CUSeconds -> CUSeconds -> Bool #

Ord CUSeconds

Instance details

Methods

compare :: CUSeconds -> CUSeconds -> Ordering #

(<) :: CUSeconds -> CUSeconds -> Bool #

(<=) :: CUSeconds -> CUSeconds -> Bool #

(>) :: CUSeconds -> CUSeconds -> Bool #

(>=) :: CUSeconds -> CUSeconds -> Bool #

max :: CUSeconds -> CUSeconds -> CUSeconds #

min :: CUSeconds -> CUSeconds -> CUSeconds #

type Difference CUSeconds

Instance details

type Difference CUSeconds = CUSeconds

newtype CUShort #

Constructors

CUShort Word16

Instances

Instances details

Integral CUShort

Instance details

Methods

fromInteger :: Integer -> CUShort #

NormalForm CUShort

Instance details

Defined in Basement.NormalForm

Methods

toNormalForm :: CUShort -> () #

Additive CUShort

Instance details

Methods

azero :: CUShort #

(+) :: CUShort -> CUShort -> CUShort #

scale :: IsNatural n => n -> CUShort -> CUShort #

IDivisible CUShort

Instance details

Methods

div :: CUShort -> CUShort -> CUShort #

mod :: CUShort -> CUShort -> CUShort #

divMod :: CUShort -> CUShort -> (CUShort, CUShort) #

Multiplicative CUShort

Instance details

Methods

midentity :: CUShort #

(*) :: CUShort -> CUShort -> CUShort #

(^) :: (IsNatural n, Enum n, IDivisible n) => CUShort -> n -> CUShort #

IsIntegral CUShort

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CUShort -> Integer #

IsNatural CUShort

Instance details

Defined in Basement.Numerical.Number

Methods

toNatural :: CUShort -> Natural #

Subtractive CUShort

Instance details

Associated Types

type Difference CUShort
Instance details Defined in Basement.Numerical.Subtractive type Difference CUShort = CUShort

Methods

(-) :: CUShort -> CUShort -> Difference CUShort #

Bits CUShort

Instance details

Methods

(.&.) :: CUShort -> CUShort -> CUShort #

(.|.) :: CUShort -> CUShort -> CUShort #

xor :: CUShort -> CUShort -> CUShort #

complement :: CUShort -> CUShort #

shift :: CUShort -> Int -> CUShort #

rotate :: CUShort -> Int -> CUShort #

zeroBits :: CUShort #

bit :: Int -> CUShort #

setBit :: CUShort -> Int -> CUShort #

clearBit :: CUShort -> Int -> CUShort #

complementBit :: CUShort -> Int -> CUShort #

testBit :: CUShort -> Int -> Bool #

bitSizeMaybe :: CUShort -> Maybe Int #

bitSize :: CUShort -> Int #

isSigned :: CUShort -> Bool #

shiftL :: CUShort -> Int -> CUShort #

unsafeShiftL :: CUShort -> Int -> CUShort #

shiftR :: CUShort -> Int -> CUShort #

unsafeShiftR :: CUShort -> Int -> CUShort #

rotateL :: CUShort -> Int -> CUShort #

rotateR :: CUShort -> Int -> CUShort #

popCount :: CUShort -> Int #

FiniteBits CUShort

Instance details

Methods

finiteBitSize :: CUShort -> Int

countLeadingZeros :: CUShort -> Int

countTrailingZeros :: CUShort -> Int

Bounded CUShort

Instance details

Methods

minBound :: CUShort #

maxBound :: CUShort #

Enum CUShort

Instance details

Methods

succ :: CUShort -> CUShort #

pred :: CUShort -> CUShort #

toEnum :: Int -> CUShort #

fromEnum :: CUShort -> Int #

enumFrom :: CUShort -> [CUShort] #

enumFromThen :: CUShort -> CUShort -> [CUShort] #

enumFromTo :: CUShort -> CUShort -> [CUShort] #

enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] #

Storable CUShort

Instance details

Methods

sizeOf :: CUShort -> Int

alignment :: CUShort -> Int

peekElemOff :: Ptr CUShort -> Int -> IO CUShort

pokeElemOff :: Ptr CUShort -> Int -> CUShort -> IO ()

peekByteOff :: Ptr b -> Int -> IO CUShort

pokeByteOff :: Ptr b -> Int -> CUShort -> IO ()

peek :: Ptr CUShort -> IO CUShort

poke :: Ptr CUShort -> CUShort -> IO ()

Ix CUShort

Instance details

Methods

range :: (CUShort, CUShort) -> [CUShort]

index :: (CUShort, CUShort) -> CUShort -> Int

unsafeIndex :: (CUShort, CUShort) -> CUShort -> Int

inRange :: (CUShort, CUShort) -> CUShort -> Bool

rangeSize :: (CUShort, CUShort) -> Int

unsafeRangeSize :: (CUShort, CUShort) -> Int

Num CUShort

Instance details

Methods

(+) :: CUShort -> CUShort -> CUShort

(-) :: CUShort -> CUShort -> CUShort

(*) :: CUShort -> CUShort -> CUShort

negate :: CUShort -> CUShort

abs :: CUShort -> CUShort

signum :: CUShort -> CUShort

fromInteger :: Integer -> CUShort

Read CUShort

Instance details

Methods

readsPrec :: Int -> ReadS CUShort

readList :: ReadS [CUShort]

readPrec :: ReadPrec CUShort

readListPrec :: ReadPrec [CUShort]

Integral CUShort

Instance details

Methods

quot :: CUShort -> CUShort -> CUShort

rem :: CUShort -> CUShort -> CUShort

div :: CUShort -> CUShort -> CUShort

mod :: CUShort -> CUShort -> CUShort

quotRem :: CUShort -> CUShort -> (CUShort, CUShort)

divMod :: CUShort -> CUShort -> (CUShort, CUShort)

toInteger :: CUShort -> Integer

Real CUShort

Instance details

Methods

toRational :: CUShort -> Rational

Show CUShort

Instance details

Methods

showsPrec :: Int -> CUShort -> ShowS

show :: CUShort -> String

showList :: [CUShort] -> ShowS

Eq CUShort

Instance details

Methods

(==) :: CUShort -> CUShort -> Bool #

(/=) :: CUShort -> CUShort -> Bool #

Ord CUShort

Instance details

Methods

compare :: CUShort -> CUShort -> Ordering #

(<) :: CUShort -> CUShort -> Bool #

(<=) :: CUShort -> CUShort -> Bool #

(>) :: CUShort -> CUShort -> Bool #

(>=) :: CUShort -> CUShort -> Bool #

max :: CUShort -> CUShort -> CUShort #

min :: CUShort -> CUShort -> CUShort #

type Difference CUShort

Instance details

type Difference CUShort = CUShort

newtype CWchar #

Constructors

CWchar Int32

Instances

Instances details

HasNegation CWchar

Instance details

Methods

negate :: CWchar -> CWchar #

Integral CWchar

Instance details

Methods

fromInteger :: Integer -> CWchar #

Additive CWchar

Instance details

Methods

azero :: CWchar #

(+) :: CWchar -> CWchar -> CWchar #

scale :: IsNatural n => n -> CWchar -> CWchar #

IDivisible CWchar

Instance details

Methods

div :: CWchar -> CWchar -> CWchar #

mod :: CWchar -> CWchar -> CWchar #

divMod :: CWchar -> CWchar -> (CWchar, CWchar) #

Multiplicative CWchar

Instance details

Methods

midentity :: CWchar #

(*) :: CWchar -> CWchar -> CWchar #

(^) :: (IsNatural n, Enum n, IDivisible n) => CWchar -> n -> CWchar #

IsIntegral CWchar

Instance details

Defined in Basement.Numerical.Number

Methods

toInteger :: CWchar -> Integer #

Subtractive CWchar

Instance details

Associated Types

type Difference CWchar
Instance details Defined in Basement.Numerical.Subtractive type Difference CWchar = CWchar

Methods

(-) :: CWchar -> CWchar -> Difference CWchar #

Bits CWchar

Instance details

Methods

(.&.) :: CWchar -> CWchar -> CWchar #

(.|.) :: CWchar -> CWchar -> CWchar #

xor :: CWchar -> CWchar -> CWchar #

complement :: CWchar -> CWchar #

shift :: CWchar -> Int -> CWchar #

rotate :: CWchar -> Int -> CWchar #

zeroBits :: CWchar #

bit :: Int -> CWchar #

setBit :: CWchar -> Int -> CWchar #

clearBit :: CWchar -> Int -> CWchar #

complementBit :: CWchar -> Int -> CWchar #

testBit :: CWchar -> Int -> Bool #

bitSizeMaybe :: CWchar -> Maybe Int #

bitSize :: CWchar -> Int #

isSigned :: CWchar -> Bool #

shiftL :: CWchar -> Int -> CWchar #

unsafeShiftL :: CWchar -> Int -> CWchar #

shiftR :: CWchar -> Int -> CWchar #

unsafeShiftR :: CWchar -> Int -> CWchar #

rotateL :: CWchar -> Int -> CWchar #

rotateR :: CWchar -> Int -> CWchar #

popCount :: CWchar -> Int #

FiniteBits CWchar

Instance details

Methods

finiteBitSize :: CWchar -> Int

countLeadingZeros :: CWchar -> Int

countTrailingZeros :: CWchar -> Int

Bounded CWchar

Instance details

Methods

minBound :: CWchar #

maxBound :: CWchar #

Enum CWchar

Instance details

Methods

succ :: CWchar -> CWchar #

pred :: CWchar -> CWchar #

toEnum :: Int -> CWchar #

fromEnum :: CWchar -> Int #

enumFrom :: CWchar -> [CWchar] #

enumFromThen :: CWchar -> CWchar -> [CWchar] #

enumFromTo :: CWchar -> CWchar -> [CWchar] #

enumFromThenTo :: CWchar -> CWchar -> CWchar -> [CWchar] #

Storable CWchar

Instance details

Methods

sizeOf :: CWchar -> Int

alignment :: CWchar -> Int

peekElemOff :: Ptr CWchar -> Int -> IO CWchar

pokeElemOff :: Ptr CWchar -> Int -> CWchar -> IO ()

peekByteOff :: Ptr b -> Int -> IO CWchar

pokeByteOff :: Ptr b -> Int -> CWchar -> IO ()

peek :: Ptr CWchar -> IO CWchar

poke :: Ptr CWchar -> CWchar -> IO ()

Ix CWchar

Instance details

Methods

range :: (CWchar, CWchar) -> [CWchar]

index :: (CWchar, CWchar) -> CWchar -> Int

unsafeIndex :: (CWchar, CWchar) -> CWchar -> Int

inRange :: (CWchar, CWchar) -> CWchar -> Bool

rangeSize :: (CWchar, CWchar) -> Int

unsafeRangeSize :: (CWchar, CWchar) -> Int

Num CWchar

Instance details

Methods

(+) :: CWchar -> CWchar -> CWchar

(-) :: CWchar -> CWchar -> CWchar

(*) :: CWchar -> CWchar -> CWchar

negate :: CWchar -> CWchar

abs :: CWchar -> CWchar

signum :: CWchar -> CWchar

fromInteger :: Integer -> CWchar

Read CWchar

Instance details

Methods

readsPrec :: Int -> ReadS CWchar

readList :: ReadS [CWchar]

readPrec :: ReadPrec CWchar

readListPrec :: ReadPrec [CWchar]

Integral CWchar

Instance details

Methods

quot :: CWchar -> CWchar -> CWchar

rem :: CWchar -> CWchar -> CWchar

div :: CWchar -> CWchar -> CWchar

mod :: CWchar -> CWchar -> CWchar

quotRem :: CWchar -> CWchar -> (CWchar, CWchar)

divMod :: CWchar -> CWchar -> (CWchar, CWchar)

toInteger :: CWchar -> Integer

Real CWchar

Instance details

Methods

toRational :: CWchar -> Rational

Show CWchar

Instance details

Methods

showsPrec :: Int -> CWchar -> ShowS

show :: CWchar -> String

showList :: [CWchar] -> ShowS

Eq CWchar

Instance details

Methods

(==) :: CWchar -> CWchar -> Bool #

(/=) :: CWchar -> CWchar -> Bool #

Ord CWchar

Instance details

Methods

compare :: CWchar -> CWchar -> Ordering #

(<) :: CWchar -> CWchar -> Bool #

(<=) :: CWchar -> CWchar -> Bool #

(>) :: CWchar -> CWchar -> Bool #

(>=) :: CWchar -> CWchar -> Bool #

max :: CWchar -> CWchar -> CWchar #

min :: CWchar -> CWchar -> CWchar #

type Difference CWchar

Instance details