Clash.Class.BitPack

Documentation

class KnownNat (BitSize a) => BitPack a where

Convert to and from a BitVector

Minimal complete definition

Nothing

Associated Types

type BitSize a :: Nat

Number of Bits needed to represents elements of type a

Can be derived using Generics:

import Clash.Prelude
import GHC.Generics

data MyProductType = MyProductType { a :: Int, b :: Bool }
  deriving (Generic, BitPack)

type BitSize a = CLog 2 (GConstructorCount (Rep a)) + GFieldSize (Rep a)

Methods

pack :: a -> BitVector (BitSize a)

Convert element of type a to a BitVector

>>> pack (-5 :: Signed 6)
11_1011

default pack :: (Generic a, GBitPack (Rep a), KnownNat (BitSize a), KnownNat constrSize, KnownNat fieldSize, constrSize ~ CLog 2 (GConstructorCount (Rep a)), fieldSize ~ GFieldSize (Rep a), (constrSize + fieldSize) ~ BitSize a) => a -> BitVector (BitSize a)

unpack :: BitVector (BitSize a) -> a

Convert a BitVector to an element of type a

>>> pack (-5 :: Signed 6)
11_1011
>>> let x = pack (-5 :: Signed 6)
>>> unpack x :: Unsigned 6
59
>>> pack (59 :: Unsigned 6)
11_1011

default unpack :: (Generic a, GBitPack (Rep a), KnownNat constrSize, KnownNat fieldSize, constrSize ~ CLog 2 (GConstructorCount (Rep a)), fieldSize ~ GFieldSize (Rep a), (constrSize + fieldSize) ~ BitSize a) => BitVector (BitSize a) -> a

Instances

BitPack Bool

Defined in Clash.Class.BitPack

Associated Types

type BitSize Bool :: Nat

Methods

pack :: Bool -> BitVector (BitSize Bool)

unpack :: BitVector (BitSize Bool) -> Bool

BitPack Double

Defined in Clash.Class.BitPack

Associated Types

type BitSize Double :: Nat

Methods

pack :: Double -> BitVector (BitSize Double)

unpack :: BitVector (BitSize Double) -> Double

BitPack Float

Defined in Clash.Class.BitPack

Associated Types

type BitSize Float :: Nat

Methods

pack :: Float -> BitVector (BitSize Float)

unpack :: BitVector (BitSize Float) -> Float

BitPack Int

Defined in Clash.Class.BitPack

Associated Types

type BitSize Int :: Nat

Methods

pack :: Int -> BitVector (BitSize Int)

unpack :: BitVector (BitSize Int) -> Int

BitPack Int8

Defined in Clash.Class.BitPack

Associated Types

type BitSize Int8 :: Nat

Methods

pack :: Int8 -> BitVector (BitSize Int8)

unpack :: BitVector (BitSize Int8) -> Int8

BitPack Int16

Defined in Clash.Class.BitPack

Associated Types

type BitSize Int16 :: Nat

Methods

pack :: Int16 -> BitVector (BitSize Int16)

unpack :: BitVector (BitSize Int16) -> Int16

BitPack Int32

Defined in Clash.Class.BitPack

Associated Types

type BitSize Int32 :: Nat

Methods

pack :: Int32 -> BitVector (BitSize Int32)

unpack :: BitVector (BitSize Int32) -> Int32

BitPack Int64

Defined in Clash.Class.BitPack

Associated Types

type BitSize Int64 :: Nat

Methods

pack :: Int64 -> BitVector (BitSize Int64)

unpack :: BitVector (BitSize Int64) -> Int64

BitPack Word

Defined in Clash.Class.BitPack

Associated Types

type BitSize Word :: Nat

Methods

pack :: Word -> BitVector (BitSize Word)

unpack :: BitVector (BitSize Word) -> Word

BitPack Word8

Defined in Clash.Class.BitPack

Associated Types

type BitSize Word8 :: Nat

Methods

pack :: Word8 -> BitVector (BitSize Word8)

unpack :: BitVector (BitSize Word8) -> Word8

BitPack Word16

Defined in Clash.Class.BitPack

Associated Types

type BitSize Word16 :: Nat

Methods

pack :: Word16 -> BitVector (BitSize Word16)

unpack :: BitVector (BitSize Word16) -> Word16

BitPack Word32

Defined in Clash.Class.BitPack

Associated Types

type BitSize Word32 :: Nat

Methods

pack :: Word32 -> BitVector (BitSize Word32)

unpack :: BitVector (BitSize Word32) -> Word32

BitPack Word64

Defined in Clash.Class.BitPack

Associated Types

type BitSize Word64 :: Nat

Methods

pack :: Word64 -> BitVector (BitSize Word64)

unpack :: BitVector (BitSize Word64) -> Word64

BitPack ()

Defined in Clash.Class.BitPack

Associated Types

type BitSize () :: Nat

Methods

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

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

BitPack CUShort

Defined in Clash.Class.BitPack

Associated Types

type BitSize CUShort :: Nat

Methods

pack :: CUShort -> BitVector (BitSize CUShort)

unpack :: BitVector (BitSize CUShort) -> CUShort

BitPack Half

Defined in Clash.Class.BitPack

Associated Types

type BitSize Half :: Nat

Methods

pack :: Half -> BitVector (BitSize Half)

unpack :: BitVector (BitSize Half) -> Half

BitPack Bit

Defined in Clash.Class.BitPack

Associated Types

type BitSize Bit :: Nat

Methods

pack :: Bit -> BitVector (BitSize Bit)

unpack :: BitVector (BitSize Bit) -> Bit

BitPack a => BitPack (Maybe a)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (Maybe a) :: Nat

Methods

pack :: Maybe a -> BitVector (BitSize (Maybe a))

unpack :: BitVector (BitSize (Maybe a)) -> Maybe a

BitPack a => BitPack (Complex a)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (Complex a) :: Nat

Methods

pack :: Complex a -> BitVector (BitSize (Complex a))

unpack :: BitVector (BitSize (Complex a)) -> Complex a

BitPack a => BitPack (Down a)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (Down a) :: Nat

Methods

pack :: Down a -> BitVector (BitSize (Down a))

unpack :: BitVector (BitSize (Down a)) -> Down a

KnownNat n => BitPack (BitVector n)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (BitVector n) :: Nat

Methods

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

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

(KnownNat n, 1 <= n) => BitPack (Index n)

Defined in Clash.Sized.Internal.Index

Associated Types

type BitSize (Index n) :: Nat

Methods

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

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

KnownNat n => BitPack (Unsigned n)

Defined in Clash.Sized.Internal.Unsigned

Associated Types

type BitSize (Unsigned n) :: Nat

Methods

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

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

KnownNat n => BitPack (Signed n)

Defined in Clash.Sized.Internal.Signed

Associated Types

type BitSize (Signed n) :: Nat

Methods

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

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

(BitPack a, BitPack b) => BitPack (Either a b)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (Either a b) :: Nat

Methods

pack :: Either a b -> BitVector (BitSize (Either a b))

unpack :: BitVector (BitSize (Either a b)) -> Either a b

(BitPack a, BitPack b) => BitPack (a, b)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a, b) :: Nat

Methods

pack :: (a, b) -> BitVector (BitSize (a, b))

unpack :: BitVector (BitSize (a, b)) -> (a, b)

(KnownNat n, BitPack a) => BitPack (Vec n a)

Defined in Clash.Sized.Vector

Associated Types

type BitSize (Vec n a) :: Nat

Methods

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

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

(KnownNat d, BitPack a) => BitPack (RTree d a)

Defined in Clash.Sized.RTree

Associated Types

type BitSize (RTree d a) :: Nat

Methods

pack :: RTree d a -> BitVector (BitSize (RTree d a))

unpack :: BitVector (BitSize (RTree d a)) -> RTree d a

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3), KnownNat (BitSize (a2, a3))) => BitPack (a1, a2, a3)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3) :: Nat

Methods

pack :: (a1, a2, a3) -> BitVector (BitSize (a1, a2, a3))

unpack :: BitVector (BitSize (a1, a2, a3)) -> (a1, a2, a3)

BitPack (rep (int + frac)) => BitPack (Fixed rep int frac)

Defined in Clash.Sized.Fixed

Associated Types

type BitSize (Fixed rep int frac) :: Nat

Methods

pack :: Fixed rep int frac -> BitVector (BitSize (Fixed rep int frac))

unpack :: BitVector (BitSize (Fixed rep int frac)) -> Fixed rep int frac

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4), KnownNat (BitSize (a2, a3, a4))) => BitPack (a1, a2, a3, a4)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3, a4) :: Nat

Methods

pack :: (a1, a2, a3, a4) -> BitVector (BitSize (a1, a2, a3, a4))

unpack :: BitVector (BitSize (a1, a2, a3, a4)) -> (a1, a2, a3, a4)

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4, a5), KnownNat (BitSize (a2, a3, a4, a5))) => BitPack (a1, a2, a3, a4, a5)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3, a4, a5) :: Nat

Methods

pack :: (a1, a2, a3, a4, a5) -> BitVector (BitSize (a1, a2, a3, a4, a5))

unpack :: BitVector (BitSize (a1, a2, a3, a4, a5)) -> (a1, a2, a3, a4, a5)

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4, a5, a6), KnownNat (BitSize (a2, a3, a4, a5, a6))) => BitPack (a1, a2, a3, a4, a5, a6)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3, a4, a5, a6) :: Nat

Methods

pack :: (a1, a2, a3, a4, a5, a6) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6))

unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6)) -> (a1, a2, a3, a4, a5, a6)

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4, a5, a6, a7), KnownNat (BitSize (a2, a3, a4, a5, a6, a7))) => BitPack (a1, a2, a3, a4, a5, a6, a7)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3, a4, a5, a6, a7) :: Nat

Methods

pack :: (a1, a2, a3, a4, a5, a6, a7) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7))

unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7)) -> (a1, a2, a3, a4, a5, a6, a7)

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4, a5, a6, a7, a8), KnownNat (BitSize (a2, a3, a4, a5, a6, a7, a8))) => BitPack (a1, a2, a3, a4, a5, a6, a7, a8)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3, a4, a5, a6, a7, a8) :: Nat

Methods

pack :: (a1, a2, a3, a4, a5, a6, a7, a8) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8))

unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8)) -> (a1, a2, a3, a4, a5, a6, a7, a8)

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4, a5, a6, a7, a8, a9), KnownNat (BitSize (a2, a3, a4, a5, a6, a7, a8, a9))) => BitPack (a1, a2, a3, a4, a5, a6, a7, a8, a9)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9) :: Nat

Methods

pack :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9))

unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9)

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4, a5, a6, a7, a8, a9, a10), KnownNat (BitSize (a2, a3, a4, a5, a6, a7, a8, a9, a10))) => BitPack (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) :: Nat

Methods

pack :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10))

unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4, a5, a6, a7, a8, a9, a10, a11), KnownNat (BitSize (a2, a3, a4, a5, a6, a7, a8, a9, a10, a11))) => BitPack (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) :: Nat

Methods

pack :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11))

unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)

(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12), KnownNat (BitSize (a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12))) => BitPack (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)

Defined in Clash.Class.BitPack

Associated Types

type BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) :: Nat

Methods

pack :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12))

unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)

bitCoerce :: (BitPack a, BitPack b, BitSize a ~ BitSize b) => a -> b

Coerce a value from one type to another through its bit representation.

>>> pack (-5 :: Signed 6)
11_1011
>>> bitCoerce (-5 :: Signed 6) :: Unsigned 6
59
>>> pack (59 :: Unsigned 6)
11_1011

bitCoerceMap :: forall a b. (BitPack a, BitPack b, BitSize a ~ BitSize b) => (a -> a) -> b -> b

Map a value by first coercing to another type through its bit representation.

>>> pack (-5 :: Signed 32)
1111_1111_1111_1111_1111_1111_1111_1011
>>> bitCoerceMap @(Vec 4 (BitVector 8)) (replace 1 0) (-5 :: Signed 32)
-16711685
>>> pack (-16711685 :: Signed 32)
1111_1111_0000_0000_1111_1111_1111_1011

boolToBV :: KnownNat n => Bool -> BitVector (n + 1)

Zero-extend a Boolean value to a BitVector of the appropriate size.

>>> boolToBV True :: BitVector 6
00_0001
>>> boolToBV False :: BitVector 6
00_0000

boolToBit :: Bool -> Bit

Convert a Bool to a Bit

bitToBool :: Bit -> Bool

Convert a Bool to a Bit

packXWith :: KnownNat n => (a -> BitVector n) -> a -> BitVector n

Internals

class GBitPack f where

Associated Types

type GFieldSize f :: Nat

Size of fields. If multiple constructors exist, this is the maximum of the sum of each of the constructors fields.

type GConstructorCount f :: Nat

Number of constructors this type has. Indirectly indicates how many bits are needed to represent the constructor.

Methods

gPackFields

Arguments

:: Int

Current constructor

-> f a

Data to pack

-> (Int, BitVector (GFieldSize f))

(Constructor number, Packed fields)

Pack fields of a type. Caller should pack and prepend the constructor bits.

gUnpack

Arguments

:: Int

Construct with constructor n

-> Int

Current constructor

-> BitVector (GFieldSize f)

BitVector containing fields

-> f a

Unpacked result

Unpack whole type.

Instances

GBitPack (U1 :: Type -> Type)

Defined in Clash.Class.BitPack

Associated Types

type GFieldSize U1 :: Nat

type GConstructorCount U1 :: Nat

Methods

gPackFields :: Int -> U1 a -> (Int, BitVector (GFieldSize U1))

gUnpack :: Int -> Int -> BitVector (GFieldSize U1) -> U1 a

BitPack c => GBitPack (K1 i c :: Type -> Type)

Defined in Clash.Class.BitPack

Associated Types

type GFieldSize (K1 i c) :: Nat

type GConstructorCount (K1 i c) :: Nat

Methods

gPackFields :: Int -> K1 i c a -> (Int, BitVector (GFieldSize (K1 i c)))

gUnpack :: Int -> Int -> BitVector (GFieldSize (K1 i c)) -> K1 i c a

(KnownNat (GFieldSize g), KnownNat (GFieldSize f), KnownNat (GConstructorCount f), GBitPack f, GBitPack g) => GBitPack (f :+: g)

Defined in Clash.Class.BitPack

Associated Types

type GFieldSize (f :+: g) :: Nat

type GConstructorCount (f :+: g) :: Nat

Methods

gPackFields :: Int -> (f :+: g) a -> (Int, BitVector (GFieldSize (f :+: g)))

gUnpack :: Int -> Int -> BitVector (GFieldSize (f :+: g)) -> (f :+: g) a

(KnownNat (GFieldSize g), KnownNat (GFieldSize f), GBitPack f, GBitPack g) => GBitPack (f :*: g)

Defined in Clash.Class.BitPack

Associated Types

type GFieldSize (f :*: g) :: Nat

type GConstructorCount (f :*: g) :: Nat

Methods

gPackFields :: Int -> (f :*: g) a -> (Int, BitVector (GFieldSize (f :*: g)))

gUnpack :: Int -> Int -> BitVector (GFieldSize (f :*: g)) -> (f :*: g) a

GBitPack a => GBitPack (M1 m d a)

Defined in Clash.Class.BitPack

Associated Types

type GFieldSize (M1 m d a) :: Nat

type GConstructorCount (M1 m d a) :: Nat

Methods

gPackFields :: Int -> M1 m d a a0 -> (Int, BitVector (GFieldSize (M1 m d a)))

gUnpack :: Int -> Int -> BitVector (GFieldSize (M1 m d a)) -> M1 m d a a0