LLVM.Extra.Multi.Vector

Documentation

newtype T n a

Constructors

Cons (VectorValueOf n a)

Instances

Positive n => C (T n)

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

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

(Positive n, C a) => Phi (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)

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

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

deconsPrim :: VectorValueOf 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

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

addPhi :: 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 Int

C Int8

C Int16

C Int32

C Int64

C Word

C Word8

C Word16

C Word32

C Word64

C Bool8

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

(Flags flags, MultiVector a) => C (Number flags a)

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

type Value n a = Value (Vector 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)

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 :: (VectorValueOf n a -> VectorValueOf 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, VectorValueOf n a ~ Value n al) => T n a

shufflePrimitive :: (Positive n, Positive m, IsPrimitive al, ValueOf a ~ Value al, VectorValueOf n a ~ Value n al, VectorValueOf 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, ValueOf a ~ Value al, VectorValueOf n a ~ Value n al) => Value Word32 -> T n a -> CodeGenFunction r (T a)

insertPrimitive :: (Positive n, IsPrimitive al, ValueOf a ~ Value al, VectorValueOf 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 (IntegerConstant a, C a) => IntegerConstant a where

Methods

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

Instances

IntegerConstant Double

IntegerConstant Float

IntegerConstant Int

IntegerConstant Int8

IntegerConstant Int16

IntegerConstant Int32

IntegerConstant Int64

IntegerConstant Word

IntegerConstant Word8

IntegerConstant Word16

IntegerConstant Word32

IntegerConstant Word64

(Flags flags, MultiVector a, IntegerConstant a) => IntegerConstant (Number flags a)

class (RationalConstant a, IntegerConstant a) => RationalConstant a where

Methods

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

Instances

RationalConstant Double

RationalConstant Float

(Flags flags, MultiVector a, RationalConstant a) => RationalConstant (Number flags 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

Additive Int

Additive Int8

Additive Int16

Additive Int32

Additive Int64

Additive Word

Additive Word8

Additive Word16

Additive Word32

Additive Word64

(Flags flags, MultiVector a, Additive a) => Additive (Number flags a)

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

(Flags flags, MultiVector a, PseudoRing a) => PseudoRing (Number flags a)

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

(Flags flags, MultiVector a, Field a) => Field (Number flags a)

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

(Flags flags, MultiVector a, Real a) => Real (Number flags a)

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

(Flags flags, MultiVector a, Fraction a) => Fraction (Number flags a)

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

(Flags flags, MultiVector a, Algebraic a) => Algebraic (Number flags a)

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

(Flags flags, MultiVector a, Transcendental a) => Transcendental (Number flags a)

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

(Flags flags, MultiVector a, FloatingComparison a) => FloatingComparison (Number flags a)

class (Select a, 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 Int

Select Int8

Select Int16

Select Int32

Select Int64

Select Word

Select Word8

Select Word16

Select Word32

Select Word64

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

(Flags flags, MultiVector a, Select a) => Select (Number flags a)

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

Comparison Int8

Comparison Int16

Comparison Int32

Comparison Int64

Comparison Word

Comparison Word8

Comparison Word16

Comparison Word32

Comparison Word64

(Flags flags, MultiVector a, Comparison a) => Comparison (Number flags a)

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, C a) => 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 Int

BitShift Int8

BitShift Int16

BitShift Int32

BitShift Int64

BitShift Word

BitShift Word8

BitShift Word16

BitShift Word32

BitShift Word64