LLVM.Extra.Multi.Vector

Documentation

newtype T n a

Constructors

Cons (Repr (Value n) a)

Instances

Positive n => C (T n)

(Positive n, C a) => Phi (T n a)

(Positive n, C a) => Zero (T n a)

(Positive n, C a) => Undefined (T n a)

(Positive n, Transcendental a) => Transcendental (T n a)

(Positive n, Algebraic a) => Algebraic (T n a)

(Positive n, Logic a) => Logic (T n a)

(Positive n, FloatingComparison a) => FloatingComparison (T n a)

(Positive n, Comparison a) => Comparison (T n a)

(Positive n, Fraction a) => Fraction (T n a)

(Positive n, Real a) => Real (T n a)

(Positive n, RationalConstant a) => RationalConstant (T n a)

(Positive n, Field a) => Field (T n a)

(Positive n, IntegerConstant a) => IntegerConstant (T n a)

(Positive n, PseudoModule a) => PseudoModule (T n a)

(Positive n, PseudoRing a) => PseudoRing (T n a)

(Positive n, Additive a) => Additive (T n a)

C n a => C (T n a)

consPrim :: Repr (Value n) a ~ Value n a => Value (Vector n a) -> T n a

deconsPrim :: Repr (Value n) a ~ Value n a => T n a -> Value (Vector n a)

class C a => C a where

Methods

cons :: Positive n => Vector n a -> T n a

undef :: Positive n => T n a

zero :: Positive n => T n a

phis :: Positive n => BasicBlock -> T n a -> CodeGenFunction r (T n a)

addPhis :: Positive n => BasicBlock -> T n a -> T n a -> CodeGenFunction r ()

shuffle :: (Positive n, Positive m) => ConstValue (Vector m Word32) -> T n a -> T n a -> CodeGenFunction r (T m a)

extract :: Positive n => Value Word32 -> T n a -> CodeGenFunction r (T a)

insert :: Positive n => Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)

Instances

C Bool

C Double

C Float

C Int8

C Int16

C Int32

C Int64

C Word8

C Word16

C Word32

C Word64

C Bool8

(C a, C b) => C (a, b)

(C a, C b, C c) => C (a, b, c)

type Value n = Compose Value (Vector n)

map :: (Positive n, C a, C b) => (T a -> CodeGenFunction r (T b)) -> T n a -> CodeGenFunction r (T n b)

zip :: T n a -> T n b -> T n (a, b)

zip3 :: T n a -> T n b -> T n c -> T n (a, b, c)

unzip :: T n (a, b) -> (T n a, T n b)

unzip3 :: T n (a, b, c) -> (T n a, T n b, T n c)

replicate :: (Positive n, C a) => T a -> CodeGenFunction r (T n a)

iterate :: (Positive n, C a) => (T a -> CodeGenFunction r (T a)) -> T a -> CodeGenFunction r (T n a)

take :: (Positive n, Positive m, C a) => T n a -> CodeGenFunction r (T m a)

takeRev :: (Positive n, Positive m, C a) => T n a -> CodeGenFunction r (T m a)

lift1 :: (Repr (Value n) a -> Repr (Value n) b) -> T n a -> T n b

modify :: (Positive n, C a) => Value Word32 -> (T a -> CodeGenFunction r (T a)) -> T n a -> CodeGenFunction r (T n a)

assemble :: (Positive n, C a) => [T a] -> CodeGenFunction r (T n a)

dissect :: (Positive n, C a) => T n a -> CodeGenFunction r [T a]

dissectList :: (Positive n, C a) => T n a -> [CodeGenFunction r (T a)]

reverse :: (Positive n, C a) => T n a -> CodeGenFunction r (T n a)

rotateUp :: (Positive n, C a) => T n a -> CodeGenFunction r (T n a)

Rotate one element towards the higher elements.

I don't want to call it rotateLeft or rotateRight, because there is no prefered layout for the vector elements. In Intel's instruction manual vector elements are indexed like the bits, that is from right to left. However, when working with Haskell list and enumeration syntax, the start index is left.

rotateDown :: (Positive n, C a) => T n a -> CodeGenFunction r (T n a)

shiftUp :: (Positive n, C a) => T a -> T n a -> CodeGenFunction r (T a, T n a)

shiftDown :: (Positive n, C a) => T a -> T n a -> CodeGenFunction r (T a, T n a)

shiftUpMultiZero :: (Positive n, C a) => Int -> T n a -> CodeGenFunction r (T n a)

shiftDownMultiZero :: (Positive n, C a) => Int -> T n a -> CodeGenFunction r (T n a)

shiftUpMultiUndef :: (Positive n, C a) => Int -> T n a -> CodeGenFunction r (T n a)

shiftDownMultiUndef :: (Positive n, C a) => Int -> T n a -> CodeGenFunction r (T n a)

undefPrimitive :: (Positive n, IsPrimitive al, Repr (Value n) a ~ Value n al) => T n a

shufflePrimitive :: (Positive n, Positive m, IsPrimitive al, Repr Value a ~ Value al, Repr (Value n) a ~ Value n al, Repr (Value m) a ~ Value m al) => ConstValue (Vector m Word32) -> T n a -> T n a -> CodeGenFunction r (T m a)

extractPrimitive :: (Positive n, IsPrimitive al, Repr Value a ~ Value al, Repr (Value n) a ~ Value n al) => Value Word32 -> T n a -> CodeGenFunction r (T a)

insertPrimitive :: (Positive n, IsPrimitive al, Repr Value a ~ Value al, Repr (Value n) a ~ Value n al) => Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)

shuffleMatchTraversable :: (Positive n, C a, Traversable f) => ConstValue (Vector n Word32) -> f (T n a) -> CodeGenFunction r (f (T n a))

insertTraversable :: (Positive n, C a, Traversable f, Applicative f) => Value Word32 -> f (T a) -> f (T n a) -> CodeGenFunction r (f (T n a))

extractTraversable :: (Positive n, C a, Traversable f) => Value Word32 -> f (T n a) -> CodeGenFunction r (f (T a))

class C a => IntegerConstant a where

Methods

fromInteger' :: Positive n => Integer -> T n a

Instances

IntegerConstant Double

IntegerConstant Float

IntegerConstant Int8

IntegerConstant Int16

IntegerConstant Int32

IntegerConstant Int64

IntegerConstant Word8

IntegerConstant Word16

IntegerConstant Word32

IntegerConstant Word64

class IntegerConstant a => RationalConstant a where

Methods

fromRational' :: Positive n => Rational -> T n a

Instances

RationalConstant Double

RationalConstant Float

class (Additive a, C a) => Additive a where

Methods

add :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

sub :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

neg :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Additive Double

Additive Float

Additive Int8

Additive Int16

Additive Int32

Additive Int64

Additive Word8

Additive Word16

Additive Word32

Additive Word64

class (PseudoRing a, Additive a) => PseudoRing a where

Methods

mul :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

Instances

PseudoRing Double

PseudoRing Float

class (Field a, PseudoRing a) => Field a where

Methods

fdiv :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

Instances

Field Double

Field Float

class (PseudoModule v, PseudoRing (Scalar v), Additive v) => PseudoModule v where

Methods

scale :: Positive n => T n (Scalar v) -> T n v -> CodeGenFunction r (T n v)

Instances

PseudoModule Double

PseudoModule Float

class (Real a, Additive a) => Real a where

Methods

min :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

max :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

abs :: Positive n => T n a -> CodeGenFunction r (T n a)

signum :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Real Double

Real Float

class (Fraction a, Real a) => Fraction a where

Methods

truncate :: Positive n => T n a -> CodeGenFunction r (T n a)

fraction :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Fraction Double

Fraction Float

class (Algebraic a, Field a) => Algebraic a where

Methods

sqrt :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Algebraic Double

Algebraic Float

class (Transcendental a, Algebraic a) => Transcendental a where

Methods

pi :: Positive n => CodeGenFunction r (T n a)

sin, log, exp, cos :: Positive n => T n a -> CodeGenFunction r (T n a)

pow :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

Instances

Transcendental Double

Transcendental Float

class (FloatingComparison a, Comparison a) => FloatingComparison a where

Methods

fcmp :: Positive n => FPPredicate -> T n a -> T n a -> CodeGenFunction r (T n Bool)

Instances

FloatingComparison Float

class C a => Select a where

Methods

select :: Positive n => T n Bool -> T n a -> T n a -> CodeGenFunction r (T n a)

Instances

Select Bool

Select Double

Select Float

Select Int8

Select Int16

Select Int32

Select Int64

Select Word8

Select Word16

Select Word32

Select Word64

(Select a, Select b) => Select (a, b)

(Select a, Select b, Select c) => Select (a, b, c)

class (Comparison a, C a) => Comparison a where

Methods

cmp :: Positive n => CmpPredicate -> T n a -> T n a -> CodeGenFunction r (T n Bool)

Instances

Comparison Double

Comparison Float

Comparison Int8

Comparison Int16

Comparison Int32

Comparison Int64

Comparison Word8

Comparison Word16

Comparison Word32

Comparison Word64

class (Logic a, C a) => Logic a where

Methods

and :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

or :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

xor :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

inv :: Positive n => T n a -> CodeGenFunction r (T n a)

Instances

Logic Bool

Logic Word8

Logic Word16

Logic Word32

Logic Word64

class BitShift a where

Methods

shl :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

shr :: Positive n => T n a -> T n a -> CodeGenFunction r (T n a)

Instances

BitShift Int8

BitShift Int16

BitShift Int32

BitShift Int64

BitShift Word8

BitShift Word16

BitShift Word32

BitShift Word64