Clash.Sized.BitVector

Bit

data Bit

Bit

Instances

Bounded Bit

Methods

minBound :: Bit

maxBound :: Bit

Enum Bit

Methods

succ :: Bit -> Bit

pred :: Bit -> Bit

toEnum :: Int -> Bit

fromEnum :: Bit -> Int

enumFrom :: Bit -> [Bit]

enumFromThen :: Bit -> Bit -> [Bit]

enumFromTo :: Bit -> Bit -> [Bit]

enumFromThenTo :: Bit -> Bit -> Bit -> [Bit]

Eq Bit

Methods

(==) :: Bit -> Bit -> Bool

(/=) :: Bit -> Bit -> Bool

Integral Bit

Methods

quot :: Bit -> Bit -> Bit

rem :: Bit -> Bit -> Bit

div :: Bit -> Bit -> Bit

mod :: Bit -> Bit -> Bit

quotRem :: Bit -> Bit -> (Bit, Bit)

divMod :: Bit -> Bit -> (Bit, Bit)

toInteger :: Bit -> Integer

Data Bit

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bit -> c Bit

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bit

toConstr :: Bit -> Constr

dataTypeOf :: Bit -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bit)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bit)

gmapT :: (forall b. Data b => b -> b) -> Bit -> Bit

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bit -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bit -> r

gmapQ :: (forall d. Data d => d -> u) -> Bit -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bit -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bit -> m Bit

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bit -> m Bit

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bit -> m Bit

Num Bit

Methods

(+) :: Bit -> Bit -> Bit

(-) :: Bit -> Bit -> Bit

(*) :: Bit -> Bit -> Bit

negate :: Bit -> Bit

abs :: Bit -> Bit

signum :: Bit -> Bit

fromInteger :: Integer -> Bit

Ord Bit

Methods

compare :: Bit -> Bit -> Ordering

(<) :: Bit -> Bit -> Bool

(<=) :: Bit -> Bit -> Bool

(>) :: Bit -> Bit -> Bool

(>=) :: Bit -> Bit -> Bool

max :: Bit -> Bit -> Bit

min :: Bit -> Bit -> Bit

Real Bit

Methods

toRational :: Bit -> Rational

Show Bit

Methods

showsPrec :: Int -> Bit -> ShowS

show :: Bit -> String

showList :: [Bit] -> ShowS

Lift Bit

Methods

lift :: Bit -> Q Exp

Bits Bit

Methods

(.&.) :: Bit -> Bit -> Bit

(.|.) :: Bit -> Bit -> Bit

xor :: Bit -> Bit -> Bit

complement :: Bit -> Bit

shift :: Bit -> Int -> Bit

rotate :: Bit -> Int -> Bit

zeroBits :: Bit

bit :: Int -> Bit

setBit :: Bit -> Int -> Bit

clearBit :: Bit -> Int -> Bit

complementBit :: Bit -> Int -> Bit

testBit :: Bit -> Int -> Bool

bitSizeMaybe :: Bit -> Maybe Int

bitSize :: Bit -> Int

isSigned :: Bit -> Bool

shiftL :: Bit -> Int -> Bit

unsafeShiftL :: Bit -> Int -> Bit

shiftR :: Bit -> Int -> Bit

unsafeShiftR :: Bit -> Int -> Bit

rotateL :: Bit -> Int -> Bit

rotateR :: Bit -> Int -> Bit

popCount :: Bit -> Int

FiniteBits Bit

Methods

finiteBitSize :: Bit -> Int

countLeadingZeros :: Bit -> Int

countTrailingZeros :: Bit -> Int

NFData Bit

Methods

rnf :: Bit -> ()

ShowX Bit

Methods

showsPrecX :: Int -> Bit -> ShowS

showX :: Bit -> String

showListX :: [Bit] -> ShowS

Default Bit

Methods

def :: Bit

BitPack Bit

Associated Types

type BitSize Bit :: Nat

Methods

pack :: Bit -> BitVector (BitSize Bit)

unpack :: BitVector (BitSize Bit) -> Bit

Bundle Bit

Associated Types

type Unbundled domain Bit = (res :: *)

Methods

bundle :: Unbundled domain Bit -> Signal domain Bit

unbundle :: Signal domain Bit -> Unbundled domain Bit

type BitSize Bit

type BitSize Bit = 1

type Unbundled domain Bit

type Unbundled domain Bit = Signal domain Bit

Construction

Initialisation

high :: Bit

logic '1'

low :: Bit

logic '0'

BitVector

data BitVector (n :: Nat)

A vector of bits.

• Bit indices are descending
• Num instance performs unsigned arithmetic.

Instances

Resize BitVector

Methods

resize :: (KnownNat a, KnownNat b) => BitVector a -> BitVector b

extend :: (KnownNat a, KnownNat b) => BitVector a -> BitVector (b + a)

zeroExtend :: (KnownNat a, KnownNat b) => BitVector a -> BitVector (b + a)

signExtend :: (KnownNat a, KnownNat b) => BitVector a -> BitVector (b + a)

truncateB :: KnownNat a => BitVector (a + b) -> BitVector a

KnownNat n => Bounded (BitVector n)

Methods

minBound :: BitVector n

maxBound :: BitVector n

KnownNat n => Enum (BitVector n)

The functions: enumFrom, enumFromThen, enumFromTo, and enumFromThenTo, are not synthesisable.

Methods

succ :: BitVector n -> BitVector n

pred :: BitVector n -> BitVector n

toEnum :: Int -> BitVector n

fromEnum :: BitVector n -> Int

enumFrom :: BitVector n -> [BitVector n]

enumFromThen :: BitVector n -> BitVector n -> [BitVector n]

enumFromTo :: BitVector n -> BitVector n -> [BitVector n]

enumFromThenTo :: BitVector n -> BitVector n -> BitVector n -> [BitVector n]

Eq (BitVector n)

Methods

(==) :: BitVector n -> BitVector n -> Bool

(/=) :: BitVector n -> BitVector n -> Bool

KnownNat n => Integral (BitVector n)

Methods

quot :: BitVector n -> BitVector n -> BitVector n

rem :: BitVector n -> BitVector n -> BitVector n

div :: BitVector n -> BitVector n -> BitVector n

mod :: BitVector n -> BitVector n -> BitVector n

quotRem :: BitVector n -> BitVector n -> (BitVector n, BitVector n)

divMod :: BitVector n -> BitVector n -> (BitVector n, BitVector n)

toInteger :: BitVector n -> Integer

KnownNat n => Data (BitVector n)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BitVector n -> c (BitVector n)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BitVector n)

toConstr :: BitVector n -> Constr

dataTypeOf :: BitVector n -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BitVector n))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BitVector n))

gmapT :: (forall b. Data b => b -> b) -> BitVector n -> BitVector n

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BitVector n -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BitVector n -> r

gmapQ :: (forall d. Data d => d -> u) -> BitVector n -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> BitVector n -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BitVector n -> m (BitVector n)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BitVector n -> m (BitVector n)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BitVector n -> m (BitVector n)

KnownNat n => Num (BitVector n)

Methods

(+) :: BitVector n -> BitVector n -> BitVector n

(-) :: BitVector n -> BitVector n -> BitVector n

(*) :: BitVector n -> BitVector n -> BitVector n

negate :: BitVector n -> BitVector n

abs :: BitVector n -> BitVector n

signum :: BitVector n -> BitVector n

fromInteger :: Integer -> BitVector n

Ord (BitVector n)

Methods

compare :: BitVector n -> BitVector n -> Ordering

(<) :: BitVector n -> BitVector n -> Bool

(<=) :: BitVector n -> BitVector n -> Bool

(>) :: BitVector n -> BitVector n -> Bool

(>=) :: BitVector n -> BitVector n -> Bool

max :: BitVector n -> BitVector n -> BitVector n

min :: BitVector n -> BitVector n -> BitVector n

KnownNat n => Real (BitVector n)

Methods

toRational :: BitVector n -> Rational

KnownNat n => Show (BitVector n)

Methods

showsPrec :: Int -> BitVector n -> ShowS

show :: BitVector n -> String

showList :: [BitVector n] -> ShowS

KnownNat n => Lift (BitVector n)

Methods

lift :: BitVector n -> Q Exp

KnownNat n => Bits (BitVector n)

Methods

(.&.) :: BitVector n -> BitVector n -> BitVector n

(.|.) :: BitVector n -> BitVector n -> BitVector n

xor :: BitVector n -> BitVector n -> BitVector n

complement :: BitVector n -> BitVector n

shift :: BitVector n -> Int -> BitVector n

rotate :: BitVector n -> Int -> BitVector n

zeroBits :: BitVector n

bit :: Int -> BitVector n

setBit :: BitVector n -> Int -> BitVector n

clearBit :: BitVector n -> Int -> BitVector n

complementBit :: BitVector n -> Int -> BitVector n

testBit :: BitVector n -> Int -> Bool

bitSizeMaybe :: BitVector n -> Maybe Int

bitSize :: BitVector n -> Int

isSigned :: BitVector n -> Bool

shiftL :: BitVector n -> Int -> BitVector n

unsafeShiftL :: BitVector n -> Int -> BitVector n

shiftR :: BitVector n -> Int -> BitVector n

unsafeShiftR :: BitVector n -> Int -> BitVector n

rotateL :: BitVector n -> Int -> BitVector n

rotateR :: BitVector n -> Int -> BitVector n

popCount :: BitVector n -> Int

KnownNat n => FiniteBits (BitVector n)

Methods

finiteBitSize :: BitVector n -> Int

countLeadingZeros :: BitVector n -> Int

countTrailingZeros :: BitVector n -> Int

NFData (BitVector n)

Methods

rnf :: BitVector n -> ()

KnownNat n => SaturatingNum (BitVector n)

Methods

satPlus :: SaturationMode -> BitVector n -> BitVector n -> BitVector n

satMin :: SaturationMode -> BitVector n -> BitVector n -> BitVector n

satMult :: SaturationMode -> BitVector n -> BitVector n -> BitVector n

KnownNat n => ShowX (BitVector n)

Methods

showsPrecX :: Int -> BitVector n -> ShowS

showX :: BitVector n -> String

showListX :: [BitVector n] -> ShowS

KnownNat n => Ixed (BitVector n)

Methods

ix :: Index (BitVector n) -> Traversal' (BitVector n) (IxValue (BitVector n))

Default (BitVector n)

Methods

def :: BitVector n

KnownNat n => Arbitrary (BitVector n)

Methods

arbitrary :: Gen (BitVector n)

shrink :: BitVector n -> [BitVector n]

KnownNat n => CoArbitrary (BitVector n)

Methods

coarbitrary :: BitVector n -> Gen b -> Gen b

BitPack (BitVector n)

Associated Types

type BitSize (BitVector n) :: Nat

Methods

pack :: BitVector n -> BitVector (BitSize (BitVector n))

unpack :: BitVector (BitSize (BitVector n)) -> BitVector n

Bundle (BitVector n)

Associated Types

type Unbundled domain (BitVector n) = (res :: *)

Methods

bundle :: Unbundled domain (BitVector n) -> Signal domain (BitVector n)

unbundle :: Signal domain (BitVector n) -> Unbundled domain (BitVector n)

(KnownNat m, KnownNat n) => ExtendingNum (BitVector m) (BitVector n)

Associated Types

type AResult (BitVector m) (BitVector n) :: *

type MResult (BitVector m) (BitVector n) :: *

Methods

plus :: BitVector m -> BitVector n -> AResult (BitVector m) (BitVector n)

minus :: BitVector m -> BitVector n -> AResult (BitVector m) (BitVector n)

times :: BitVector m -> BitVector n -> MResult (BitVector m) (BitVector n)

type Unbundled domain (BitVector n)

type Unbundled domain (BitVector n) = Signal domain (BitVector n)

type Index (BitVector n)

type Index (BitVector n) = Int

type IxValue (BitVector n)

type IxValue (BitVector n) = Bit

type BitSize (BitVector n)

type BitSize (BitVector n) = n

type AResult (BitVector m) (BitVector n)

type AResult (BitVector m) (BitVector n) = BitVector (Max m n + 1)

type MResult (BitVector m) (BitVector n)

type MResult (BitVector m) (BitVector n) = BitVector (m + n)

Accessors

Length information

size# :: KnownNat n => BitVector n -> Int

maxIndex# :: KnownNat n => BitVector n -> Int

Construction

bLit :: KnownNat n => String -> Q (TExp (BitVector n))

Create a binary literal

>>> $$(bLit "1001") :: BitVector 4
1001
>>> $$(bLit "1001") :: BitVector 3
001

NB: You can also just write:

>>> 0b1001 :: BitVector 4
1001

The advantage of bLit is that you can use computations to create the string literal:

>>> import qualified Data.List as List
>>> $$(bLit (List.replicate 4 '1')) :: BitVector 4
1111

Concatenation

(++#) :: KnownNat m => BitVector n -> BitVector m -> BitVector (n + m)

Concatenate two BitVectors