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

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 ()

shuffleMatch :: Positive n => ConstValue (Vector n Word32) -> T n a -> CodeGenFunction r (T n 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 a, C b) => C (a, b)

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

newtype Value n a

Constructors

Value (PrimValue n a)

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)

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, ValueTuple a ~ al, Zero al) => Int -> T n a -> CodeGenFunction r (T n a)

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

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

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

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

insertPrimitive :: (Positive n, IsPrimitive a, Repr Value a ~ Value a, Repr (Value n) a ~ Value n a) => 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 (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

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 (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

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

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