CLaSH.Sized.BitVector

Datatypes

data BitVector n

A vector of bits.

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

Instances

Resize BitVector

KnownNat n => Bounded (BitVector n)

KnownNat n => Enum (BitVector n)

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

Eq (BitVector n)

KnownNat n => Integral (BitVector n)

Typeable Nat n => Data (BitVector n)

KnownNat n => Num (BitVector n)

Ord (BitVector n)

KnownNat n => Real (BitVector n)

KnownNat n => Show (BitVector n)

KnownNat n => Arbitrary (BitVector n)

KnownNat n => CoArbitrary (BitVector n)

(KnownNat n, KnownNat ((+) n 1), KnownNat ((+) n 2)) => Bits (BitVector n)

(KnownNat n, KnownNat ((+) n 1), KnownNat ((+) n 2)) => FiniteBits (BitVector n)

Default (BitVector n)

KnownNat n => Ixed (BitVector n)

KnownNat n => Lift (BitVector n)

(KnownNat n, KnownNat ((+) n 1), KnownNat ((+) n n)) => SaturatingNum (BitVector n)

BitPack (BitVector n)

Bundle (BitVector n)

(KnownNat ((+) (Max m n) 1), KnownNat ((+) m n)) => ExtendingNum (BitVector m) (BitVector n)

type Unbundled' clk (BitVector n) = Signal' clk (BitVector n)

type Index (BitVector n) = Int

type IxValue (BitVector n) = Bit

type BitSize (BitVector n) = n

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

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

type Bit = BitVector 1

Bit: a BitVector of length 1

Accessors

Length information

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

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

Construction

Initialisation

high :: Bit

logic '1'

low :: Bit

logic '0'

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