{-# LANGUAGE DeriveAnyClass #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}

-- |
-- Module      : Verismith.Verilog.BitVec
-- Description : Unsigned BitVec implementation.
-- Copyright   : (c) 2019, Yann Herklotz Grave
-- License     : GPL-3
-- Maintainer  : yann [at] yannherklotz [dot] com
-- Stability   : experimental
-- Portability : POSIX
--
-- Unsigned BitVec implementation.
module Verismith.Verilog.BitVec
  ( BitVecF (..),
    BitVec,
    bitVec,
    select,
  )
where

import Control.DeepSeq (NFData)
import Data.Bits
import Data.Data
import Data.Ratio
import GHC.Generics (Generic)

-- | Bit Vector that stores the bits in an arbitrary container together with the
-- size.
data BitVecF a = BitVec
  { forall a. BitVecF a -> Int
width :: {-# UNPACK #-} !Int,
    forall a. BitVecF a -> a
value :: !a
  }
  deriving (Int -> BitVecF a -> ShowS
[BitVecF a] -> ShowS
BitVecF a -> String
(Int -> BitVecF a -> ShowS)
-> (BitVecF a -> String)
-> ([BitVecF a] -> ShowS)
-> Show (BitVecF a)
forall a. Show a => Int -> BitVecF a -> ShowS
forall a. Show a => [BitVecF a] -> ShowS
forall a. Show a => BitVecF a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> BitVecF a -> ShowS
showsPrec :: Int -> BitVecF a -> ShowS
$cshow :: forall a. Show a => BitVecF a -> String
show :: BitVecF a -> String
$cshowList :: forall a. Show a => [BitVecF a] -> ShowS
showList :: [BitVecF a] -> ShowS
Show, BitVecF a -> BitVecF a -> Bool
(BitVecF a -> BitVecF a -> Bool)
-> (BitVecF a -> BitVecF a -> Bool) -> Eq (BitVecF a)
forall a. Eq a => BitVecF a -> BitVecF a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => BitVecF a -> BitVecF a -> Bool
== :: BitVecF a -> BitVecF a -> Bool
$c/= :: forall a. Eq a => BitVecF a -> BitVecF a -> Bool
/= :: BitVecF a -> BitVecF a -> Bool
Eq, Eq (BitVecF a)
Eq (BitVecF a) =>
(BitVecF a -> BitVecF a -> Ordering)
-> (BitVecF a -> BitVecF a -> Bool)
-> (BitVecF a -> BitVecF a -> Bool)
-> (BitVecF a -> BitVecF a -> Bool)
-> (BitVecF a -> BitVecF a -> Bool)
-> (BitVecF a -> BitVecF a -> BitVecF a)
-> (BitVecF a -> BitVecF a -> BitVecF a)
-> Ord (BitVecF a)
BitVecF a -> BitVecF a -> Bool
BitVecF a -> BitVecF a -> Ordering
BitVecF a -> BitVecF a -> BitVecF a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (BitVecF a)
forall a. Ord a => BitVecF a -> BitVecF a -> Bool
forall a. Ord a => BitVecF a -> BitVecF a -> Ordering
forall a. Ord a => BitVecF a -> BitVecF a -> BitVecF a
$ccompare :: forall a. Ord a => BitVecF a -> BitVecF a -> Ordering
compare :: BitVecF a -> BitVecF a -> Ordering
$c< :: forall a. Ord a => BitVecF a -> BitVecF a -> Bool
< :: BitVecF a -> BitVecF a -> Bool
$c<= :: forall a. Ord a => BitVecF a -> BitVecF a -> Bool
<= :: BitVecF a -> BitVecF a -> Bool
$c> :: forall a. Ord a => BitVecF a -> BitVecF a -> Bool
> :: BitVecF a -> BitVecF a -> Bool
$c>= :: forall a. Ord a => BitVecF a -> BitVecF a -> Bool
>= :: BitVecF a -> BitVecF a -> Bool
$cmax :: forall a. Ord a => BitVecF a -> BitVecF a -> BitVecF a
max :: BitVecF a -> BitVecF a -> BitVecF a
$cmin :: forall a. Ord a => BitVecF a -> BitVecF a -> BitVecF a
min :: BitVecF a -> BitVecF a -> BitVecF a
Ord, Typeable (BitVecF a)
Typeable (BitVecF a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BitVecF a -> c (BitVecF a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (BitVecF a))
-> (BitVecF a -> Constr)
-> (BitVecF a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (BitVecF a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (BitVecF a)))
-> ((forall b. Data b => b -> b) -> BitVecF a -> BitVecF a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BitVecF a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BitVecF a -> r)
-> (forall u. (forall d. Data d => d -> u) -> BitVecF a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BitVecF a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a))
-> Data (BitVecF a)
BitVecF a -> Constr
BitVecF a -> DataType
(forall b. Data b => b -> b) -> BitVecF a -> BitVecF a
forall a. Data a => Typeable (BitVecF a)
forall a. Data a => BitVecF a -> Constr
forall a. Data a => BitVecF a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> BitVecF a -> BitVecF a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> BitVecF a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> BitVecF a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BitVecF a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BitVecF a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BitVecF a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitVecF a -> c (BitVecF a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BitVecF a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BitVecF a))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BitVecF a -> u
forall u. (forall d. Data d => d -> u) -> BitVecF a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BitVecF a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BitVecF a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BitVecF a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitVecF a -> c (BitVecF a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BitVecF a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BitVecF a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitVecF a -> c (BitVecF a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BitVecF a -> c (BitVecF a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BitVecF a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (BitVecF a)
$ctoConstr :: forall a. Data a => BitVecF a -> Constr
toConstr :: BitVecF a -> Constr
$cdataTypeOf :: forall a. Data a => BitVecF a -> DataType
dataTypeOf :: BitVecF a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (BitVecF a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (BitVecF a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BitVecF a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (BitVecF a))
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> BitVecF a -> BitVecF a
gmapT :: (forall b. Data b => b -> b) -> BitVecF a -> BitVecF a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BitVecF a -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BitVecF a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BitVecF a -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BitVecF a -> r
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> BitVecF a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BitVecF a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> BitVecF a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BitVecF a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BitVecF a -> m (BitVecF a)
Data, (forall a b. (a -> b) -> BitVecF a -> BitVecF b)
-> (forall a b. a -> BitVecF b -> BitVecF a) -> Functor BitVecF
forall a b. a -> BitVecF b -> BitVecF a
forall a b. (a -> b) -> BitVecF a -> BitVecF b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> BitVecF a -> BitVecF b
fmap :: forall a b. (a -> b) -> BitVecF a -> BitVecF b
$c<$ :: forall a b. a -> BitVecF b -> BitVecF a
<$ :: forall a b. a -> BitVecF b -> BitVecF a
Functor, (forall m. Monoid m => BitVecF m -> m)
-> (forall m a. Monoid m => (a -> m) -> BitVecF a -> m)
-> (forall m a. Monoid m => (a -> m) -> BitVecF a -> m)
-> (forall a b. (a -> b -> b) -> b -> BitVecF a -> b)
-> (forall a b. (a -> b -> b) -> b -> BitVecF a -> b)
-> (forall b a. (b -> a -> b) -> b -> BitVecF a -> b)
-> (forall b a. (b -> a -> b) -> b -> BitVecF a -> b)
-> (forall a. (a -> a -> a) -> BitVecF a -> a)
-> (forall a. (a -> a -> a) -> BitVecF a -> a)
-> (forall a. BitVecF a -> [a])
-> (forall a. BitVecF a -> Bool)
-> (forall a. BitVecF a -> Int)
-> (forall a. Eq a => a -> BitVecF a -> Bool)
-> (forall a. Ord a => BitVecF a -> a)
-> (forall a. Ord a => BitVecF a -> a)
-> (forall a. Num a => BitVecF a -> a)
-> (forall a. Num a => BitVecF a -> a)
-> Foldable BitVecF
forall a. Eq a => a -> BitVecF a -> Bool
forall a. Num a => BitVecF a -> a
forall a. Ord a => BitVecF a -> a
forall m. Monoid m => BitVecF m -> m
forall a. BitVecF a -> Bool
forall a. BitVecF a -> Int
forall a. BitVecF a -> [a]
forall a. (a -> a -> a) -> BitVecF a -> a
forall m a. Monoid m => (a -> m) -> BitVecF a -> m
forall b a. (b -> a -> b) -> b -> BitVecF a -> b
forall a b. (a -> b -> b) -> b -> BitVecF a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => BitVecF m -> m
fold :: forall m. Monoid m => BitVecF m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> BitVecF a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> BitVecF a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> BitVecF a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> BitVecF a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> BitVecF a -> b
foldr :: forall a b. (a -> b -> b) -> b -> BitVecF a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> BitVecF a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> BitVecF a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> BitVecF a -> b
foldl :: forall b a. (b -> a -> b) -> b -> BitVecF a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> BitVecF a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> BitVecF a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> BitVecF a -> a
foldr1 :: forall a. (a -> a -> a) -> BitVecF a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> BitVecF a -> a
foldl1 :: forall a. (a -> a -> a) -> BitVecF a -> a
$ctoList :: forall a. BitVecF a -> [a]
toList :: forall a. BitVecF a -> [a]
$cnull :: forall a. BitVecF a -> Bool
null :: forall a. BitVecF a -> Bool
$clength :: forall a. BitVecF a -> Int
length :: forall a. BitVecF a -> Int
$celem :: forall a. Eq a => a -> BitVecF a -> Bool
elem :: forall a. Eq a => a -> BitVecF a -> Bool
$cmaximum :: forall a. Ord a => BitVecF a -> a
maximum :: forall a. Ord a => BitVecF a -> a
$cminimum :: forall a. Ord a => BitVecF a -> a
minimum :: forall a. Ord a => BitVecF a -> a
$csum :: forall a. Num a => BitVecF a -> a
sum :: forall a. Num a => BitVecF a -> a
$cproduct :: forall a. Num a => BitVecF a -> a
product :: forall a. Num a => BitVecF a -> a
Foldable, Functor BitVecF
Foldable BitVecF
(Functor BitVecF, Foldable BitVecF) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> BitVecF a -> f (BitVecF b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    BitVecF (f a) -> f (BitVecF a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> BitVecF a -> m (BitVecF b))
-> (forall (m :: * -> *) a.
    Monad m =>
    BitVecF (m a) -> m (BitVecF a))
-> Traversable BitVecF
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => BitVecF (m a) -> m (BitVecF a)
forall (f :: * -> *) a.
Applicative f =>
BitVecF (f a) -> f (BitVecF a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BitVecF a -> m (BitVecF b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BitVecF a -> f (BitVecF b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BitVecF a -> f (BitVecF b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> BitVecF a -> f (BitVecF b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
BitVecF (f a) -> f (BitVecF a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
BitVecF (f a) -> f (BitVecF a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BitVecF a -> m (BitVecF b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> BitVecF a -> m (BitVecF b)
$csequence :: forall (m :: * -> *) a. Monad m => BitVecF (m a) -> m (BitVecF a)
sequence :: forall (m :: * -> *) a. Monad m => BitVecF (m a) -> m (BitVecF a)
Traversable, (forall x. BitVecF a -> Rep (BitVecF a) x)
-> (forall x. Rep (BitVecF a) x -> BitVecF a)
-> Generic (BitVecF a)
forall x. Rep (BitVecF a) x -> BitVecF a
forall x. BitVecF a -> Rep (BitVecF a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (BitVecF a) x -> BitVecF a
forall a x. BitVecF a -> Rep (BitVecF a) x
$cfrom :: forall a x. BitVecF a -> Rep (BitVecF a) x
from :: forall x. BitVecF a -> Rep (BitVecF a) x
$cto :: forall a x. Rep (BitVecF a) x -> BitVecF a
to :: forall x. Rep (BitVecF a) x -> BitVecF a
Generic, BitVecF a -> ()
(BitVecF a -> ()) -> NFData (BitVecF a)
forall a. NFData a => BitVecF a -> ()
forall a. (a -> ()) -> NFData a
$crnf :: forall a. NFData a => BitVecF a -> ()
rnf :: BitVecF a -> ()
NFData)

-- | Specialisation of the above with Integer, so that infinitely large bit
-- vectors can be stored.
type BitVec = BitVecF Integer

instance (Enum a) => Enum (BitVecF a) where
  toEnum :: Int -> BitVecF a
toEnum Int
i = Int -> a -> BitVecF a
forall a. Int -> a -> BitVecF a
BitVec (Integer -> Int
width' (Integer -> Int) -> Integer -> Int
forall a b. (a -> b) -> a -> b
$ Int -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i) (a -> BitVecF a) -> a -> BitVecF a
forall a b. (a -> b) -> a -> b
$ Int -> a
forall a. Enum a => Int -> a
toEnum Int
i
  fromEnum :: BitVecF a -> Int
fromEnum (BitVec Int
_ a
v) = a -> Int
forall a. Enum a => a -> Int
fromEnum a
v

instance (Num a, Bits a) => Num (BitVecF a) where
  BitVec Int
w1 a
v1 + :: BitVecF a -> BitVecF a -> BitVecF a
+ BitVec Int
w2 a
v2 = Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
w1 Int
w2) (a
v1 a -> a -> a
forall a. Num a => a -> a -> a
+ a
v2)
  BitVec Int
w1 a
v1 - :: BitVecF a -> BitVecF a -> BitVecF a
- BitVec Int
w2 a
v2 = Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
w1 Int
w2) (a
v1 a -> a -> a
forall a. Num a => a -> a -> a
- a
v2)
  BitVec Int
w1 a
v1 * :: BitVecF a -> BitVecF a -> BitVecF a
* BitVec Int
w2 a
v2 = Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
w1 Int
w2) (a
v1 a -> a -> a
forall a. Num a => a -> a -> a
* a
v2)
  abs :: BitVecF a -> BitVecF a
abs = BitVecF a -> BitVecF a
forall a. a -> a
id
  signum :: BitVecF a -> BitVecF a
signum (BitVec Int
_ a
v) = if a
v a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
0 then Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec Int
1 a
0 else Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec Int
1 a
1
  fromInteger :: Integer -> BitVecF a
fromInteger Integer
i = Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec (Integer -> Int
width' Integer
i) (a -> BitVecF a) -> a -> BitVecF a
forall a b. (a -> b) -> a -> b
$ Integer -> a
forall a. Num a => Integer -> a
fromInteger Integer
i

instance (Integral a, Bits a) => Real (BitVecF a) where
  toRational :: BitVecF a -> Rational
toRational (BitVec Int
_ a
n) = a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
n Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
1

instance (Integral a, Bits a) => Integral (BitVecF a) where
  quotRem :: BitVecF a -> BitVecF a -> (BitVecF a, BitVecF a)
quotRem (BitVec Int
w1 a
v1) (BitVec Int
w2 a
v2) = (a -> BitVecF a) -> (a, a) -> (BitVecF a, BitVecF a)
forall a b. (a -> b) -> (a, a) -> (b, b)
both (Int -> a -> BitVecF a
forall a. Int -> a -> BitVecF a
BitVec (Int -> a -> BitVecF a) -> Int -> a -> BitVecF a
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
w1 Int
w2) ((a, a) -> (BitVecF a, BitVecF a))
-> (a, a) -> (BitVecF a, BitVecF a)
forall a b. (a -> b) -> a -> b
$ a -> a -> (a, a)
forall a. Integral a => a -> a -> (a, a)
quotRem a
v1 a
v2
  toInteger :: BitVecF a -> Integer
toInteger (BitVec Int
_ a
v) = a -> Integer
forall a. Integral a => a -> Integer
toInteger a
v

instance (Num a, Bits a) => Bits (BitVecF a) where
  BitVec Int
w1 a
v1 .&. :: BitVecF a -> BitVecF a -> BitVecF a
.&. BitVec Int
w2 a
v2 = Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
w1 Int
w2) (a
v1 a -> a -> a
forall a. Bits a => a -> a -> a
.&. a
v2)
  BitVec Int
w1 a
v1 .|. :: BitVecF a -> BitVecF a -> BitVecF a
.|. BitVec Int
w2 a
v2 = Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
w1 Int
w2) (a
v1 a -> a -> a
forall a. Bits a => a -> a -> a
.|. a
v2)
  BitVec Int
w1 a
v1 xor :: BitVecF a -> BitVecF a -> BitVecF a
`xor` BitVec Int
w2 a
v2 = Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
w1 Int
w2) (a
v1 a -> a -> a
forall a. Bits a => a -> a -> a
`xor` a
v2)
  complement :: BitVecF a -> BitVecF a
complement (BitVec Int
w a
v) = Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec Int
w (a -> BitVecF a) -> a -> BitVecF a
forall a b. (a -> b) -> a -> b
$ a -> a
forall a. Bits a => a -> a
complement a
v
  shift :: BitVecF a -> Int -> BitVecF a
shift (BitVec Int
w a
v) Int
i = Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec Int
w (a -> BitVecF a) -> a -> BitVecF a
forall a b. (a -> b) -> a -> b
$ a -> Int -> a
forall a. Bits a => a -> Int -> a
shift a
v Int
i
  rotate :: BitVecF a -> Int -> BitVecF a
rotate = BitVecF a -> Int -> BitVecF a
forall a. (Num a, Bits a) => BitVecF a -> Int -> BitVecF a
rotateBitVec
  bit :: Int -> BitVecF a
bit Int
i = Integer -> BitVecF a
forall a. Num a => Integer -> a
fromInteger (Integer -> BitVecF a) -> Integer -> BitVecF a
forall a b. (a -> b) -> a -> b
$ Int -> Integer
forall a. Bits a => Int -> a
bit Int
i
  testBit :: BitVecF a -> Int -> Bool
testBit (BitVec Int
_ a
v) = a -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit a
v
  bitSize :: BitVecF a -> Int
bitSize (BitVec Int
w a
_) = Int
w
  bitSizeMaybe :: BitVecF a -> Maybe Int
bitSizeMaybe (BitVec Int
w a
_) = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
w
  isSigned :: BitVecF a -> Bool
isSigned BitVecF a
_ = Bool
False
  popCount :: BitVecF a -> Int
popCount (BitVec Int
_ a
v) = a -> Int
forall a. Bits a => a -> Int
popCount a
v

instance (Num a, Bits a) => FiniteBits (BitVecF a) where
  finiteBitSize :: BitVecF a -> Int
finiteBitSize (BitVec Int
w a
_) = Int
w

instance (Bits a) => Semigroup (BitVecF a) where
  (BitVec Int
w1 a
v1) <> :: BitVecF a -> BitVecF a -> BitVecF a
<> (BitVec Int
w2 a
v2) = Int -> a -> BitVecF a
forall a. Int -> a -> BitVecF a
BitVec (Int
w1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
w2) (a -> Int -> a
forall a. Bits a => a -> Int -> a
shiftL a
v1 Int
w2 a -> a -> a
forall a. Bits a => a -> a -> a
.|. a
v2)

instance (Bits a) => Monoid (BitVecF a) where
  mempty :: BitVecF a
mempty = Int -> a -> BitVecF a
forall a. Int -> a -> BitVecF a
BitVec Int
0 a
forall a. Bits a => a
zeroBits

-- | BitVecF construction, given width and value.
bitVec :: (Num a, Bits a) => Int -> a -> BitVecF a
bitVec :: forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec Int
w a
v = Int -> a -> BitVecF a
forall a. Int -> a -> BitVecF a
BitVec Int
w' (a -> BitVecF a) -> a -> BitVecF a
forall a b. (a -> b) -> a -> b
$ a
v a -> a -> a
forall a. Bits a => a -> a -> a
.&. ((a
2 a -> Int -> a
forall a b. (Num a, Integral b) => a -> b -> a
^ Int
w') a -> a -> a
forall a. Num a => a -> a -> a
- a
1) where w' :: Int
w' = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
w Int
0

-- | Bit selection.  LSB is 0.
select ::
  (Integral a, Bits a, Integral b, Bits b) =>
  BitVecF a ->
  (BitVecF b, BitVecF b) ->
  BitVecF a
select :: forall a b.
(Integral a, Bits a, Integral b, Bits b) =>
BitVecF a -> (BitVecF b, BitVecF b) -> BitVecF a
select (BitVec Int
_ a
v) (BitVecF b
msb, BitVecF b
lsb) =
  Int -> a -> BitVecF a
forall a. (Num a, Bits a) => Int -> a -> BitVecF a
bitVec (BitVecF b -> Int
from (BitVecF b -> Int) -> BitVecF b -> Int
forall a b. (a -> b) -> a -> b
$ BitVecF b
msb BitVecF b -> BitVecF b -> BitVecF b
forall a. Num a => a -> a -> a
- BitVecF b
lsb BitVecF b -> BitVecF b -> BitVecF b
forall a. Num a => a -> a -> a
+ BitVecF b
1) (a -> BitVecF a) -> (Int -> a) -> Int -> BitVecF a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int -> a
forall a. Bits a => a -> Int -> a
shiftR (a -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
v) (Int -> BitVecF a) -> Int -> BitVecF a
forall a b. (a -> b) -> a -> b
$ BitVecF b -> Int
from BitVecF b
lsb
  where
    from :: BitVecF b -> Int
from = b -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (b -> Int) -> (BitVecF b -> b) -> BitVecF b -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BitVecF b -> b
forall a. BitVecF a -> a
value

-- | Rotate bits in a 'BitVec'.
rotateBitVec :: (Num a, Bits a) => BitVecF a -> Int -> BitVecF a
rotateBitVec :: forall a. (Num a, Bits a) => BitVecF a -> Int -> BitVecF a
rotateBitVec b :: BitVecF a
b@(BitVec Int
s a
_) Int
n
  | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 = (BitVecF a -> BitVecF a) -> BitVecF a -> [BitVecF a]
forall a. (a -> a) -> a -> [a]
iterate BitVecF a -> BitVecF a
forall a. Bits a => a -> a
rotateL1 BitVecF a
b [BitVecF a] -> Int -> BitVecF a
forall a. HasCallStack => [a] -> Int -> a
!! Int
n
  | Bool
otherwise = (BitVecF a -> BitVecF a) -> BitVecF a -> [BitVecF a]
forall a. (a -> a) -> a -> [a]
iterate BitVecF a -> BitVecF a
forall a. Bits a => a -> a
rotateR1 BitVecF a
b [BitVecF a] -> Int -> BitVecF a
forall a. HasCallStack => [a] -> Int -> a
!! Int -> Int
forall a. Num a => a -> a
abs Int
n
  where
    rotateR1 :: a -> a
rotateR1 a
n' = Int -> Int -> a -> a
forall {a} {a}. (Bits a, Bits a) => Int -> Int -> a -> a
testBits Int
0 (Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) a
n' a -> a -> a
forall a. Bits a => a -> a -> a
.|. a -> Int -> a
forall a. Bits a => a -> Int -> a
shiftR a
n' Int
1
    rotateL1 :: a -> a
rotateL1 a
n' = Int -> Int -> a -> a
forall {a} {a}. (Bits a, Bits a) => Int -> Int -> a -> a
testBits (Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Int
0 a
n' a -> a -> a
forall a. Bits a => a -> a -> a
.|. a -> Int -> a
forall a. Bits a => a -> Int -> a
shiftL a
n' Int
1
    testBits :: Int -> Int -> a -> a
testBits Int
a Int
b' a
n' = if a -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit a
n' Int
a then Int -> a
forall a. Bits a => Int -> a
bit Int
b' else a
forall a. Bits a => a
zeroBits

width' :: Integer -> Int
width' :: Integer -> Int
width' Integer
a
  | Integer
a Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0 = Int
1
  | Bool
otherwise = Integer -> Int
forall {t} {a}. (Num t, Num a, Bits t) => t -> a
width'' Integer
a
  where
    width'' :: t -> a
width'' t
a'
      | t
a' t -> t -> Bool
forall a. Eq a => a -> a -> Bool
== t
0 = a
0
      | t
a' t -> t -> Bool
forall a. Eq a => a -> a -> Bool
== -t
1 = a
1
      | Bool
otherwise = a
1 a -> a -> a
forall a. Num a => a -> a -> a
+ t -> a
width'' (t -> Int -> t
forall a. Bits a => a -> Int -> a
shiftR t
a' Int
1)

both :: (a -> b) -> (a, a) -> (b, b)
both :: forall a b. (a -> b) -> (a, a) -> (b, b)
both a -> b
f (a
a, a
b) = (a -> b
f a
a, a -> b
f a
b)