Copyright	(C) 2013-2016 University of Twente 2016-2017 Myrtle Software Ltd
License	BSD2 (see the file LICENSE)
Maintainer	Christiaan Baaij <christiaan.baaij@gmail.com>
Safe Haskell	Trustworthy
Language	Haskell2010
Extensions	Cpp UndecidableInstances MonoLocalBinds TemplateHaskell TemplateHaskellQuotes ScopedTypeVariables BangPatterns TypeFamilies ViewPatterns DataKinds InstanceSigs StandaloneDeriving DeriveDataTypeable DeriveFunctor DeriveTraversable DeriveFoldable DeriveGeneric DefaultSignatures DeriveLift DerivingStrategies FlexibleContexts MagicHash KindSignatures TupleSections TypeOperators ExplicitNamespaces ExplicitForAll BinaryLiterals TypeApplications

Clash.Class.BitPack

Description

Synopsis

class KnownNat (BitSize a) => BitPack a where
- type BitSize a :: Nat
- pack :: a -> BitVector (BitSize a)
- unpack :: BitVector (BitSize a) -> a
bitCoerce :: (BitPack a, BitPack b, BitSize a ~ BitSize b) => a -> b
bitCoerceMap :: forall a b. (BitPack a, BitPack b, BitSize a ~ BitSize b) => (a -> a) -> b -> b
boolToBV :: KnownNat n => Bool -> BitVector (n + 1)
boolToBit :: Bool -> Bit
bitToBool :: Bit -> Bool
packXWith :: KnownNat n => (a -> BitVector n) -> a -> BitVector n

Documentation

class KnownNat (BitSize a) => BitPack a where Source #

Convert to and from a BitVector

Minimal complete definition

Nothing

Associated Types

type BitSize a :: Nat Source #

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) Source #

Methods

pack :: a -> BitVector (BitSize a) Source #

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) Source #

unpack :: BitVector (BitSize a) -> a Source #

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 Source #

Instances

Instances details

BitPack Bool Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Bool :: Nat Source # Methods pack :: Bool -> BitVector (BitSize Bool) Source # unpack :: BitVector (BitSize Bool) -> Bool Source #
BitPack Double Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Double :: Nat Source # Methods pack :: Double -> BitVector (BitSize Double) Source # unpack :: BitVector (BitSize Double) -> Double Source #
BitPack Float Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Float :: Nat Source # Methods pack :: Float -> BitVector (BitSize Float) Source # unpack :: BitVector (BitSize Float) -> Float Source #
BitPack Int Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Int :: Nat Source # Methods pack :: Int -> BitVector (BitSize Int) Source # unpack :: BitVector (BitSize Int) -> Int Source #
BitPack Int8 Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Int8 :: Nat Source # Methods pack :: Int8 -> BitVector (BitSize Int8) Source # unpack :: BitVector (BitSize Int8) -> Int8 Source #
BitPack Int16 Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Int16 :: Nat Source # Methods pack :: Int16 -> BitVector (BitSize Int16) Source # unpack :: BitVector (BitSize Int16) -> Int16 Source #
BitPack Int32 Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Int32 :: Nat Source # Methods pack :: Int32 -> BitVector (BitSize Int32) Source # unpack :: BitVector (BitSize Int32) -> Int32 Source #
BitPack Int64 Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Int64 :: Nat Source # Methods pack :: Int64 -> BitVector (BitSize Int64) Source # unpack :: BitVector (BitSize Int64) -> Int64 Source #
BitPack Word Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Word :: Nat Source # Methods pack :: Word -> BitVector (BitSize Word) Source # unpack :: BitVector (BitSize Word) -> Word Source #
BitPack Word8 Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Word8 :: Nat Source # Methods pack :: Word8 -> BitVector (BitSize Word8) Source # unpack :: BitVector (BitSize Word8) -> Word8 Source #
BitPack Word16 Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Word16 :: Nat Source # Methods pack :: Word16 -> BitVector (BitSize Word16) Source # unpack :: BitVector (BitSize Word16) -> Word16 Source #
BitPack Word32 Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Word32 :: Nat Source # Methods pack :: Word32 -> BitVector (BitSize Word32) Source # unpack :: BitVector (BitSize Word32) -> Word32 Source #
BitPack Word64 Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Word64 :: Nat Source # Methods pack :: Word64 -> BitVector (BitSize Word64) Source # unpack :: BitVector (BitSize Word64) -> Word64 Source #
BitPack () Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize () :: Nat Source # Methods pack :: () -> BitVector (BitSize ()) Source # unpack :: BitVector (BitSize ()) -> () Source #
BitPack CUShort Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize CUShort :: Nat Source # Methods pack :: CUShort -> BitVector (BitSize CUShort) Source # unpack :: BitVector (BitSize CUShort) -> CUShort Source #
BitPack Half Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Half :: Nat Source # Methods pack :: Half -> BitVector (BitSize Half) Source # unpack :: BitVector (BitSize Half) -> Half Source #
BitPack Bit Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize Bit :: Nat Source # Methods pack :: Bit -> BitVector (BitSize Bit) Source # unpack :: BitVector (BitSize Bit) -> Bit Source #
BitPack a => BitPack (Maybe a) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (Maybe a) :: Nat Source # Methods pack :: Maybe a -> BitVector (BitSize (Maybe a)) Source # unpack :: BitVector (BitSize (Maybe a)) -> Maybe a Source #
BitPack a => BitPack (Complex a) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (Complex a) :: Nat Source # Methods pack :: Complex a -> BitVector (BitSize (Complex a)) Source # unpack :: BitVector (BitSize (Complex a)) -> Complex a Source #
BitPack a => BitPack (Down a) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (Down a) :: Nat Source # Methods pack :: Down a -> BitVector (BitSize (Down a)) Source # unpack :: BitVector (BitSize (Down a)) -> Down a Source #
KnownNat n => BitPack (BitVector n) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (BitVector n) :: Nat Source # Methods pack :: BitVector n -> BitVector (BitSize (BitVector n)) Source # unpack :: BitVector (BitSize (BitVector n)) -> BitVector n Source #
(KnownNat n, 1 <= n) => BitPack (Index n) Source #
Instance details Defined in Clash.Sized.Internal.Index Associated Types type BitSize (Index n) :: Nat Source # Methods pack :: Index n -> BitVector (BitSize (Index n)) Source # unpack :: BitVector (BitSize (Index n)) -> Index n Source #
KnownNat n => BitPack (Unsigned n) Source #
Instance details Defined in Clash.Sized.Internal.Unsigned Associated Types type BitSize (Unsigned n) :: Nat Source # Methods pack :: Unsigned n -> BitVector (BitSize (Unsigned n)) Source # unpack :: BitVector (BitSize (Unsigned n)) -> Unsigned n Source #
KnownNat n => BitPack (Signed n) Source #
Instance details Defined in Clash.Sized.Internal.Signed Associated Types type BitSize (Signed n) :: Nat Source # Methods pack :: Signed n -> BitVector (BitSize (Signed n)) Source # unpack :: BitVector (BitSize (Signed n)) -> Signed n Source #
(BitPack a, BitPack b) => BitPack (Either a b) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (Either a b) :: Nat Source # Methods pack :: Either a b -> BitVector (BitSize (Either a b)) Source # unpack :: BitVector (BitSize (Either a b)) -> Either a b Source #
(BitPack a, BitPack b) => BitPack (a, b) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a, b) :: Nat Source # Methods pack :: (a, b) -> BitVector (BitSize (a, b)) Source # unpack :: BitVector (BitSize (a, b)) -> (a, b) Source #
(KnownNat n, BitPack a) => BitPack (Vec n a) Source #
Instance details Defined in Clash.Sized.Vector Associated Types type BitSize (Vec n a) :: Nat Source # Methods pack :: Vec n a -> BitVector (BitSize (Vec n a)) Source # unpack :: BitVector (BitSize (Vec n a)) -> Vec n a Source #
(KnownNat d, BitPack a) => BitPack (RTree d a) Source #
Instance details Defined in Clash.Sized.RTree Associated Types type BitSize (RTree d a) :: Nat Source # Methods pack :: RTree d a -> BitVector (BitSize (RTree d a)) Source # unpack :: BitVector (BitSize (RTree d a)) -> RTree d a Source #
(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3), KnownNat (BitSize (a2, a3))) => BitPack (a1, a2, a3) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3) :: Nat Source # Methods pack :: (a1, a2, a3) -> BitVector (BitSize (a1, a2, a3)) Source # unpack :: BitVector (BitSize (a1, a2, a3)) -> (a1, a2, a3) Source #
BitPack (rep (int + frac)) => BitPack (Fixed rep int frac) Source #
Instance details Defined in Clash.Sized.Fixed Associated Types type BitSize (Fixed rep int frac) :: Nat Source # Methods pack :: Fixed rep int frac -> BitVector (BitSize (Fixed rep int frac)) Source # unpack :: BitVector (BitSize (Fixed rep int frac)) -> Fixed rep int frac Source #
(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4), KnownNat (BitSize (a2, a3, a4))) => BitPack (a1, a2, a3, a4) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3, a4) :: Nat Source # Methods pack :: (a1, a2, a3, a4) -> BitVector (BitSize (a1, a2, a3, a4)) Source # unpack :: BitVector (BitSize (a1, a2, a3, a4)) -> (a1, a2, a3, a4) Source #
(BitPack a1, KnownNat (BitSize a1), BitPack (a2, a3, a4, a5), KnownNat (BitSize (a2, a3, a4, a5))) => BitPack (a1, a2, a3, a4, a5) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3, a4, a5) :: Nat Source # Methods pack :: (a1, a2, a3, a4, a5) -> BitVector (BitSize (a1, a2, a3, a4, a5)) Source # unpack :: BitVector (BitSize (a1, a2, a3, a4, a5)) -> (a1, a2, a3, a4, a5) Source #
(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) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3, a4, a5, a6) :: Nat Source # Methods pack :: (a1, a2, a3, a4, a5, a6) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6)) Source # unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6)) -> (a1, a2, a3, a4, a5, a6) Source #
(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) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3, a4, a5, a6, a7) :: Nat Source # Methods pack :: (a1, a2, a3, a4, a5, a6, a7) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7)) Source # unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7)) -> (a1, a2, a3, a4, a5, a6, a7) Source #
(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) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3, a4, a5, a6, a7, a8) :: Nat Source # Methods pack :: (a1, a2, a3, a4, a5, a6, a7, a8) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8)) Source # unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8)) -> (a1, a2, a3, a4, a5, a6, a7, a8) Source #
(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) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9) :: Nat Source # Methods pack :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9)) Source # unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9) Source #
(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) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) :: Nat Source # Methods pack :: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) -> BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)) Source # unpack :: BitVector (BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)) -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) Source #
(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) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) :: Nat Source # 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)) Source # 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) Source #
(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) Source #
Instance details Defined in Clash.Class.BitPack Associated Types type BitSize (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12) :: Nat Source # 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)) Source # 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) Source #

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

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 Source #

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) Source #

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 Source #

Convert a Bool to a Bit

bitToBool :: Bit -> Bool Source #

Convert a Bool to a Bit

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