Clash.Sized.BitVector

Bit

data Bit

A single bit

NB: The usual Haskell method of converting an integral numeric type to another, fromIntegral, is not well suited for Clash as it will go through Integer which is arbitrarily bounded in HDL. Instead use bitCoerce and the Resize class.

Instances

Bounded Bit

Defined in Clash.Sized.Internal.BitVector

Methods

minBound :: Bit

maxBound :: Bit

Enum Bit

Defined in Clash.Sized.Internal.BitVector

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

Defined in Clash.Sized.Internal.BitVector

Methods

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

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

Integral Bit

Defined in Clash.Sized.Internal.BitVector

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

Defined in Clash.Sized.Internal.BitVector

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 :: forall r r'. (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

Defined in Clash.Sized.Internal.BitVector

Methods

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

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

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

negate :: Bit -> Bit

abs :: Bit -> Bit

signum :: Bit -> Bit

fromInteger :: Integer -> Bit

Ord Bit

Defined in Clash.Sized.Internal.BitVector

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

Defined in Clash.Sized.Internal.BitVector

Methods

toRational :: Bit -> Rational

Show Bit

Defined in Clash.Sized.Internal.BitVector

Methods

showsPrec :: Int -> Bit -> ShowS

show :: Bit -> String

showList :: [Bit] -> ShowS

Generic Bit

Defined in Clash.Sized.Internal.BitVector

Associated Types

type Rep Bit :: Type -> Type

Methods

from :: Bit -> Rep Bit x

to :: Rep Bit x -> Bit

Bits Bit

Defined in Clash.Sized.Internal.BitVector

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

Defined in Clash.Sized.Internal.BitVector

Methods

finiteBitSize :: Bit -> Int

countLeadingZeros :: Bit -> Int

countTrailingZeros :: Bit -> Int

Default Bit

Defined in Clash.Sized.Internal.BitVector

Methods

def :: Bit

NFData Bit

Defined in Clash.Sized.Internal.BitVector

Methods

rnf :: Bit -> ()

NFDataX Bit

Defined in Clash.Sized.Internal.BitVector

Methods

deepErrorX :: String -> Bit

hasUndefined :: Bit -> Bool

ensureSpine :: Bit -> Bit

rnfX :: Bit -> ()

ShowX Bit

Defined in Clash.Sized.Internal.BitVector

Methods

showsPrecX :: Int -> Bit -> ShowS

showX :: Bit -> String

showListX :: [Bit] -> ShowS

BitPack Bit

Defined in Clash.Class.BitPack.Internal

Associated Types

type BitSize Bit :: Nat

Methods

pack :: Bit -> BitVector (BitSize Bit)

unpack :: BitVector (BitSize Bit) -> Bit

Bundle Bit

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom Bit = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom Bit -> Signal dom Bit

unbundle :: forall (dom :: Domain). Signal dom Bit -> Unbundled dom Bit

Bundle Bit

Defined in Clash.Signal.Delayed.Bundle

Associated Types

type Unbundled dom d Bit = (res :: Type)

Methods

bundle :: forall (dom :: Domain) (d :: Nat). Unbundled dom d Bit -> DSignal dom d Bit

unbundle :: forall (dom :: Domain) (d :: Nat). DSignal dom d Bit -> Unbundled dom d Bit

AutoReg Bit

Defined in Clash.Class.AutoReg.Internal

Methods

autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> Bit -> Signal dom Bit -> Signal dom Bit

Lift Bit

Defined in Clash.Sized.Internal.BitVector

Methods

lift :: Bit -> Q Exp

liftTyped :: Bit -> Q (TExp Bit)

type Rep Bit

Defined in Clash.Sized.Internal.BitVector

type Rep Bit = D1 ('MetaData "Bit" "Clash.Sized.Internal.BitVector" "clash-prelude-1.6.6-inplace" 'False) (C1 ('MetaCons "Bit" 'PrefixI 'True) (S1 ('MetaSel ('Just "unsafeMask#") 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 Word) :*: S1 ('MetaSel ('Just "unsafeToInteger#") 'SourceUnpack 'SourceStrict 'DecidedStrict) (Rec0 Word)))

type BitSize Bit

Defined in Clash.Class.BitPack.Internal

type BitSize Bit = 1

type Unbundled dom Bit

Defined in Clash.Signal.Bundle

type Unbundled dom Bit = Signal dom Bit

type TryDomain t Bit

Defined in Clash.Class.HasDomain.HasSingleDomain

type TryDomain t Bit = 'NotFound

type Unbundled dom d Bit

Defined in Clash.Signal.Delayed.Bundle

type Unbundled dom d Bit = DSignal dom d 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.

NB: The usual Haskell method of converting an integral numeric type to another, fromIntegral, is not well suited for Clash as it will go through Integer which is arbitrarily bounded in HDL. Instead use bitCoerce and the Resize class.

BitVector has the type role

>>> :i BitVector
type role BitVector nominal
...

as it is not safe to coerce between different sizes of BitVector. To change the size, use the functions in the Resize class.

Instances

Resize BitVector

Defined in Clash.Sized.Internal.BitVector

Methods

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

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

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

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

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

KnownNat n => Lift (BitVector n :: Type)

Defined in Clash.Sized.Internal.BitVector

Methods

lift :: BitVector n -> Q Exp

liftTyped :: BitVector n -> Q (TExp (BitVector n))

KnownNat n => Bounded (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

minBound :: BitVector n

maxBound :: BitVector n

KnownNat n => Enum (BitVector n)

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

Defined in Clash.Sized.Internal.BitVector

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]

KnownNat n => Eq (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

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

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

KnownNat n => Integral (BitVector n)

NB: toInteger/fromIntegral can cause unexpected truncation, as Integer is arbitrarily bounded during synthesis. Prefer bitCoerce and the Resize class.

Defined in Clash.Sized.Internal.BitVector

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)

Defined in Clash.Sized.Internal.BitVector

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 :: forall r r'. (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)

NB: fromInteger/fromIntegral can cause unexpected truncation, as Integer is arbitrarily bounded during synthesis. Prefer bitCoerce and the Resize class.

Defined in Clash.Sized.Internal.BitVector

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

KnownNat n => Ord (BitVector n)

Defined in Clash.Sized.Internal.BitVector

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)

Defined in Clash.Sized.Internal.BitVector

Methods

toRational :: BitVector n -> Rational

KnownNat n => Show (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

showsPrec :: Int -> BitVector n -> ShowS

show :: BitVector n -> String

showList :: [BitVector n] -> ShowS

Generic (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Associated Types

type Rep (BitVector n) :: Type -> Type

Methods

from :: BitVector n -> Rep (BitVector n) x

to :: Rep (BitVector n) x -> BitVector n

KnownNat n => Arbitrary (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

arbitrary :: Gen (BitVector n)

shrink :: BitVector n -> [BitVector n]

KnownNat n => CoArbitrary (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

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

KnownNat n => Bits (BitVector n)

Defined in Clash.Sized.Internal.BitVector

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)

Defined in Clash.Sized.Internal.BitVector

Methods

finiteBitSize :: BitVector n -> Int

countLeadingZeros :: BitVector n -> Int

countTrailingZeros :: BitVector n -> Int

Default (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

def :: BitVector n

NFData (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

rnf :: BitVector n -> ()

KnownNat n => Ixed (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

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

KnownNat n => SaturatingNum (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

satAdd :: SaturationMode -> BitVector n -> BitVector n -> BitVector n

satSub :: SaturationMode -> BitVector n -> BitVector n -> BitVector n

satMul :: SaturationMode -> BitVector n -> BitVector n -> BitVector n

satSucc :: SaturationMode -> BitVector n -> BitVector n

satPred :: SaturationMode -> BitVector n -> BitVector n

KnownNat n => NFDataX (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

deepErrorX :: String -> BitVector n

hasUndefined :: BitVector n -> Bool

ensureSpine :: BitVector n -> BitVector n

rnfX :: BitVector n -> ()

KnownNat n => ShowX (BitVector n)

Defined in Clash.Sized.Internal.BitVector

Methods

showsPrecX :: Int -> BitVector n -> ShowS

showX :: BitVector n -> String

showListX :: [BitVector n] -> ShowS

KnownNat n => BitPack (BitVector n)

Defined in Clash.Class.BitPack.Internal

Associated Types

type BitSize (BitVector n) :: Nat

Methods

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

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

KnownNat n => Parity (BitVector n)

Defined in Clash.Class.Parity

Methods

even :: BitVector n -> Bool

odd :: BitVector n -> Bool

Bundle (BitVector n)

Defined in Clash.Signal.Bundle

Associated Types

type Unbundled dom (BitVector n) = (res :: Type)

Methods

bundle :: forall (dom :: Domain). Unbundled dom (BitVector n) -> Signal dom (BitVector n)

unbundle :: forall (dom :: Domain). Signal dom (BitVector n) -> Unbundled dom (BitVector n)

Bundle (BitVector n)

Defined in Clash.Signal.Delayed.Bundle

Associated Types

type Unbundled dom d (BitVector n) = (res :: Type)

Methods

bundle :: forall (dom :: Domain) (d :: Nat). Unbundled dom d (BitVector n) -> DSignal dom d (BitVector n)

unbundle :: forall (dom :: Domain) (d :: Nat). DSignal dom d (BitVector n) -> Unbundled dom d (BitVector n)

KnownNat n => Counter (BitVector n)

Defined in Clash.Class.Counter.Internal

Methods

countMin :: BitVector n

countMax :: BitVector n

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

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

KnownNat n => AutoReg (BitVector n)

Defined in Clash.Class.AutoReg.Internal

Methods

autoReg :: forall (dom :: Domain). (HasCallStack, KnownDomain dom) => Clock dom -> Reset dom -> Enable dom -> BitVector n -> Signal dom (BitVector n) -> Signal dom (BitVector n)

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

Defined in Clash.Sized.Internal.BitVector

Associated Types

type AResult (BitVector m) (BitVector n)

type MResult (BitVector m) (BitVector n)

Methods

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

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

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

type Unbundled dom d (BitVector n)

Defined in Clash.Signal.Delayed.Bundle

type Unbundled dom d (BitVector n) = DSignal dom d (BitVector n)

type Unbundled dom (BitVector n)

Defined in Clash.Signal.Bundle

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

type TryDomain t (BitVector n)

Defined in Clash.Class.HasDomain.HasSingleDomain

type TryDomain t (BitVector n) = 'NotFound

type Rep (BitVector n)

Defined in Clash.Sized.Internal.BitVector

type Rep (BitVector n) = D1 ('MetaData "BitVector" "Clash.Sized.Internal.BitVector" "clash-prelude-1.6.6-inplace" 'False) (C1 ('MetaCons "BV" 'PrefixI 'True) (S1 ('MetaSel ('Just "unsafeMask") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Natural) :*: S1 ('MetaSel ('Just "unsafeToNatural") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Natural)))

type Index (BitVector n)

Defined in Clash.Sized.Internal.BitVector

type Index (BitVector n) = Int

type IxValue (BitVector n)

Defined in Clash.Sized.Internal.BitVector

type IxValue (BitVector n) = Bit

type BitSize (BitVector n)

Defined in Clash.Class.BitPack.Internal

type BitSize (BitVector n) = n

type AResult (BitVector m) (BitVector n)

Defined in Clash.Sized.Internal.BitVector

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

type MResult (BitVector m) (BitVector n)

Defined in Clash.Sized.Internal.BitVector

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 :: String -> ExpQ

Create a binary literal

>>> $(bLit "1001")
0b1001

NB: You can also just write:

>>> 0b1001 :: BitVector 4
0b1001

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'))
0b1111

Also bLit can handle don't care bits:

>>> $(bLit "1.0.")
0b1.0.

N.B.: From Clash 1.6 an onwards bLit will deduce the size of the BitVector from the given string and annotate the splice it produces accordingly.

Concatenation

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

Concatenate two BitVectors

Pattern matching

bitPattern :: String -> Q Pat

Template Haskell macro for generating a pattern matching on some bits of a value.

This macro compiles to an efficient view pattern that matches the bits of a given value against the bits specified in the pattern. The scrutinee can be any type that is an instance of the Num, Bits and Eq typeclasses.

The bit pattern is specified by a string which contains:

• '0' or '1' for matching a bit
• '.' for bits which are not matched (wildcard)
• '_' can be used as a separator similar to the NumericUnderscores language extension
• lowercase alphabetical characters can be used to bind some bits to variables. For example "0aab11bb" will bind two variables aa :: BitVector 2 and bbb :: BitVector 3 with their values set by the corresponding bits

The following example matches a byte against two bit patterns where some bits are relevant and others are not while binding two variables aa and bb:

  decode :: Unsigned 8 -> Maybe Bool
  decode $(bitPattern "00.._.110") = Just True
  decode $(bitPattern "10.._0001") = Just False
  decode $(bitPattern "aa.._b0b1") = Just (aa + bb > 1)
  decode _ = Nothing