LLVM.Extra.Vector

Documentation

class (Positive (Size v), Phi v, Undefined v) => Simple v where

Methods

shuffleMatch :: ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v

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

Instances

(Positive n, IsPrimitive a) => Simple (Value (Vector n a))

Defined in LLVM.Extra.Vector

Associated Types

type Element (Value (Vector n a))

type Size (Value (Vector n a))

Methods

shuffleMatch :: ConstValue (Vector (Size (Value (Vector n a))) Word32) -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))

extract :: Value Word32 -> Value (Vector n a) -> CodeGenFunction r (Element (Value (Vector n a)))

(Positive n, Phi a, Undefined a) => Simple (Constant n a)

Defined in LLVM.Extra.Vector

Associated Types

type Element (Constant n a)

type Size (Constant n a)

Methods

shuffleMatch :: ConstValue (Vector (Size (Constant n a)) Word32) -> Constant n a -> CodeGenFunction r (Constant n a)

extract :: Value Word32 -> Constant n a -> CodeGenFunction r (Element (Constant n a))

(Simple v0, Simple v1, Size v0 ~ Size v1) => Simple (v0, v1)

Defined in LLVM.Extra.Vector

Associated Types

type Element (v0, v1)

type Size (v0, v1)

Methods

shuffleMatch :: ConstValue (Vector (Size (v0, v1)) Word32) -> (v0, v1) -> CodeGenFunction r (v0, v1)

extract :: Value Word32 -> (v0, v1) -> CodeGenFunction r (Element (v0, v1))

(Simple v0, Simple v1, Simple v2, Size v0 ~ Size v1, Size v1 ~ Size v2) => Simple (v0, v1, v2)

Defined in LLVM.Extra.Vector

Associated Types

type Element (v0, v1, v2)

type Size (v0, v1, v2)

Methods

shuffleMatch :: ConstValue (Vector (Size (v0, v1, v2)) Word32) -> (v0, v1, v2) -> CodeGenFunction r (v0, v1, v2)

extract :: Value Word32 -> (v0, v1, v2) -> CodeGenFunction r (Element (v0, v1, v2))

class Simple v => C v where

Allow to work on records of vectors as if they are vectors of records. This is a reasonable approach for records of different element types since processor vectors can only be built from elements of the same type. But also, say, for chunked stereo signal this makes sense. In this case we would work on Stereo (Value a).

Formerly we used a two-way dependency Vector - (Element, Size). Now we have only the dependency Vector -> (Element, Size). This means that we need some more type annotations as in umul32to64/assemble, on the other hand we can allow multiple vector types with respect to the same element type. E.g. we can provide a vector type with pair elements where the pair elements are interleaved in the vector.

Methods

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

Instances

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

Defined in LLVM.Extra.Vector

Methods

insert :: Value Word32 -> Element (Value (Vector n a)) -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))

(C v0, C v1, Size v0 ~ Size v1) => C (v0, v1)

Defined in LLVM.Extra.Vector

Methods

insert :: Value Word32 -> Element (v0, v1) -> (v0, v1) -> CodeGenFunction r (v0, v1)

(C v0, C v1, C v2, Size v0 ~ Size v1, Size v1 ~ Size v2) => C (v0, v1, v2)

Defined in LLVM.Extra.Vector

Methods

insert :: Value Word32 -> Element (v0, v1, v2) -> (v0, v1, v2) -> CodeGenFunction r (v0, v1, v2)

type family Element v

Instances

type Element (Value (Vector n a))

Defined in LLVM.Extra.Vector

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

type Element (Constant n a)

Defined in LLVM.Extra.Vector

type Element (Constant n a) = a

type Element (v0, v1)

Defined in LLVM.Extra.Vector

type Element (v0, v1) = (Element v0, Element v1)

type Element (v0, v1, v2)

Defined in LLVM.Extra.Vector

type Element (v0, v1, v2) = (Element v0, Element v1, Element v2)

type family Size v

Instances

type Size (Value (Vector n a))

Defined in LLVM.Extra.Vector

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

type Size (Constant n a)

Defined in LLVM.Extra.Vector

type Size (Constant n a) = n

type Size (v0, v1)

Defined in LLVM.Extra.Vector

type Size (v0, v1) = Size v0

type Size (v0, v1, v2)

Defined in LLVM.Extra.Vector

type Size (v0, v1, v2) = Size v0

class (n ~ Size (Construct n a), a ~ Element (Construct n a), C (Construct n a)) => Canonical n a

Instances

(Positive n, IsPrimitive a) => Canonical n (Value a)

Defined in LLVM.Extra.Vector

Associated Types

type Construct n (Value a)

(Canonical n a0, Canonical n a1) => Canonical n (a0, a1)

Defined in LLVM.Extra.Vector

Associated Types

type Construct n (a0, a1)

(Canonical n a0, Canonical n a1, Canonical n a2) => Canonical n (a0, a1, a2)

Defined in LLVM.Extra.Vector

Associated Types

type Construct n (a0, a1, a2)

type family Construct n a

Instances

type Construct n (Value a)

Defined in LLVM.Extra.Vector

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

type Construct n (a0, a1)

Defined in LLVM.Extra.Vector

type Construct n (a0, a1) = (Construct n a0, Construct n a1)

type Construct n (a0, a1, a2)

Defined in LLVM.Extra.Vector

type Construct n (a0, a1, a2) = (Construct n a0, Construct n a1, Construct n a2)

size :: Positive n => Value (Vector n a) -> Int

sizeInTuple :: Simple v => v -> Int

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

Manually assemble a vector of equal values. Better use ScalarOrVector.replicate.

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

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

construct a vector out of single elements

You must assert that the length of the list matches the vector size.

This can be considered the inverse of extractAll.

shuffle :: (C v, C w, Element v ~ Element w) => v -> ConstValue (Vector (Size w) Word32) -> CodeGenFunction r w

Manually implement vector shuffling using insertelement and extractelement. In contrast to LLVM's built-in instruction it supports distinct vector sizes, but it allows only one input vector (or a tuple of vectors, but we cannot shuffle between them). For more complex shuffling we recommend extractAll and assemble.

rotateUp :: Simple v => v -> CodeGenFunction r v

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 :: Simple v => v -> CodeGenFunction r v

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

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

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

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

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

shuffleMatchTraversable :: (Simple v, Traversable f) => ConstValue (Vector (Size v) Word32) -> f v -> CodeGenFunction r (f v)

shuffleMatchAccess :: C v => ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v

Implement the shuffleMatch method using the methods of the C class.

shuffleMatchPlain1 :: (Positive n, IsPrimitive a) => Value (Vector n a) -> ConstValue (Vector n Word32) -> CodeGenFunction r (Value (Vector n a))

shuffleMatchPlain2 :: (Positive n, IsPrimitive a) => Value (Vector n a) -> Value (Vector n a) -> ConstValue (Vector n Word32) -> CodeGenFunction r (Value (Vector n a))

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

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

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

provide the elements of a vector as a list of individual virtual registers

This can be considered the inverse of assemble.

data Constant n a

Instances

Foldable (Constant n)

Defined in LLVM.Extra.Vector

Methods

fold :: Monoid m => Constant n m -> m

foldMap :: Monoid m => (a -> m) -> Constant n a -> m

foldMap' :: Monoid m => (a -> m) -> Constant n a -> m

foldr :: (a -> b -> b) -> b -> Constant n a -> b

foldr' :: (a -> b -> b) -> b -> Constant n a -> b

foldl :: (b -> a -> b) -> b -> Constant n a -> b

foldl' :: (b -> a -> b) -> b -> Constant n a -> b

foldr1 :: (a -> a -> a) -> Constant n a -> a

foldl1 :: (a -> a -> a) -> Constant n a -> a

toList :: Constant n a -> [a]

null :: Constant n a -> Bool

length :: Constant n a -> Int

elem :: Eq a => a -> Constant n a -> Bool

maximum :: Ord a => Constant n a -> a

minimum :: Ord a => Constant n a -> a

sum :: Num a => Constant n a -> a

product :: Num a => Constant n a -> a

Traversable (Constant n)

Defined in LLVM.Extra.Vector

Methods

traverse :: Applicative f => (a -> f b) -> Constant n a -> f (Constant n b)

sequenceA :: Applicative f => Constant n (f a) -> f (Constant n a)

mapM :: Monad m => (a -> m b) -> Constant n a -> m (Constant n b)

sequence :: Monad m => Constant n (m a) -> m (Constant n a)

Applicative (Constant n)

Defined in LLVM.Extra.Vector

Methods

pure :: a -> Constant n a

(<*>) :: Constant n (a -> b) -> Constant n a -> Constant n b

liftA2 :: (a -> b -> c) -> Constant n a -> Constant n b -> Constant n c

(*>) :: Constant n a -> Constant n b -> Constant n b

(<*) :: Constant n a -> Constant n b -> Constant n a

Functor (Constant n)

Defined in LLVM.Extra.Vector

Methods

fmap :: (a -> b) -> Constant n a -> Constant n b

(<$) :: a -> Constant n b -> Constant n a

Phi a => Phi (Constant n a)

Defined in LLVM.Extra.Vector

Methods

phi :: BasicBlock -> Constant n a -> CodeGenFunction r (Constant n a)

addPhi :: BasicBlock -> Constant n a -> Constant n a -> CodeGenFunction r ()

Undefined a => Undefined (Constant n a)

Defined in LLVM.Extra.Vector

Methods

undef :: Constant n a

(Positive n, Phi a, Undefined a) => Simple (Constant n a)

Defined in LLVM.Extra.Vector

Associated Types

type Element (Constant n a)

type Size (Constant n a)

Methods

shuffleMatch :: ConstValue (Vector (Size (Constant n a)) Word32) -> Constant n a -> CodeGenFunction r (Constant n a)

extract :: Value Word32 -> Constant n a -> CodeGenFunction r (Element (Constant n a))

type Element (Constant n a)

Defined in LLVM.Extra.Vector

type Element (Constant n a) = a

type Size (Constant n a)

Defined in LLVM.Extra.Vector

type Size (Constant n a) = n

constant :: Positive n => a -> Constant n a

insertChunk :: (C c, C v, Element c ~ Element v) => Int -> c -> v -> CodeGenFunction r v

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

map :: (C v, C w, Size v ~ Size w) => (Element v -> CodeGenFunction r (Element w)) -> v -> CodeGenFunction r w

Like LLVM.Util.Loop.mapVector but the loop is unrolled, which is faster since it can be packed by the code generator.

mapChunks :: (C ca, C cb, Size ca ~ Size cb, C va, C vb, Size va ~ Size vb, Element ca ~ Element va, Element cb ~ Element vb) => (ca -> CodeGenFunction r cb) -> va -> CodeGenFunction r vb

zipChunksWith :: (C ca, C cb, C cc, Size ca ~ Size cb, Size cb ~ Size cc, C va, C vb, C vc, Size va ~ Size vb, Size vb ~ Size vc, Element ca ~ Element va, Element cb ~ Element vb, Element cc ~ Element vc) => (ca -> cb -> CodeGenFunction r cc) -> va -> vb -> CodeGenFunction r vc

chop :: (C c, C v, Element c ~ Element v) => v -> [CodeGenFunction r c]

If the target vector type is a native type then the chop operation produces no actual machine instruction. (nop) If the vector cannot be evenly divided into chunks the last chunk will be padded with undefined values.

concat :: (C c, C v, Element c ~ Element v) => [c] -> CodeGenFunction r v

The target size is determined by the type. If the chunk list provides more data, the exceeding data is dropped. If the chunk list provides too few data, the target vector is filled with undefined elements.

signedFraction :: (IsFloating a, IsConst a, Real a, Positive n) => Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))

cumulate1 :: (IsArithmetic a, IsPrimitive a, Positive n) => Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))

Needs (log n) vector additions

class (IsArithmetic a, IsPrimitive a) => Arithmetic a where

The order of addition is chosen for maximum efficiency. We do not try to prevent cancelations.

Minimal complete definition

Nothing

Methods

sum :: Positive n => Value (Vector n a) -> CodeGenFunction r (Value a)

sumToPair :: Positive n => Value (Vector n a) -> CodeGenFunction r (Value a, Value a)

The first result value is the sum of all vector elements from 0 to div n 2 + 1 and the second result value is the sum of vector elements from div n 2 to n-1. n must be at least D2.

sumInterleavedToPair :: Positive n => Value (Vector n a) -> CodeGenFunction r (Value a, Value a)

Treat the vector as concatenation of pairs and all these pairs are added. Useful for stereo signal processing. n must be at least D2.

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

dotProduct :: Positive n => Value (Vector n a) -> Value (Vector n a) -> CodeGenFunction r (Value a)

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

Instances

Arithmetic Int16

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Int16) -> CodeGenFunction r (Value Int16)

sumToPair :: Positive n => Value (Vector n Int16) -> CodeGenFunction r (Value Int16, Value Int16)

sumInterleavedToPair :: Positive n => Value (Vector n Int16) -> CodeGenFunction r (Value Int16, Value Int16)

cumulate :: Positive n => Value Int16 -> Value (Vector n Int16) -> CodeGenFunction r (Value Int16, Value (Vector n Int16))

dotProduct :: Positive n => Value (Vector n Int16) -> Value (Vector n Int16) -> CodeGenFunction r (Value Int16)

mul :: Positive n => Value (Vector n Int16) -> Value (Vector n Int16) -> CodeGenFunction r (Value (Vector n Int16))

Arithmetic Int32

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Int32) -> CodeGenFunction r (Value Int32)

sumToPair :: Positive n => Value (Vector n Int32) -> CodeGenFunction r (Value Int32, Value Int32)

sumInterleavedToPair :: Positive n => Value (Vector n Int32) -> CodeGenFunction r (Value Int32, Value Int32)

cumulate :: Positive n => Value Int32 -> Value (Vector n Int32) -> CodeGenFunction r (Value Int32, Value (Vector n Int32))

dotProduct :: Positive n => Value (Vector n Int32) -> Value (Vector n Int32) -> CodeGenFunction r (Value Int32)

mul :: Positive n => Value (Vector n Int32) -> Value (Vector n Int32) -> CodeGenFunction r (Value (Vector n Int32))

Arithmetic Int64

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Int64) -> CodeGenFunction r (Value Int64)

sumToPair :: Positive n => Value (Vector n Int64) -> CodeGenFunction r (Value Int64, Value Int64)

sumInterleavedToPair :: Positive n => Value (Vector n Int64) -> CodeGenFunction r (Value Int64, Value Int64)

cumulate :: Positive n => Value Int64 -> Value (Vector n Int64) -> CodeGenFunction r (Value Int64, Value (Vector n Int64))

dotProduct :: Positive n => Value (Vector n Int64) -> Value (Vector n Int64) -> CodeGenFunction r (Value Int64)

mul :: Positive n => Value (Vector n Int64) -> Value (Vector n Int64) -> CodeGenFunction r (Value (Vector n Int64))

Arithmetic Int8

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Int8) -> CodeGenFunction r (Value Int8)

sumToPair :: Positive n => Value (Vector n Int8) -> CodeGenFunction r (Value Int8, Value Int8)

sumInterleavedToPair :: Positive n => Value (Vector n Int8) -> CodeGenFunction r (Value Int8, Value Int8)

cumulate :: Positive n => Value Int8 -> Value (Vector n Int8) -> CodeGenFunction r (Value Int8, Value (Vector n Int8))

dotProduct :: Positive n => Value (Vector n Int8) -> Value (Vector n Int8) -> CodeGenFunction r (Value Int8)

mul :: Positive n => Value (Vector n Int8) -> Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))

Arithmetic Word16

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Word16) -> CodeGenFunction r (Value Word16)

sumToPair :: Positive n => Value (Vector n Word16) -> CodeGenFunction r (Value Word16, Value Word16)

sumInterleavedToPair :: Positive n => Value (Vector n Word16) -> CodeGenFunction r (Value Word16, Value Word16)

cumulate :: Positive n => Value Word16 -> Value (Vector n Word16) -> CodeGenFunction r (Value Word16, Value (Vector n Word16))

dotProduct :: Positive n => Value (Vector n Word16) -> Value (Vector n Word16) -> CodeGenFunction r (Value Word16)

mul :: Positive n => Value (Vector n Word16) -> Value (Vector n Word16) -> CodeGenFunction r (Value (Vector n Word16))

Arithmetic Word32

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Word32) -> CodeGenFunction r (Value Word32)

sumToPair :: Positive n => Value (Vector n Word32) -> CodeGenFunction r (Value Word32, Value Word32)

sumInterleavedToPair :: Positive n => Value (Vector n Word32) -> CodeGenFunction r (Value Word32, Value Word32)

cumulate :: Positive n => Value Word32 -> Value (Vector n Word32) -> CodeGenFunction r (Value Word32, Value (Vector n Word32))

dotProduct :: Positive n => Value (Vector n Word32) -> Value (Vector n Word32) -> CodeGenFunction r (Value Word32)

mul :: Positive n => Value (Vector n Word32) -> Value (Vector n Word32) -> CodeGenFunction r (Value (Vector n Word32))

Arithmetic Word64

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Word64) -> CodeGenFunction r (Value Word64)

sumToPair :: Positive n => Value (Vector n Word64) -> CodeGenFunction r (Value Word64, Value Word64)

sumInterleavedToPair :: Positive n => Value (Vector n Word64) -> CodeGenFunction r (Value Word64, Value Word64)

cumulate :: Positive n => Value Word64 -> Value (Vector n Word64) -> CodeGenFunction r (Value Word64, Value (Vector n Word64))

dotProduct :: Positive n => Value (Vector n Word64) -> Value (Vector n Word64) -> CodeGenFunction r (Value Word64)

mul :: Positive n => Value (Vector n Word64) -> Value (Vector n Word64) -> CodeGenFunction r (Value (Vector n Word64))

Arithmetic Word8

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Word8) -> CodeGenFunction r (Value Word8)

sumToPair :: Positive n => Value (Vector n Word8) -> CodeGenFunction r (Value Word8, Value Word8)

sumInterleavedToPair :: Positive n => Value (Vector n Word8) -> CodeGenFunction r (Value Word8, Value Word8)

cumulate :: Positive n => Value Word8 -> Value (Vector n Word8) -> CodeGenFunction r (Value Word8, Value (Vector n Word8))

dotProduct :: Positive n => Value (Vector n Word8) -> Value (Vector n Word8) -> CodeGenFunction r (Value Word8)

mul :: Positive n => Value (Vector n Word8) -> Value (Vector n Word8) -> CodeGenFunction r (Value (Vector n Word8))

Arithmetic Double

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Double) -> CodeGenFunction r (Value Double)

sumToPair :: Positive n => Value (Vector n Double) -> CodeGenFunction r (Value Double, Value Double)

sumInterleavedToPair :: Positive n => Value (Vector n Double) -> CodeGenFunction r (Value Double, Value Double)

cumulate :: Positive n => Value Double -> Value (Vector n Double) -> CodeGenFunction r (Value Double, Value (Vector n Double))

dotProduct :: Positive n => Value (Vector n Double) -> Value (Vector n Double) -> CodeGenFunction r (Value Double)

mul :: Positive n => Value (Vector n Double) -> Value (Vector n Double) -> CodeGenFunction r (Value (Vector n Double))

Arithmetic Float

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Float) -> CodeGenFunction r (Value Float)

sumToPair :: Positive n => Value (Vector n Float) -> CodeGenFunction r (Value Float, Value Float)

sumInterleavedToPair :: Positive n => Value (Vector n Float) -> CodeGenFunction r (Value Float, Value Float)

cumulate :: Positive n => Value Float -> Value (Vector n Float) -> CodeGenFunction r (Value Float, Value (Vector n Float))

dotProduct :: Positive n => Value (Vector n Float) -> Value (Vector n Float) -> CodeGenFunction r (Value Float)

mul :: Positive n => Value (Vector n Float) -> Value (Vector n Float) -> CodeGenFunction r (Value (Vector n Float))

Arithmetic Int

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Int) -> CodeGenFunction r (Value Int)

sumToPair :: Positive n => Value (Vector n Int) -> CodeGenFunction r (Value Int, Value Int)

sumInterleavedToPair :: Positive n => Value (Vector n Int) -> CodeGenFunction r (Value Int, Value Int)

cumulate :: Positive n => Value Int -> Value (Vector n Int) -> CodeGenFunction r (Value Int, Value (Vector n Int))

dotProduct :: Positive n => Value (Vector n Int) -> Value (Vector n Int) -> CodeGenFunction r (Value Int)

mul :: Positive n => Value (Vector n Int) -> Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))

Arithmetic Word

Defined in LLVM.Extra.Vector

Methods

sum :: Positive n => Value (Vector n Word) -> CodeGenFunction r (Value Word)

sumToPair :: Positive n => Value (Vector n Word) -> CodeGenFunction r (Value Word, Value Word)

sumInterleavedToPair :: Positive n => Value (Vector n Word) -> CodeGenFunction r (Value Word, Value Word)

cumulate :: Positive n => Value Word -> Value (Vector n Word) -> CodeGenFunction r (Value Word, Value (Vector n Word))

dotProduct :: Positive n => Value (Vector n Word) -> Value (Vector n Word) -> CodeGenFunction r (Value Word)

mul :: Positive n => Value (Vector n Word) -> Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))

class (Arithmetic a, CmpRet a, IsPrimitive a, IsConst a) => Real a where

Methods

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

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

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

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

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

floor :: Positive n => Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))

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

Instances

Real Int16

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Int16) -> Value (Vector n Int16) -> CodeGenFunction r (Value (Vector n Int16))

max :: Positive n => Value (Vector n Int16) -> Value (Vector n Int16) -> CodeGenFunction r (Value (Vector n Int16))

abs :: Positive n => Value (Vector n Int16) -> CodeGenFunction r (Value (Vector n Int16))

signum :: Positive n => Value (Vector n Int16) -> CodeGenFunction r (Value (Vector n Int16))

truncate :: Positive n => Value (Vector n Int16) -> CodeGenFunction r (Value (Vector n Int16))

floor :: Positive n => Value (Vector n Int16) -> CodeGenFunction r (Value (Vector n Int16))

fraction :: Positive n => Value (Vector n Int16) -> CodeGenFunction r (Value (Vector n Int16))

Real Int32

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Int32) -> Value (Vector n Int32) -> CodeGenFunction r (Value (Vector n Int32))

max :: Positive n => Value (Vector n Int32) -> Value (Vector n Int32) -> CodeGenFunction r (Value (Vector n Int32))

abs :: Positive n => Value (Vector n Int32) -> CodeGenFunction r (Value (Vector n Int32))

signum :: Positive n => Value (Vector n Int32) -> CodeGenFunction r (Value (Vector n Int32))

truncate :: Positive n => Value (Vector n Int32) -> CodeGenFunction r (Value (Vector n Int32))

floor :: Positive n => Value (Vector n Int32) -> CodeGenFunction r (Value (Vector n Int32))

fraction :: Positive n => Value (Vector n Int32) -> CodeGenFunction r (Value (Vector n Int32))

Real Int64

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Int64) -> Value (Vector n Int64) -> CodeGenFunction r (Value (Vector n Int64))

max :: Positive n => Value (Vector n Int64) -> Value (Vector n Int64) -> CodeGenFunction r (Value (Vector n Int64))

abs :: Positive n => Value (Vector n Int64) -> CodeGenFunction r (Value (Vector n Int64))

signum :: Positive n => Value (Vector n Int64) -> CodeGenFunction r (Value (Vector n Int64))

truncate :: Positive n => Value (Vector n Int64) -> CodeGenFunction r (Value (Vector n Int64))

floor :: Positive n => Value (Vector n Int64) -> CodeGenFunction r (Value (Vector n Int64))

fraction :: Positive n => Value (Vector n Int64) -> CodeGenFunction r (Value (Vector n Int64))

Real Int8

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Int8) -> Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))

max :: Positive n => Value (Vector n Int8) -> Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))

abs :: Positive n => Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))

signum :: Positive n => Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))

truncate :: Positive n => Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))

floor :: Positive n => Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))

fraction :: Positive n => Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))

Real Word16

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Word16) -> Value (Vector n Word16) -> CodeGenFunction r (Value (Vector n Word16))

max :: Positive n => Value (Vector n Word16) -> Value (Vector n Word16) -> CodeGenFunction r (Value (Vector n Word16))

abs :: Positive n => Value (Vector n Word16) -> CodeGenFunction r (Value (Vector n Word16))

signum :: Positive n => Value (Vector n Word16) -> CodeGenFunction r (Value (Vector n Word16))

truncate :: Positive n => Value (Vector n Word16) -> CodeGenFunction r (Value (Vector n Word16))

floor :: Positive n => Value (Vector n Word16) -> CodeGenFunction r (Value (Vector n Word16))

fraction :: Positive n => Value (Vector n Word16) -> CodeGenFunction r (Value (Vector n Word16))

Real Word32

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Word32) -> Value (Vector n Word32) -> CodeGenFunction r (Value (Vector n Word32))

max :: Positive n => Value (Vector n Word32) -> Value (Vector n Word32) -> CodeGenFunction r (Value (Vector n Word32))

abs :: Positive n => Value (Vector n Word32) -> CodeGenFunction r (Value (Vector n Word32))

signum :: Positive n => Value (Vector n Word32) -> CodeGenFunction r (Value (Vector n Word32))

truncate :: Positive n => Value (Vector n Word32) -> CodeGenFunction r (Value (Vector n Word32))

floor :: Positive n => Value (Vector n Word32) -> CodeGenFunction r (Value (Vector n Word32))

fraction :: Positive n => Value (Vector n Word32) -> CodeGenFunction r (Value (Vector n Word32))

Real Word64

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Word64) -> Value (Vector n Word64) -> CodeGenFunction r (Value (Vector n Word64))

max :: Positive n => Value (Vector n Word64) -> Value (Vector n Word64) -> CodeGenFunction r (Value (Vector n Word64))

abs :: Positive n => Value (Vector n Word64) -> CodeGenFunction r (Value (Vector n Word64))

signum :: Positive n => Value (Vector n Word64) -> CodeGenFunction r (Value (Vector n Word64))

truncate :: Positive n => Value (Vector n Word64) -> CodeGenFunction r (Value (Vector n Word64))

floor :: Positive n => Value (Vector n Word64) -> CodeGenFunction r (Value (Vector n Word64))

fraction :: Positive n => Value (Vector n Word64) -> CodeGenFunction r (Value (Vector n Word64))

Real Word8

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Word8) -> Value (Vector n Word8) -> CodeGenFunction r (Value (Vector n Word8))

max :: Positive n => Value (Vector n Word8) -> Value (Vector n Word8) -> CodeGenFunction r (Value (Vector n Word8))

abs :: Positive n => Value (Vector n Word8) -> CodeGenFunction r (Value (Vector n Word8))

signum :: Positive n => Value (Vector n Word8) -> CodeGenFunction r (Value (Vector n Word8))

truncate :: Positive n => Value (Vector n Word8) -> CodeGenFunction r (Value (Vector n Word8))

floor :: Positive n => Value (Vector n Word8) -> CodeGenFunction r (Value (Vector n Word8))

fraction :: Positive n => Value (Vector n Word8) -> CodeGenFunction r (Value (Vector n Word8))

Real Double

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Double) -> Value (Vector n Double) -> CodeGenFunction r (Value (Vector n Double))

max :: Positive n => Value (Vector n Double) -> Value (Vector n Double) -> CodeGenFunction r (Value (Vector n Double))

abs :: Positive n => Value (Vector n Double) -> CodeGenFunction r (Value (Vector n Double))

signum :: Positive n => Value (Vector n Double) -> CodeGenFunction r (Value (Vector n Double))

truncate :: Positive n => Value (Vector n Double) -> CodeGenFunction r (Value (Vector n Double))

floor :: Positive n => Value (Vector n Double) -> CodeGenFunction r (Value (Vector n Double))

fraction :: Positive n => Value (Vector n Double) -> CodeGenFunction r (Value (Vector n Double))

Real Float

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Float) -> Value (Vector n Float) -> CodeGenFunction r (Value (Vector n Float))

max :: Positive n => Value (Vector n Float) -> Value (Vector n Float) -> CodeGenFunction r (Value (Vector n Float))

abs :: Positive n => Value (Vector n Float) -> CodeGenFunction r (Value (Vector n Float))

signum :: Positive n => Value (Vector n Float) -> CodeGenFunction r (Value (Vector n Float))

truncate :: Positive n => Value (Vector n Float) -> CodeGenFunction r (Value (Vector n Float))

floor :: Positive n => Value (Vector n Float) -> CodeGenFunction r (Value (Vector n Float))

fraction :: Positive n => Value (Vector n Float) -> CodeGenFunction r (Value (Vector n Float))

Real Int

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Int) -> Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))

max :: Positive n => Value (Vector n Int) -> Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))

abs :: Positive n => Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))

signum :: Positive n => Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))

truncate :: Positive n => Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))

floor :: Positive n => Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))

fraction :: Positive n => Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))

Real Word

Defined in LLVM.Extra.Vector

Methods

min :: Positive n => Value (Vector n Word) -> Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))

max :: Positive n => Value (Vector n Word) -> Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))

abs :: Positive n => Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))

signum :: Positive n => Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))

truncate :: Positive n => Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))

floor :: Positive n => Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))

fraction :: Positive n => Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))