Data.PrimitiveArray.Index.Set

Set with and without interfaces. We provide instances for sets, and sets with one or two interfaces. The First and Last annotation is purely cosmetical (apart from introducing type safety).

newtypes, data types, classes.

newtype Interface t

Certain sets have an interface, a particular element with special meaning. In this module, certain `meanings' are already provided. These include a First element and a Last element. We phantom-type these to reduce programming overhead.

Constructors

Iter

Fields

• getIter :: Int

Instances

Vector Vector (Interface t0)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Interface t0) -> m (Vector (Interface t0))

basicUnsafeThaw :: PrimMonad m => Vector (Interface t0) -> m (Mutable Vector (PrimState m) (Interface t0))

basicLength :: Vector (Interface t0) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Interface t0) -> Vector (Interface t0)

basicUnsafeIndexM :: Monad m => Vector (Interface t0) -> Int -> m (Interface t0)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Interface t0) -> Vector (Interface t0) -> m ()

elemseq :: Vector (Interface t0) -> Interface t0 -> b -> b

MVector MVector (Interface t0)

Methods

basicLength :: MVector s (Interface t0) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Interface t0) -> MVector s (Interface t0)

basicOverlaps :: MVector s (Interface t0) -> MVector s (Interface t0) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Interface t0))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Interface t0) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Interface t0 -> m (MVector (PrimState m) (Interface t0))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Interface t0) -> Int -> m (Interface t0)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Interface t0) -> Int -> Interface t0 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Interface t0) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Interface t0) -> Interface t0 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Interface t0) -> MVector (PrimState m) (Interface t0) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Interface t0) -> MVector (PrimState m) (Interface t0) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Interface t0) -> Int -> m (MVector (PrimState m) (Interface t0))

Eq (Interface t)

Methods

(==) :: Interface t -> Interface t -> Bool

(/=) :: Interface t -> Interface t -> Bool

Num (Interface t)

Methods

(+) :: Interface t -> Interface t -> Interface t

(-) :: Interface t -> Interface t -> Interface t

(*) :: Interface t -> Interface t -> Interface t

negate :: Interface t -> Interface t

abs :: Interface t -> Interface t

signum :: Interface t -> Interface t

fromInteger :: Integer -> Interface t

Ord (Interface t)

Methods

compare :: Interface t -> Interface t -> Ordering

(<) :: Interface t -> Interface t -> Bool

(<=) :: Interface t -> Interface t -> Bool

(>) :: Interface t -> Interface t -> Bool

(>=) :: Interface t -> Interface t -> Bool

max :: Interface t -> Interface t -> Interface t

min :: Interface t -> Interface t -> Interface t

Show (Interface t)

Methods

showsPrec :: Int -> Interface t -> ShowS

show :: Interface t -> String

showList :: [Interface t] -> ShowS

Generic (Interface t)

Associated Types

type Rep (Interface t) :: * -> *

Methods

from :: Interface t -> Rep (Interface t) x

to :: Rep (Interface t) x -> Interface t

Hashable (Interface t)

Methods

hashWithSalt :: Int -> Interface t -> Int

hash :: Interface t -> Int

FromJSON (Interface t)

Methods

parseJSON :: Value -> Parser (Interface t)

parseJSONList :: Value -> Parser [Interface t]

ToJSON (Interface t)

Methods

toJSON :: Interface t -> Value

toEncoding :: Interface t -> Encoding

toJSONList :: [Interface t] -> Value

toEncodingList :: [Interface t] -> Encoding

Binary (Interface t)

Methods

put :: Interface t -> Put

get :: Get (Interface t)

putList :: [Interface t] -> Put

Serialize (Interface t)

Methods

put :: Putter (Interface t)

get :: Get (Interface t)

NFData (Interface t)

Methods

rnf :: Interface t -> ()

Unbox (Interface t0)

Index (Interface i)

Methods

linearIndex :: Interface i -> Interface i -> Interface i -> Int

smallestLinearIndex :: Interface i -> Int

largestLinearIndex :: Interface i -> Int

size :: Interface i -> Interface i -> Int

inBounds :: Interface i -> Interface i -> Interface i -> Bool

data MVector s (Interface t0)

data MVector s (Interface t0) = MV_Interface (MVector s Int)

type Rep (Interface t)

type Rep (Interface t) = D1 (MetaData "Interface" "Data.PrimitiveArray.Index.Set" "PrimitiveArray-0.7.1.0-B4A9oZDNxHW51HjshiHgYe" True) (C1 (MetaCons "Iter" PrefixI True) (S1 (MetaSel (Just Symbol "getIter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

data Vector (Interface t0)

data Vector (Interface t0) = V_Interface (Vector Int)

data First

Declare the interface to be the start of a path.

data Last

Declare the interface to be the end of a path.

data Any

Declare the interface to match anything.

TODO needed? want to use later in ADPfusion

newtype BitSet t

Newtype for a bitset. We'd use Words but that requires more shape instances.

TODO can we use Words now?

Constructors

BitSet

Fields

• getBitSet :: Int

Instances

Vector Vector (BitSet t0)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (BitSet t0) -> m (Vector (BitSet t0))

basicUnsafeThaw :: PrimMonad m => Vector (BitSet t0) -> m (Mutable Vector (PrimState m) (BitSet t0))

basicLength :: Vector (BitSet t0) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (BitSet t0) -> Vector (BitSet t0)

basicUnsafeIndexM :: Monad m => Vector (BitSet t0) -> Int -> m (BitSet t0)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (BitSet t0) -> Vector (BitSet t0) -> m ()

elemseq :: Vector (BitSet t0) -> BitSet t0 -> b -> b

MVector MVector (BitSet t0)

Methods

basicLength :: MVector s (BitSet t0) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (BitSet t0) -> MVector s (BitSet t0)

basicOverlaps :: MVector s (BitSet t0) -> MVector s (BitSet t0) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (BitSet t0))

basicInitialize :: PrimMonad m => MVector (PrimState m) (BitSet t0) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> BitSet t0 -> m (MVector (PrimState m) (BitSet t0))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (BitSet t0) -> Int -> m (BitSet t0)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (BitSet t0) -> Int -> BitSet t0 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (BitSet t0) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (BitSet t0) -> BitSet t0 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (BitSet t0) -> MVector (PrimState m) (BitSet t0) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (BitSet t0) -> MVector (PrimState m) (BitSet t0) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (BitSet t0) -> Int -> m (MVector (PrimState m) (BitSet t0))

Eq (BitSet t)

Methods

(==) :: BitSet t -> BitSet t -> Bool

(/=) :: BitSet t -> BitSet t -> Bool

Num (BitSet t)

Methods

(+) :: BitSet t -> BitSet t -> BitSet t

(-) :: BitSet t -> BitSet t -> BitSet t

(*) :: BitSet t -> BitSet t -> BitSet t

negate :: BitSet t -> BitSet t

abs :: BitSet t -> BitSet t

signum :: BitSet t -> BitSet t

fromInteger :: Integer -> BitSet t

Ord (BitSet t)

Methods

compare :: BitSet t -> BitSet t -> Ordering

(<) :: BitSet t -> BitSet t -> Bool

(<=) :: BitSet t -> BitSet t -> Bool

(>) :: BitSet t -> BitSet t -> Bool

(>=) :: BitSet t -> BitSet t -> Bool

max :: BitSet t -> BitSet t -> BitSet t

min :: BitSet t -> BitSet t -> BitSet t

Read (BitSet t)

Methods

readsPrec :: Int -> ReadS (BitSet t)

readList :: ReadS [BitSet t]

readPrec :: ReadPrec (BitSet t)

readListPrec :: ReadPrec [BitSet t]

Show (BitSet t)

Methods

showsPrec :: Int -> BitSet t -> ShowS

show :: BitSet t -> String

showList :: [BitSet t] -> ShowS

Generic (BitSet t)

Associated Types

type Rep (BitSet t) :: * -> *

Methods

from :: BitSet t -> Rep (BitSet t) x

to :: Rep (BitSet t) x -> BitSet t

Arbitrary (BitSet t)

Methods

arbitrary :: Gen (BitSet t)

shrink :: BitSet t -> [BitSet t]

Hashable (BitSet t)

Methods

hashWithSalt :: Int -> BitSet t -> Int

hash :: BitSet t -> Int

FromJSON (BitSet t)

Methods

parseJSON :: Value -> Parser (BitSet t)

parseJSONList :: Value -> Parser [BitSet t]

ToJSON (BitSet t)

Methods

toJSON :: BitSet t -> Value

toEncoding :: BitSet t -> Encoding

toJSONList :: [BitSet t] -> Value

toEncodingList :: [BitSet t] -> Encoding

Bits (BitSet t)

Methods

(.&.) :: BitSet t -> BitSet t -> BitSet t

(.|.) :: BitSet t -> BitSet t -> BitSet t

xor :: BitSet t -> BitSet t -> BitSet t

complement :: BitSet t -> BitSet t

shift :: BitSet t -> Int -> BitSet t

rotate :: BitSet t -> Int -> BitSet t

zeroBits :: BitSet t

bit :: Int -> BitSet t

setBit :: BitSet t -> Int -> BitSet t

clearBit :: BitSet t -> Int -> BitSet t

complementBit :: BitSet t -> Int -> BitSet t

testBit :: BitSet t -> Int -> Bool

bitSizeMaybe :: BitSet t -> Maybe Int

bitSize :: BitSet t -> Int

isSigned :: BitSet t -> Bool

shiftL :: BitSet t -> Int -> BitSet t

unsafeShiftL :: BitSet t -> Int -> BitSet t

shiftR :: BitSet t -> Int -> BitSet t

unsafeShiftR :: BitSet t -> Int -> BitSet t

rotateL :: BitSet t -> Int -> BitSet t

rotateR :: BitSet t -> Int -> BitSet t

popCount :: BitSet t -> Int

FiniteBits (BitSet t)

Methods

finiteBitSize :: BitSet t -> Int

countLeadingZeros :: BitSet t -> Int

countTrailingZeros :: BitSet t -> Int

Binary (BitSet t)

Methods

put :: BitSet t -> Put

get :: Get (BitSet t)

putList :: [BitSet t] -> Put

Ranked (BitSet t)

Methods

lsb :: BitSet t -> Int

rank :: BitSet t -> Int

nlz :: BitSet t -> Int

Serialize (BitSet t)

Methods

put :: Putter (BitSet t)

get :: Get (BitSet t)

NFData (BitSet t)

Methods

rnf :: BitSet t -> ()

Unbox (BitSet t0)

IndexStream ((:.) Z (BitSet t)) => IndexStream (BitSet t)

Methods

streamUp :: Monad m => BitSet t -> BitSet t -> Stream m (BitSet t)

streamDown :: Monad m => BitSet t -> BitSet t -> Stream m (BitSet t)

Index (BitSet t)

Methods

linearIndex :: BitSet t -> BitSet t -> BitSet t -> Int

smallestLinearIndex :: BitSet t -> Int

largestLinearIndex :: BitSet t -> Int

size :: BitSet t -> BitSet t -> Int

inBounds :: BitSet t -> BitSet t -> BitSet t -> Bool

ApplyMask (BitSet t)

Methods

applyMask :: Mask (BitSet t) -> BitSet t -> BitSet t

SetPredSucc (Fixed (BitSet t))

Methods

setSucc :: Fixed (BitSet t) -> Fixed (BitSet t) -> Fixed (BitSet t) -> Maybe (Fixed (BitSet t))

setPred :: Fixed (BitSet t) -> Fixed (BitSet t) -> Fixed (BitSet t) -> Maybe (Fixed (BitSet t))

SetPredSucc (BitSet t)

Methods

setSucc :: BitSet t -> BitSet t -> BitSet t -> Maybe (BitSet t)

setPred :: BitSet t -> BitSet t -> BitSet t -> Maybe (BitSet t)

IndexStream z => IndexStream ((:.) z (BitSet C))

Methods

streamUp :: Monad m => (z :. BitSet C) -> (z :. BitSet C) -> Stream m (z :. BitSet C)

streamDown :: Monad m => (z :. BitSet C) -> (z :. BitSet C) -> Stream m (z :. BitSet C)

IndexStream z => IndexStream ((:.) z (BitSet O))

Methods

streamUp :: Monad m => (z :. BitSet O) -> (z :. BitSet O) -> Stream m (z :. BitSet O)

streamDown :: Monad m => (z :. BitSet O) -> (z :. BitSet O) -> Stream m (z :. BitSet O)

IndexStream z => IndexStream ((:.) z (BitSet I))

Methods

streamUp :: Monad m => (z :. BitSet I) -> (z :. BitSet I) -> Stream m (z :. BitSet I)

streamDown :: Monad m => (z :. BitSet I) -> (z :. BitSet I) -> Stream m (z :. BitSet I)

data MVector s (BitSet t0)

data MVector s (BitSet t0) = MV_BitSet (MVector s Int)

type Rep (BitSet t)

type Rep (BitSet t) = D1 (MetaData "BitSet" "Data.PrimitiveArray.Index.Set" "PrimitiveArray-0.7.1.0-B4A9oZDNxHW51HjshiHgYe" True) (C1 (MetaCons "BitSet" PrefixI True) (S1 (MetaSel (Just Symbol "getBitSet") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Int)))

data Vector (BitSet t0)

data Vector (BitSet t0) = V_BitSet (Vector Int)

type Mask (BitSet t)

type Mask (BitSet t) = BitSet t

bitSetI :: Int -> BitSet I

bitSetO :: Int -> BitSet O

bitSetC :: Int -> BitSet C

data BS1 i t

A bitset with one interface.

Constructors

BS1 !(BitSet t) !(Interface i)

Instances

SetPredSucc (Fixed (BS1 i t))

Methods

setSucc :: Fixed (BS1 i t) -> Fixed (BS1 i t) -> Fixed (BS1 i t) -> Maybe (Fixed (BS1 i t))

setPred :: Fixed (BS1 i t) -> Fixed (BS1 i t) -> Fixed (BS1 i t) -> Maybe (Fixed (BS1 i t))

Show (BS1 i t)

Methods

showsPrec :: Int -> BS1 i t -> ShowS

show :: BS1 i t -> String

showList :: [BS1 i t] -> ShowS

Arbitrary (BS1 i t)

Methods

arbitrary :: Gen (BS1 i t)

shrink :: BS1 i t -> [BS1 i t]

IndexStream z => IndexStream ((:.) z (BS1 i C))

Methods

streamUp :: Monad m => (z :. BS1 i C) -> (z :. BS1 i C) -> Stream m (z :. BS1 i C)

streamDown :: Monad m => (z :. BS1 i C) -> (z :. BS1 i C) -> Stream m (z :. BS1 i C)

IndexStream z => IndexStream ((:.) z (BS1 i O))

Methods

streamUp :: Monad m => (z :. BS1 i O) -> (z :. BS1 i O) -> Stream m (z :. BS1 i O)

streamDown :: Monad m => (z :. BS1 i O) -> (z :. BS1 i O) -> Stream m (z :. BS1 i O)

IndexStream z => IndexStream ((:.) z (BS1 i I))

Methods

streamUp :: Monad m => (z :. BS1 i I) -> (z :. BS1 i I) -> Stream m (z :. BS1 i I)

streamDown :: Monad m => (z :. BS1 i I) -> (z :. BS1 i I) -> Stream m (z :. BS1 i I)

IndexStream ((:.) Z (BS1 i t)) => IndexStream (BS1 i t)

Methods

streamUp :: Monad m => BS1 i t -> BS1 i t -> Stream m (BS1 i t)

streamDown :: Monad m => BS1 i t -> BS1 i t -> Stream m (BS1 i t)

Index (BS1 i t)

Methods

linearIndex :: BS1 i t -> BS1 i t -> BS1 i t -> Int

smallestLinearIndex :: BS1 i t -> Int

largestLinearIndex :: BS1 i t -> Int

size :: BS1 i t -> BS1 i t -> Int

inBounds :: BS1 i t -> BS1 i t -> BS1 i t -> Bool

ApplyMask (BS1 i t)

Methods

applyMask :: Mask (BS1 i t) -> BS1 i t -> BS1 i t

SetPredSucc (BS1 i t)

Methods

setSucc :: BS1 i t -> BS1 i t -> BS1 i t -> Maybe (BS1 i t)

setPred :: BS1 i t -> BS1 i t -> BS1 i t -> Maybe (BS1 i t)

type Mask (BS1 i t)

type Mask (BS1 i t) = BitSet t

data BS2 i j t

A bitset with two interfaces.

Constructors

BS2 !(BitSet t) !(Interface i) !(Interface j)

Instances

SetPredSucc (Fixed (BS2 i j t))

Methods

setSucc :: Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Maybe (Fixed (BS2 i j t))

setPred :: Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Maybe (Fixed (BS2 i j t))

IndexStream z => IndexStream ((:.) z (BS2 i j C))

Methods

streamUp :: Monad m => (z :. BS2 i j C) -> (z :. BS2 i j C) -> Stream m (z :. BS2 i j C)

streamDown :: Monad m => (z :. BS2 i j C) -> (z :. BS2 i j C) -> Stream m (z :. BS2 i j C)

IndexStream z => IndexStream ((:.) z (BS2 i j O))

Methods

streamUp :: Monad m => (z :. BS2 i j O) -> (z :. BS2 i j O) -> Stream m (z :. BS2 i j O)

streamDown :: Monad m => (z :. BS2 i j O) -> (z :. BS2 i j O) -> Stream m (z :. BS2 i j O)

IndexStream z => IndexStream ((:.) z (BS2 i j I))

Methods

streamUp :: Monad m => (z :. BS2 i j I) -> (z :. BS2 i j I) -> Stream m (z :. BS2 i j I)

streamDown :: Monad m => (z :. BS2 i j I) -> (z :. BS2 i j I) -> Stream m (z :. BS2 i j I)

Show (BS2 i j t)

Methods

showsPrec :: Int -> BS2 i j t -> ShowS

show :: BS2 i j t -> String

showList :: [BS2 i j t] -> ShowS

Arbitrary (BS2 i j t)

Methods

arbitrary :: Gen (BS2 i j t)

shrink :: BS2 i j t -> [BS2 i j t]

IndexStream ((:.) Z (BS2 i j t)) => IndexStream (BS2 i j t)

Methods

streamUp :: Monad m => BS2 i j t -> BS2 i j t -> Stream m (BS2 i j t)

streamDown :: Monad m => BS2 i j t -> BS2 i j t -> Stream m (BS2 i j t)

Index (BS2 i j t)

Methods

linearIndex :: BS2 i j t -> BS2 i j t -> BS2 i j t -> Int

smallestLinearIndex :: BS2 i j t -> Int

largestLinearIndex :: BS2 i j t -> Int

size :: BS2 i j t -> BS2 i j t -> Int

inBounds :: BS2 i j t -> BS2 i j t -> BS2 i j t -> Bool

ApplyMask (BS2 i j t)

Methods

applyMask :: Mask (BS2 i j t) -> BS2 i j t -> BS2 i j t

SetPredSucc (BS2 i j t)

Methods

setSucc :: BS2 i j t -> BS2 i j t -> BS2 i j t -> Maybe (BS2 i j t)

setPred :: BS2 i j t -> BS2 i j t -> BS2 i j t -> Maybe (BS2 i j t)

type Mask (BS2 i j t)

type Mask (BS2 i j t) = BitSet t

class SetPredSucc s where

Successor and Predecessor for sets. Designed as a class to accomodate sets with interfaces and without interfaces with one function.

The functions are not written recursively, as we currently only have three cases, and we do not want to "reset" while generating successors and predecessors.

Note that sets have a partial order. Within the group of element with the same popCount, we use popPermutation which has the same stepping order for both, setSucc and setPred.

Minimal complete definition

setSucc, setPred

Methods

setSucc :: s -> s -> s -> Maybe s

Set successor. The first argument is the lower set limit, the second the upper set limit, the third the current set.

setPred :: s -> s -> s -> Maybe s

Set predecessor. The first argument is the lower set limit, the second the upper set limit, the third the current set.

Instances

SetPredSucc (Fixed (BS2 i j t))

Methods

setSucc :: Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Maybe (Fixed (BS2 i j t))

setPred :: Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Maybe (Fixed (BS2 i j t))

SetPredSucc (Fixed (BS1 i t))

Methods

setSucc :: Fixed (BS1 i t) -> Fixed (BS1 i t) -> Fixed (BS1 i t) -> Maybe (Fixed (BS1 i t))

setPred :: Fixed (BS1 i t) -> Fixed (BS1 i t) -> Fixed (BS1 i t) -> Maybe (Fixed (BS1 i t))

SetPredSucc (Fixed (BitSet t))

Methods

setSucc :: Fixed (BitSet t) -> Fixed (BitSet t) -> Fixed (BitSet t) -> Maybe (Fixed (BitSet t))

setPred :: Fixed (BitSet t) -> Fixed (BitSet t) -> Fixed (BitSet t) -> Maybe (Fixed (BitSet t))

SetPredSucc (BitSet t)

Methods

setSucc :: BitSet t -> BitSet t -> BitSet t -> Maybe (BitSet t)

setPred :: BitSet t -> BitSet t -> BitSet t -> Maybe (BitSet t)

SetPredSucc (BS1 i t)

Methods

setSucc :: BS1 i t -> BS1 i t -> BS1 i t -> Maybe (BS1 i t)

setPred :: BS1 i t -> BS1 i t -> BS1 i t -> Maybe (BS1 i t)

SetPredSucc (BS2 i j t)

Methods

setSucc :: BS2 i j t -> BS2 i j t -> BS2 i j t -> Maybe (BS2 i j t)

setPred :: BS2 i j t -> BS2 i j t -> BS2 i j t -> Maybe (BS2 i j t)

type family Mask s :: *

Masks are used quite often for different types of bitsets. We liberate them as a type family.

Instances

type Mask (BitSet t)

type Mask (BitSet t) = BitSet t

type Mask (BS1 i t)

type Mask (BS1 i t) = BitSet t

type Mask (BS2 i j t)

type Mask (BS2 i j t) = BitSet t

data Fixed t

Fixed allows us to fix some or all bits of a bitset, thereby providing succ/pred operations which are only partially free.

The mask is lazy, this allows us to have undefined for l and h.

f = getFixedMask .&. getFixed are the fixed bits. n = getFixed .&. complement getFixedMask are the free bits. to = complement getFixed is the to move mask n' = popShiftR to n yields the population after the move p = popPermutation undefined n' yields the new population permutation p' = popShiftL to p yields the population moved back final = p' .|. f

Constructors

Fixed

Fields

• getFixedMask :: Mask t
• getFixed :: !t

Instances

(Unbox t0, Unbox (Mask t0)) => Vector Vector (Fixed t0)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Fixed t0) -> m (Vector (Fixed t0))

basicUnsafeThaw :: PrimMonad m => Vector (Fixed t0) -> m (Mutable Vector (PrimState m) (Fixed t0))

basicLength :: Vector (Fixed t0) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Fixed t0) -> Vector (Fixed t0)

basicUnsafeIndexM :: Monad m => Vector (Fixed t0) -> Int -> m (Fixed t0)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Fixed t0) -> Vector (Fixed t0) -> m ()

elemseq :: Vector (Fixed t0) -> Fixed t0 -> b -> b

(Unbox t0, Unbox (Mask t0)) => MVector MVector (Fixed t0)

Methods

basicLength :: MVector s (Fixed t0) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Fixed t0) -> MVector s (Fixed t0)

basicOverlaps :: MVector s (Fixed t0) -> MVector s (Fixed t0) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Fixed t0))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Fixed t0) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Fixed t0 -> m (MVector (PrimState m) (Fixed t0))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Fixed t0) -> Int -> m (Fixed t0)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Fixed t0) -> Int -> Fixed t0 -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Fixed t0) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Fixed t0) -> Fixed t0 -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Fixed t0) -> MVector (PrimState m) (Fixed t0) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Fixed t0) -> MVector (PrimState m) (Fixed t0) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Fixed t0) -> Int -> m (MVector (PrimState m) (Fixed t0))

(Eq t, Eq (Mask t)) => Eq (Fixed t)

Methods

(==) :: Fixed t -> Fixed t -> Bool

(/=) :: Fixed t -> Fixed t -> Bool

(Ord t, Ord (Mask t)) => Ord (Fixed t)

Methods

compare :: Fixed t -> Fixed t -> Ordering

(<) :: Fixed t -> Fixed t -> Bool

(<=) :: Fixed t -> Fixed t -> Bool

(>) :: Fixed t -> Fixed t -> Bool

(>=) :: Fixed t -> Fixed t -> Bool

max :: Fixed t -> Fixed t -> Fixed t

min :: Fixed t -> Fixed t -> Fixed t

(Read t, Read (Mask t)) => Read (Fixed t)

Methods

readsPrec :: Int -> ReadS (Fixed t)

readList :: ReadS [Fixed t]

readPrec :: ReadPrec (Fixed t)

readListPrec :: ReadPrec [Fixed t]

(Show t, Show (Mask t)) => Show (Fixed t)

Methods

showsPrec :: Int -> Fixed t -> ShowS

show :: Fixed t -> String

showList :: [Fixed t] -> ShowS

(Generic t, Generic (Mask t)) => Generic (Fixed t)

Associated Types

type Rep (Fixed t) :: * -> *

Methods

from :: Fixed t -> Rep (Fixed t) x

to :: Rep (Fixed t) x -> Fixed t

(Arbitrary t, Arbitrary (Mask t)) => Arbitrary (Fixed t)

Methods

arbitrary :: Gen (Fixed t)

shrink :: Fixed t -> [Fixed t]

(Generic t, Generic (Mask t), Hashable t, Hashable (Mask t)) => Hashable (Fixed t)

Methods

hashWithSalt :: Int -> Fixed t -> Int

hash :: Fixed t -> Int

(Generic t, Generic (Mask t), Binary t, Binary (Mask t)) => Binary (Fixed t)

Methods

put :: Fixed t -> Put

get :: Get (Fixed t)

putList :: [Fixed t] -> Put

(Generic t, Generic (Mask t), Serialize t, Serialize (Mask t)) => Serialize (Fixed t)

Methods

put :: Putter (Fixed t)

get :: Get (Fixed t)

NFData (Fixed t)

Methods

rnf :: Fixed t -> ()

(Unbox t0, Unbox (Mask t0)) => Unbox (Fixed t0)

SetPredSucc (Fixed (BS2 i j t))

Methods

setSucc :: Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Maybe (Fixed (BS2 i j t))

setPred :: Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Fixed (BS2 i j t) -> Maybe (Fixed (BS2 i j t))

SetPredSucc (Fixed (BS1 i t))

Methods

setSucc :: Fixed (BS1 i t) -> Fixed (BS1 i t) -> Fixed (BS1 i t) -> Maybe (Fixed (BS1 i t))

setPred :: Fixed (BS1 i t) -> Fixed (BS1 i t) -> Fixed (BS1 i t) -> Maybe (Fixed (BS1 i t))

SetPredSucc (Fixed (BitSet t))

Methods

setSucc :: Fixed (BitSet t) -> Fixed (BitSet t) -> Fixed (BitSet t) -> Maybe (Fixed (BitSet t))

setPred :: Fixed (BitSet t) -> Fixed (BitSet t) -> Fixed (BitSet t) -> Maybe (Fixed (BitSet t))

data MVector s (Fixed t0)

data MVector s (Fixed t0) = MV_Fixed (MVector s (Mask t, t))

type Rep (Fixed t)

type Rep (Fixed t) = D1 (MetaData "Fixed" "Data.PrimitiveArray.Index.Set" "PrimitiveArray-0.7.1.0-B4A9oZDNxHW51HjshiHgYe" False) (C1 (MetaCons "Fixed" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "getFixedMask") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Mask t))) (S1 (MetaSel (Just Symbol "getFixed") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 t))))

data Vector (Fixed t0)

data Vector (Fixed t0) = V_Fixed (Vector (Mask t, t))

class ApplyMask s where

Assuming a bitset on bits [0 .. highbit], we can apply a mask that stretches out those bits over [0 .. higherBit] with highbit <= higherBit. Any active interfaces are correctly set as well.

Minimal complete definition

applyMask

Methods

applyMask :: Mask s -> s -> s

Instances

ApplyMask (BitSet t)

Methods

applyMask :: Mask (BitSet t) -> BitSet t -> BitSet t

ApplyMask (BS1 i t)

Methods

applyMask :: Mask (BS1 i t) -> BS1 i t -> BS1 i t

ApplyMask (BS2 i j t)

Methods

applyMask :: Mask (BS2 i j t) -> BS2 i j t -> BS2 i j t

Instances

streamUpBsMk :: (Monad m, Ord a) => a -> a -> t -> m (t, Maybe a)

streamUpBsStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))

streamDownBsMk :: (Monad m, Ord a) => a -> a -> t -> m (t, Maybe a)

streamDownBsStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))

BS1

streamUpBsIMk :: Monad m => BS1 a i -> BS1 b i -> z -> m (z, Maybe (BS1 c i))

streamUpBsIStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))

streamDownBsIMk :: Monad m => BS1 a i -> BS1 b i -> z -> m (z, Maybe (BS1 c i))

streamDownBsIStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))

BS2

streamUpBsIiMk :: Monad m => BS2 a b i -> BS2 c d i -> z -> m (z, Maybe (BS2 e f i))

streamUpBsIiStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))

streamDownBsIiMk :: Monad m => BS2 a b i -> BS2 c d i -> z -> m (z, Maybe (BS2 e f i))

streamDownBsIiStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))

Set predecessor and successor

testBsS :: BitSet t -> Maybe (Fixed (BitSet t))

arbitraryBitSetMax :: Integer