CLaSH.Sized.Internal.BitVector

Datatypes

newtype BitVector n

A vector of bits.

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

Constructors

BV

The constructor, BV, and the field, unsafeToInteger, are not synthesisable.

Fields

unsafeToInteger :: Integer

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)

NFData (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

Reduction

reduceAnd# :: KnownNat n => BitVector n -> BitVector 1

reduceOr# :: BitVector n -> BitVector 1

reduceXor# :: BitVector n -> BitVector 1

Indexing

index# :: KnownNat n => BitVector n -> Int -> Bit

replaceBit# :: KnownNat n => BitVector n -> Int -> Bit -> BitVector n

setSlice# :: BitVector ((m + 1) + i) -> SNat m -> SNat n -> BitVector ((m + 1) - n) -> BitVector ((m + 1) + i)

slice# :: BitVector ((m + 1) + i) -> SNat m -> SNat n -> BitVector ((m + 1) - n)

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

msb# :: KnownNat n => BitVector n -> Bit

MSB

lsb# :: BitVector n -> Bit

LSB

Type classes

Eq

eq# :: BitVector n -> BitVector n -> Bool

neq# :: BitVector n -> BitVector n -> Bool

Ord

lt# :: BitVector n -> BitVector n -> Bool

ge# :: BitVector n -> BitVector n -> Bool

gt# :: BitVector n -> BitVector n -> Bool

le# :: BitVector n -> BitVector n -> Bool

Enum (not synthesisable)

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]

Bounded

minBound# :: BitVector n

maxBound# :: KnownNat n => BitVector n

Num

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

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

(*#) :: KnownNat n => BitVector n -> BitVector n -> BitVector n

negate# :: KnownNat n => BitVector n -> BitVector n

fromInteger# :: KnownNat n => Integer -> BitVector n

ExtendingNum

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

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

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

Integral

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

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

toInteger# :: BitVector n -> Integer

Bits

and# :: BitVector n -> BitVector n -> BitVector n

or# :: BitVector n -> BitVector n -> BitVector n

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

complement# :: KnownNat n => BitVector n -> BitVector n

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

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

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

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

popCountBV :: (KnownNat (n + 1), KnownNat (n + 2)) => BitVector (n + 1) -> Index (n + 2)

Resize

resize# :: KnownNat m => BitVector n -> BitVector m

QuickCheck

shrinkSizedUnsigned :: (KnownNat n, Integral (p n)) => p n -> [p n]

shrink for sized unsigned types