Synthesizer.LLVM.Frame.SerialVector

A special vector type that represents a time-sequence of samples. This way we can distinguish safely between LLVM vectors used for parallel signals and pipelines and those used for chunky processing of scalar signals. For the chunky processing this data type allows us to derive the factor from the type that time constants have to be multiplied with.

Documentation

newtype T v

Constructors

Cons v

Instances

Eq v => Eq (T v)

Num v => Num (T v)

Storable v => Storable (T v)

C v => C (T v)

Additive v => Additive (T v)

PseudoRing v => PseudoRing (T v)

PseudoModule v => PseudoModule (T v)

IntegerConstant v => IntegerConstant (T v)

Field v => Field (T v)

RationalConstant v => RationalConstant (T v)

Real v => Real (T v)

Fraction v => Fraction (T v)

Algebraic v => Algebraic (T v)

Transcendental v => Transcendental (T v)

Undefined v => Undefined (T v)

Zero v => Zero (T v)

MakeValueTuple v => MakeValueTuple (T v)

Phi v => Phi (T v)

Simple v => Sized (T v)

(C v, Zero v) => Zero (T v)

C v => C (T v)

Simple v => Read (T v)

This instance also allows to wrap tuples of vectors, but you cannot reasonably use them, because it would mean to serialize vectors with different element types.

MakeArguments (T v)

type Arguments f (T v) = f (T v)

type Struct (T v) = Struct v

type Scalar (T v) = Scalar v

type ValueTuple (T v) = T (ValueTuple v)

type Size (T v) = Size v

type WriteIt (T v) = v

type Element (T v) = Element v

type ReadIt (T v) = v

type Plain n a = T (Vector n a)

type Value n a = T (Value (Vector n a))

plain :: Vector n a -> Plain n a

value :: Value (Vector n a) -> Value n a

constant :: Positive n => a -> T (Constant n a)

class (Positive (Size v), Sized v, Phi (ReadIt v), Undefined (ReadIt v), Phi v, Undefined v) => Read v where

Minimal complete definition

extract, readStart, readNext

Associated Types

type Element v :: *

type ReadIt v :: *

Methods

extract :: Value Word32 -> v -> CodeGenFunction r (Element v)

extractAll :: v -> CodeGenFunction r [Element v]

readStart :: v -> CodeGenFunction r (ReadIterator (ReadIt v) v)

readNext :: ReadIterator (ReadIt v) v -> CodeGenFunction r (Element v, ReadIterator (ReadIt v) v)

Instances

Read v => Read (T v)

Read v => Read (Result v)

Simple v => Read (T v)

This instance also allows to wrap tuples of vectors, but you cannot reasonably use them, because it would mean to serialize vectors with different element types.

Read v => Read (Nodes13 v)

Read v => Read (Nodes02 v)

(Read va, Read vb, (~) * (Size va) (Size vb)) => Read (va, vb)

(Positive n, IsPrimitive a, IsFirstClass a) => Read (Value n a)

The implementation of extract may need to perform arithmetics at run-time and is thus a bit inefficient.

(Read va, Read vb, Read vc, (~) * (Size va) (Size vb), (~) * (Size vb) (Size vc)) => Read (va, vb, vc)

class (Read v, Phi (WriteIt v), Undefined (WriteIt v)) => C v where

Minimal complete definition

insert, writeStart, writeNext, writeStop

Associated Types

type WriteIt v :: *

Methods

insert :: Value Word32 -> Element v -> v -> CodeGenFunction r v

assemble :: [Element v] -> CodeGenFunction r v

writeStart :: CodeGenFunction r (WriteIterator (WriteIt v) v)

writeNext :: Element v -> WriteIterator (WriteIt v) v -> CodeGenFunction r (WriteIterator (WriteIt v) v)

writeStop :: WriteIterator (WriteIt v) v -> CodeGenFunction r v

Instances

C v => C (T v)

C v => C (Result v)

C v => C (T v)

C v => C (Nodes13 v)

C v => C (Nodes02 v)

(C va, C vb, (~) * (Size va) (Size vb)) => C (va, vb)

(Positive n, IsPrimitive a, IsFirstClass a) => C (Value n a)

The implementation of insert may need to perform arithmetics at run-time and is thus a bit inefficient.

(C va, C vb, C vc, (~) * (Size va) (Size vb), (~) * (Size vb) (Size vc)) => C (va, vb, vc)

class (C v, Phi (WriteIt v), Zero (WriteIt v)) => Zero v where

Methods

writeZero :: CodeGenFunction r (WriteIterator (WriteIt v) v)

Instances

Zero v => Zero (T v)

(C v, Zero v) => Zero (T v)

(Zero va, Zero vb, (~) * (Size va) (Size vb)) => Zero (va, vb)

(Zero va, Zero vb, Zero vc, (~) * (Size va) (Size vb), (~) * (Size vb) (Size vc)) => Zero (va, vb, vc)

newtype Iterator mode it v

Constructors

Iterator it

Instances

C it => C (Iterator mode it v)

Undefined it => Undefined (Iterator mode it v)

Phi it => Phi (Iterator mode it v)

type Struct (Iterator mode it v) = Struct it

type ReadIterator = Iterator ReadMode

type WriteIterator = Iterator WriteMode

data ReadMode

data WriteMode

class Positive (Size valueTuple) => Sized valueTuple

The type parameter value shall be a virtual LLVM register or a wrapper around one or more virtual LLVM registers.

Associated Types

type Size valueTuple :: *

Instances

Sized (Value a)

Basic LLVM types are all counted as scalar values, even LLVM Vectors. This means that an LLVM Vector can be used for parallel handling of data.

Sized value => Sized (T value)

Sized v => Sized (Result v)

Simple v => Sized (T v)

Sized value => Sized (Nodes13 value)

Sized value => Sized (Nodes02 value)

(Sized value0, Sized value1, (~) * (Size value0) (Size value1)) => Sized (value0, value1)

Positive n => Sized (Value n a)

(Sized value0, Sized value1, Sized value2, (~) * (Size value0) (Size value1), (~) * (Size value1) (Size value2)) => Sized (value0, value1, value2)

size :: Sized v => v -> Int

sizeOfIterator :: Sized v => Iterator mode it v -> Int

withSize :: Sized v => (Int -> m v) -> m v

insertTraversable :: (C v, Traversable f, Applicative f) => Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)

extractTraversable :: (Read v, Traversable f) => Value Word32 -> f v -> CodeGenFunction r (f (Element v))

readStartTraversable :: (Traversable f, Applicative f, Read v) => f v -> CodeGenFunction r (ReadIterator (f (ReadIt v)) (f v))

readNextTraversable :: (Traversable f, Applicative f, Read v) => ReadIterator (f (ReadIt v)) (f v) -> CodeGenFunction r (f (Element v), ReadIterator (f (ReadIt v)) (f v))

writeStartTraversable :: (Traversable f, Applicative f, C v) => CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))

writeNextTraversable :: (Traversable f, Applicative f, C v) => f (Element v) -> WriteIterator (f (WriteIt v)) (f v) -> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))

writeStopTraversable :: (Traversable f, Applicative f, C v) => WriteIterator (f (WriteIt v)) (f v) -> CodeGenFunction r (f v)

writeZeroTraversable :: (Traversable f, Applicative f, Zero v) => CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))

modify :: C v => Value Word32 -> (Element v -> CodeGenFunction r (Element v)) -> v -> CodeGenFunction r v

upsample :: C v => Element v -> CodeGenFunction r v

subsample :: Read v => v -> CodeGenFunction r (Element v)

cumulate :: (Arithmetic a, Positive n) => Value a -> Value n a -> CodeGenFunction r (Value a, Value n a)

iterate :: C v => (Element v -> CodeGenFunction r (Element v)) -> Element v -> CodeGenFunction r v

iteratePlain :: Positive n => (a -> a) -> a -> Plain n a

reverse :: C v => v -> CodeGenFunction r v

shiftUp :: C v => Element v -> v -> CodeGenFunction r (Element v, v)

shiftUpMultiZero :: (C v, Additive (Element v)) => Int -> v -> CodeGenFunction r v

shiftDownMultiZero :: (C v, Additive (Element v)) => Int -> v -> CodeGenFunction r v

replicate :: Positive n => a -> Plain n a

replicateOf :: (Positive n, IsPrimitive a, IsConst a) => a -> Value n a

fromList :: Positive n => T [] a -> Plain n a

fromFixedList :: Positive n => FixedList (ToUnary n) a -> Plain n a

mapPlain :: Positive n => (a -> b) -> Plain n a -> Plain n b

mapV :: Functor m => (Value (Vector n a) -> m (Value (Vector n b))) -> Value n a -> m (Value n b)

zipV :: Functor m => (c -> d) -> (Value (Vector n a) -> Value (Vector n b) -> m c) -> Value n a -> Value n b -> m d