{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
module LLVM.Extra.Vector (
Simple (shuffleMatch, extract), C (insert),
Element, Size,
Canonical, Construct,
size, sizeInTuple,
replicate, iterate, assemble,
shuffle,
rotateUp, rotateDown, reverse,
shiftUp, shiftDown,
shiftUpMultiZero, shiftDownMultiZero,
shuffleMatchTraversable,
shuffleMatchAccess,
shuffleMatchPlain1,
shuffleMatchPlain2,
insertTraversable,
extractTraversable,
extractAll,
Constant, constant,
insertChunk, modify,
map, mapChunks, zipChunksWith,
chop, concat,
signedFraction,
cumulate1,
Arithmetic
(sum, sumToPair, sumInterleavedToPair,
cumulate, dotProduct, mul),
Real
(min, max, abs, signum,
truncate, floor, fraction),
) where
import qualified LLVM.Extra.Tuple as Tuple
import qualified LLVM.Extra.ArithmeticPrivate as A
import qualified LLVM.Util.Intrinsic as Intrinsic
import qualified LLVM.Core as LLVM
import LLVM.Core
(Value, ConstValue, valueOf, value, constOf, undef,
Vector, insertelement, extractelement,
IsConst, IsArithmetic, IsFloating,
IsPrimitive,
CodeGenFunction, )
import qualified Type.Data.Num.Decimal as TypeNum
import Type.Data.Num.Decimal ((:+:))
import qualified Control.Applicative as App
import qualified Control.Monad.HT as M
import Control.Monad.HT ((<=<), )
import Control.Monad (liftM2, liftM3, foldM, )
import Control.Applicative (liftA2, )
import qualified Data.Traversable as Trav
import qualified Data.Foldable as Fold
import qualified Data.NonEmpty.Class as NonEmptyC
import qualified Data.NonEmpty as NonEmpty
import qualified Data.List.HT as ListHT
import qualified Data.List as List
import Data.NonEmpty ((!:), )
import Data.Int (Int8, Int16, Int32, Int64, )
import Data.Word (Word8, Word16, Word32, Word64, Word)
import Prelude hiding
(Real, truncate, floor, round,
map, zipWith, iterate, replicate, reverse, concat, sum, )
class (Simple v) => C v where
insert :: Value Word32 -> Element v -> v -> CodeGenFunction r v
class
(TypeNum.Positive (Size v), Tuple.Phi v, Tuple.Undefined v) =>
Simple v where
type Element v
type Size v
shuffleMatch ::
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
:: Value Word32 -> v -> CodeGenFunction r (Element v)
instance
(TypeNum.Positive n, LLVM.IsPrimitive a) =>
Simple (Value (Vector n a)) where
type Element (Value (Vector n a)) = Value a
type Size (Value (Vector n a)) = n
shuffleMatch :: forall r.
ConstValue (Vector (Size (Value (Vector n a))) Word32)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
shuffleMatch ConstValue (Vector (Size (Value (Vector n a))) Word32)
is Value (Vector n a)
v = Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
shuffleMatchPlain1 Value (Vector n a)
v ConstValue (Vector n Word32)
ConstValue (Vector (Size (Value (Vector n a))) Word32)
is
extract :: forall r.
Value Word32
-> Value (Vector n a)
-> CodeGenFunction r (Element (Value (Vector n a)))
extract Value Word32
k Value (Vector n a)
v = Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
extractelement Value (Vector n a)
v Value Word32
k
instance
(TypeNum.Positive n, LLVM.IsPrimitive a) =>
C (Value (Vector n a)) where
insert :: forall r.
Value Word32
-> Element (Value (Vector n a))
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n a))
insert Value Word32
k Element (Value (Vector n a))
a Value (Vector n a)
v = Value (Vector n a)
-> Value a
-> Value Word32
-> CodeGenFunction r (Value (Vector n a))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a)
-> Value a
-> Value Word32
-> CodeGenFunction r (Value (Vector n a))
insertelement Value (Vector n a)
v Value a
Element (Value (Vector n a))
a Value Word32
k
instance
(Simple v0, Simple v1, Size v0 ~ Size v1) =>
Simple (v0, v1) where
type Element (v0, v1) = (Element v0, Element v1)
type Size (v0, v1) = Size v0
shuffleMatch :: forall r.
ConstValue (Vector (Size (v0, v1)) Word32)
-> (v0, v1) -> CodeGenFunction r (v0, v1)
shuffleMatch ConstValue (Vector (Size (v0, v1)) Word32)
is (v0
v0,v1
v1) =
(v0 -> v1 -> (v0, v1))
-> CodeGenFunction r v0
-> CodeGenFunction r v1
-> CodeGenFunction r (v0, v1)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,)
(ConstValue (Vector (Size v0) Word32) -> v0 -> CodeGenFunction r v0
forall r.
ConstValue (Vector (Size v0) Word32) -> v0 -> CodeGenFunction r v0
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch ConstValue (Vector (Size v0) Word32)
ConstValue (Vector (Size (v0, v1)) Word32)
is v0
v0)
(ConstValue (Vector (Size v1) Word32) -> v1 -> CodeGenFunction r v1
forall r.
ConstValue (Vector (Size v1) Word32) -> v1 -> CodeGenFunction r v1
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch ConstValue (Vector (Size v1) Word32)
ConstValue (Vector (Size (v0, v1)) Word32)
is v1
v1)
extract :: forall r.
Value Word32 -> (v0, v1) -> CodeGenFunction r (Element (v0, v1))
extract Value Word32
k (v0
v0,v1
v1) =
(Element v0 -> Element v1 -> (Element v0, Element v1))
-> CodeGenFunction r (Element v0)
-> CodeGenFunction r (Element v1)
-> CodeGenFunction r (Element v0, Element v1)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,)
(Value Word32 -> v0 -> CodeGenFunction r (Element v0)
forall r. Value Word32 -> v0 -> CodeGenFunction r (Element v0)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k v0
v0)
(Value Word32 -> v1 -> CodeGenFunction r (Element v1)
forall r. Value Word32 -> v1 -> CodeGenFunction r (Element v1)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k v1
v1)
instance
(C v0, C v1, Size v0 ~ Size v1) =>
C (v0, v1) where
insert :: forall r.
Value Word32
-> Element (v0, v1) -> (v0, v1) -> CodeGenFunction r (v0, v1)
insert Value Word32
k (Element v0
a0,Element v1
a1) (v0
v0,v1
v1) =
(v0 -> v1 -> (v0, v1))
-> CodeGenFunction r v0
-> CodeGenFunction r v1
-> CodeGenFunction r (v0, v1)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,)
(Value Word32 -> Element v0 -> v0 -> CodeGenFunction r v0
forall r. Value Word32 -> Element v0 -> v0 -> CodeGenFunction r v0
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element v0
a0 v0
v0)
(Value Word32 -> Element v1 -> v1 -> CodeGenFunction r v1
forall r. Value Word32 -> Element v1 -> v1 -> CodeGenFunction r v1
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element v1
a1 v1
v1)
instance
(Simple v0, Simple v1, Simple v2, Size v0 ~ Size v1, Size v1 ~ Size v2) =>
Simple (v0, v1, v2) where
type Element (v0, v1, v2) = (Element v0, Element v1, Element v2)
type Size (v0, v1, v2) = Size v0
shuffleMatch :: forall r.
ConstValue (Vector (Size (v0, v1, v2)) Word32)
-> (v0, v1, v2) -> CodeGenFunction r (v0, v1, v2)
shuffleMatch ConstValue (Vector (Size (v0, v1, v2)) Word32)
is (v0
v0,v1
v1,v2
v2) =
(v0 -> v1 -> v2 -> (v0, v1, v2))
-> CodeGenFunction r v0
-> CodeGenFunction r v1
-> CodeGenFunction r v2
-> CodeGenFunction r (v0, v1, v2)
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 (,,)
(ConstValue (Vector (Size v0) Word32) -> v0 -> CodeGenFunction r v0
forall r.
ConstValue (Vector (Size v0) Word32) -> v0 -> CodeGenFunction r v0
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch ConstValue (Vector (Size v0) Word32)
ConstValue (Vector (Size (v0, v1, v2)) Word32)
is v0
v0)
(ConstValue (Vector (Size v1) Word32) -> v1 -> CodeGenFunction r v1
forall r.
ConstValue (Vector (Size v1) Word32) -> v1 -> CodeGenFunction r v1
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch ConstValue (Vector (Size v1) Word32)
ConstValue (Vector (Size (v0, v1, v2)) Word32)
is v1
v1)
(ConstValue (Vector (Size v2) Word32) -> v2 -> CodeGenFunction r v2
forall r.
ConstValue (Vector (Size v2) Word32) -> v2 -> CodeGenFunction r v2
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch ConstValue (Vector (Size v2) Word32)
ConstValue (Vector (Size (v0, v1, v2)) Word32)
is v2
v2)
extract :: forall r.
Value Word32
-> (v0, v1, v2) -> CodeGenFunction r (Element (v0, v1, v2))
extract Value Word32
k (v0
v0,v1
v1,v2
v2) =
(Element v0
-> Element v1
-> Element v2
-> (Element v0, Element v1, Element v2))
-> CodeGenFunction r (Element v0)
-> CodeGenFunction r (Element v1)
-> CodeGenFunction r (Element v2)
-> CodeGenFunction r (Element v0, Element v1, Element v2)
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 (,,)
(Value Word32 -> v0 -> CodeGenFunction r (Element v0)
forall r. Value Word32 -> v0 -> CodeGenFunction r (Element v0)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k v0
v0)
(Value Word32 -> v1 -> CodeGenFunction r (Element v1)
forall r. Value Word32 -> v1 -> CodeGenFunction r (Element v1)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k v1
v1)
(Value Word32 -> v2 -> CodeGenFunction r (Element v2)
forall r. Value Word32 -> v2 -> CodeGenFunction r (Element v2)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k v2
v2)
instance
(C v0, C v1, C v2, Size v0 ~ Size v1, Size v1 ~ Size v2) =>
C (v0, v1, v2) where
insert :: forall r.
Value Word32
-> Element (v0, v1, v2)
-> (v0, v1, v2)
-> CodeGenFunction r (v0, v1, v2)
insert Value Word32
k (Element v0
a0,Element v1
a1,Element v2
a2) (v0
v0,v1
v1,v2
v2) =
(v0 -> v1 -> v2 -> (v0, v1, v2))
-> CodeGenFunction r v0
-> CodeGenFunction r v1
-> CodeGenFunction r v2
-> CodeGenFunction r (v0, v1, v2)
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 (,,)
(Value Word32 -> Element v0 -> v0 -> CodeGenFunction r v0
forall r. Value Word32 -> Element v0 -> v0 -> CodeGenFunction r v0
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element v0
a0 v0
v0)
(Value Word32 -> Element v1 -> v1 -> CodeGenFunction r v1
forall r. Value Word32 -> Element v1 -> v1 -> CodeGenFunction r v1
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element v1
a1 v1
v1)
(Value Word32 -> Element v2 -> v2 -> CodeGenFunction r v2
forall r. Value Word32 -> Element v2 -> v2 -> CodeGenFunction r v2
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k Element v2
a2 v2
v2)
newtype Constant n a = Constant a
constant :: (TypeNum.Positive n) => a -> Constant n a
constant :: forall n a. Positive n => a -> Constant n a
constant = a -> Constant n a
forall n a. a -> Constant n a
Constant
instance Functor (Constant n) where
{-# INLINE fmap #-}
fmap :: forall a b. (a -> b) -> Constant n a -> Constant n b
fmap a -> b
f (Constant a
a) = b -> Constant n b
forall n a. a -> Constant n a
Constant (a -> b
f a
a)
instance App.Applicative (Constant n) where
{-# INLINE pure #-}
pure :: forall a. a -> Constant n a
pure = a -> Constant n a
forall n a. a -> Constant n a
Constant
{-# INLINE (<*>) #-}
Constant a -> b
f <*> :: forall a b. Constant n (a -> b) -> Constant n a -> Constant n b
<*> Constant a
a = b -> Constant n b
forall n a. a -> Constant n a
Constant (a -> b
f a
a)
instance Fold.Foldable (Constant n) where
{-# INLINE foldMap #-}
foldMap :: forall m a. Monoid m => (a -> m) -> Constant n a -> m
foldMap = (a -> m) -> Constant n a -> m
forall (t :: * -> *) m a.
(Traversable t, Monoid m) =>
(a -> m) -> t a -> m
Trav.foldMapDefault
instance Trav.Traversable (Constant n) where
{-# INLINE sequenceA #-}
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Constant n (f a) -> f (Constant n a)
sequenceA (Constant f a
a) = (a -> Constant n a) -> f a -> f (Constant n a)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Constant n a
forall n a. a -> Constant n a
Constant f a
a
instance (Tuple.Phi a) => Tuple.Phi (Constant n a) where
phi :: forall r.
BasicBlock -> Constant n a -> CodeGenFunction r (Constant n a)
phi = BasicBlock -> Constant n a -> CodeGenFunction r (Constant n a)
forall a (f :: * -> *) r.
(Phi a, Traversable f) =>
BasicBlock -> f a -> CodeGenFunction r (f a)
Tuple.phiTraversable
addPhi :: forall r.
BasicBlock -> Constant n a -> Constant n a -> CodeGenFunction r ()
addPhi = BasicBlock -> Constant n a -> Constant n a -> CodeGenFunction r ()
forall a (f :: * -> *) r.
(Phi a, Foldable f, Applicative f) =>
BasicBlock -> f a -> f a -> CodeGenFunction r ()
Tuple.addPhiFoldable
instance (Tuple.Undefined a) => Tuple.Undefined (Constant n a) where
undef :: Constant n a
undef = Constant n a
forall a (f :: * -> *). (Undefined a, Applicative f) => f a
Tuple.undefPointed
instance (TypeNum.Positive n, Tuple.Phi a, Tuple.Undefined a) => Simple (Constant n a) where
type Element (Constant n a) = a
type Size (Constant n a) = n
shuffleMatch :: forall r.
ConstValue (Vector (Size (Constant n a)) Word32)
-> Constant n a -> CodeGenFunction r (Constant n a)
shuffleMatch ConstValue (Vector (Size (Constant n a)) Word32)
_ = Constant n a -> CodeGenFunction r (Constant n a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
extract :: forall r.
Value Word32
-> Constant n a -> CodeGenFunction r (Element (Constant n a))
extract Value Word32
_ (Constant a
a) = a -> CodeGenFunction r a
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
a
class (n ~ Size (Construct n a), a ~ Element (Construct n a),
C (Construct n a)) =>
Canonical n a where
type Construct n a
instance
(TypeNum.Positive n, LLVM.IsPrimitive a) =>
Canonical n (Value a) where
type Construct n (Value a) = Value (Vector n a)
instance (Canonical n a0, Canonical n a1) => Canonical n (a0, a1) where
type Construct n (a0, a1) = (Construct n a0, Construct n a1)
instance (Canonical n a0, Canonical n a1, Canonical n a2) => Canonical n (a0, a1, a2) where
type Construct n (a0, a1, a2) = (Construct n a0, Construct n a1, Construct n a2)
size ::
(TypeNum.Positive n) =>
Value (Vector n a) -> Int
size :: forall n a. Positive n => Value (Vector n a) -> Int
size =
let sz :: (TypeNum.Positive n) => TypeNum.Singleton n -> Value (Vector n a) -> Int
sz :: forall n a. Positive n => Singleton n -> Value (Vector n a) -> Int
sz Singleton n
n Value (Vector n a)
_ = Singleton n -> Int
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton Singleton n
n
in Singleton n -> Value (Vector n a) -> Int
forall n a. Positive n => Singleton n -> Value (Vector n a) -> Int
sz Singleton n
forall x. Integer x => Singleton x
TypeNum.singleton
replicate ::
(C v) =>
Element v -> CodeGenFunction r v
replicate :: forall v r. C v => Element v -> CodeGenFunction r v
replicate = Singleton (Size v) -> Element v -> CodeGenFunction r v
forall v r.
C v =>
Singleton (Size v) -> Element v -> CodeGenFunction r v
replicateCore Singleton (Size v)
forall x. Integer x => Singleton x
TypeNum.singleton
replicateCore ::
(C v) =>
TypeNum.Singleton (Size v) -> Element v -> CodeGenFunction r v
replicateCore :: forall v r.
C v =>
Singleton (Size v) -> Element v -> CodeGenFunction r v
replicateCore Singleton (Size v)
n =
[Element v] -> CodeGenFunction r v
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r v)
-> (Element v -> [Element v]) -> Element v -> CodeGenFunction r v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Element v -> [Element v]
forall a. Int -> a -> [a]
List.replicate (Singleton (Size v) -> Int
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton Singleton (Size v)
n)
assemble ::
(C v) =>
[Element v] -> CodeGenFunction r v
assemble :: forall v r. C v => [Element v] -> CodeGenFunction r v
assemble =
(v -> (Word32, Element v) -> CodeGenFunction r v)
-> v -> [(Word32, Element v)] -> CodeGenFunction r v
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (\v
v (Word32
k,Element v
x) -> Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
k) Element v
x v
v) v
forall a. Undefined a => a
Tuple.undef ([(Word32, Element v)] -> CodeGenFunction r v)
-> ([Element v] -> [(Word32, Element v)])
-> [Element v]
-> CodeGenFunction r v
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
[Word32] -> [Element v] -> [(Word32, Element v)]
forall a b. [a] -> [b] -> [(a, b)]
List.zip [Word32
0..]
insertChunk ::
(C c, C v, Element c ~ Element v) =>
Int -> c ->
v -> CodeGenFunction r v
insertChunk :: forall c v r.
(C c, C v, Element c ~ Element v) =>
Int -> c -> v -> CodeGenFunction r v
insertChunk Int
k c
x =
[v -> CodeGenFunction r v] -> v -> CodeGenFunction r v
forall (m :: * -> *) a. Monad m => [a -> m a] -> a -> m a
M.chain ([v -> CodeGenFunction r v] -> v -> CodeGenFunction r v)
-> [v -> CodeGenFunction r v] -> v -> CodeGenFunction r v
forall a b. (a -> b) -> a -> b
$
(Word32 -> Word32 -> v -> CodeGenFunction r v)
-> [Word32] -> [Word32] -> [v -> CodeGenFunction r v]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
List.zipWith
(\Word32
i Word32
j -> \v
v ->
Value Word32 -> c -> CodeGenFunction r (Element c)
forall r. Value Word32 -> c -> CodeGenFunction r (Element c)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
i) c
x CodeGenFunction r (Element v)
-> (Element v -> CodeGenFunction r v) -> CodeGenFunction r v
forall a b.
CodeGenFunction r a
-> (a -> CodeGenFunction r b) -> CodeGenFunction r b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Element v
e ->
Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
j) Element v
e v
v)
(Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take (c -> Int
forall v. Simple v => v -> Int
sizeInTuple c
x) [Word32
0..])
[Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
k ..]
iterate ::
(C v) =>
(Element v -> CodeGenFunction r (Element v)) ->
Element v -> CodeGenFunction r v
iterate :: forall v r.
C v =>
(Element v -> CodeGenFunction r (Element v))
-> Element v -> CodeGenFunction r v
iterate Element v -> CodeGenFunction r (Element v)
f Element v
x =
((Element v, v) -> v)
-> CodeGenFunction r (Element v, v) -> CodeGenFunction r v
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Element v, v) -> v
forall a b. (a, b) -> b
snd (CodeGenFunction r (Element v, v) -> CodeGenFunction r v)
-> CodeGenFunction r (Element v, v) -> CodeGenFunction r v
forall a b. (a -> b) -> a -> b
$
(Element v -> CodeGenFunction r (Element v))
-> Element v -> v -> CodeGenFunction r (Element v, v)
forall v r.
C v =>
(Element v -> CodeGenFunction r (Element v))
-> Element v -> v -> CodeGenFunction r (Element v, v)
iterateCore Element v -> CodeGenFunction r (Element v)
f Element v
x v
forall a. Undefined a => a
Tuple.undef
iterateCore ::
(C v) =>
(Element v -> CodeGenFunction r (Element v)) ->
Element v -> v ->
CodeGenFunction r (Element v, v)
iterateCore :: forall v r.
C v =>
(Element v -> CodeGenFunction r (Element v))
-> Element v -> v -> CodeGenFunction r (Element v, v)
iterateCore Element v -> CodeGenFunction r (Element v)
f Element v
x0 v
v0 =
((Element v, v) -> Word32 -> CodeGenFunction r (Element v, v))
-> (Element v, v) -> [Word32] -> CodeGenFunction r (Element v, v)
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM
(\(Element v
x,v
v) Word32
k ->
(Element v -> v -> (Element v, v))
-> CodeGenFunction r (Element v)
-> CodeGenFunction r v
-> CodeGenFunction r (Element v, v)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) (Element v -> CodeGenFunction r (Element v)
f Element v
x)
(Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
k) Element v
x v
v))
(Element v
x0,v
v0)
(Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
v0) [Word32
0..])
shuffle ::
(C v, C w, Element v ~ Element w) =>
v ->
ConstValue (Vector (Size w) Word32) ->
CodeGenFunction r w
shuffle :: forall v w r.
(C v, C w, Element v ~ Element w) =>
v -> ConstValue (Vector (Size w) Word32) -> CodeGenFunction r w
shuffle v
x ConstValue (Vector (Size w) Word32)
i =
[Element w] -> CodeGenFunction r w
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble ([Element w] -> CodeGenFunction r w)
-> CodeGenFunction r [Element w] -> CodeGenFunction r w
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
(Word32 -> CodeGenFunction r (Element w))
-> [Word32] -> CodeGenFunction r [Element w]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM
((Value Word32 -> v -> CodeGenFunction r (Element w))
-> v -> Value Word32 -> CodeGenFunction r (Element w)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value Word32 -> v -> CodeGenFunction r (Element v)
Value Word32 -> v -> CodeGenFunction r (Element w)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract v
x (Value Word32 -> CodeGenFunction r (Element w))
-> (Word32 -> CodeGenFunction r (Value Word32))
-> Word32
-> CodeGenFunction r (Element w)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Value (Vector (Size w) Word32)
-> Value Word32 -> CodeGenFunction r (Value Word32)
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
extractelement (ConstValue (Vector (Size w) Word32)
-> Value (Vector (Size w) Word32)
forall a. ConstValue a -> Value a
value ConstValue (Vector (Size w) Word32)
i) (Value Word32 -> CodeGenFunction r (Value Word32))
-> (Word32 -> Value Word32)
-> Word32
-> CodeGenFunction r (Value Word32)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf)
(Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take (Value (Vector (Size w) Word32) -> Int
forall n a. Positive n => Value (Vector n a) -> Int
size (ConstValue (Vector (Size w) Word32)
-> Value (Vector (Size w) Word32)
forall a. ConstValue a -> Value a
value ConstValue (Vector (Size w) Word32)
i)) [Word32
0..])
sizeInTuple :: Simple v => v -> Int
sizeInTuple :: forall v. Simple v => v -> Int
sizeInTuple =
let sz :: Simple v => TypeNum.Singleton (Size v) -> v -> Int
sz :: forall v. Simple v => Singleton (Size v) -> v -> Int
sz Singleton (Size v)
n v
_ = Singleton (Size v) -> Int
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton Singleton (Size v)
n
in Singleton (Size v) -> v -> Int
forall v. Simple v => Singleton (Size v) -> v -> Int
sz Singleton (Size v)
forall x. Integer x => Singleton x
TypeNum.singleton
constCyclicVector ::
(IsConst a, TypeNum.Positive n) =>
NonEmpty.T [] a -> ConstValue (Vector n a)
constCyclicVector :: forall a n.
(IsConst a, Positive n) =>
T [] a -> ConstValue (Vector n a)
constCyclicVector =
T [] (ConstValue a) -> ConstValue (Vector n a)
forall a n.
Positive n =>
T [] (ConstValue a) -> ConstValue (Vector n a)
LLVM.constCyclicVector (T [] (ConstValue a) -> ConstValue (Vector n a))
-> (T [] a -> T [] (ConstValue a))
-> T [] a
-> ConstValue (Vector n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> ConstValue a) -> T [] a -> T [] (ConstValue a)
forall a b. (a -> b) -> T [] a -> T [] b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> ConstValue a
forall a. IsConst a => a -> ConstValue a
constOf
rotateUp ::
(Simple v) =>
v -> CodeGenFunction r v
rotateUp :: forall v r. Simple v => v -> CodeGenFunction r v
rotateUp v
x =
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall r.
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch
(T [] Word32 -> ConstValue (Vector (Size v) Word32)
forall a n.
(IsConst a, Positive n) =>
T [] a -> ConstValue (Vector n a)
constCyclicVector (T [] Word32 -> ConstValue (Vector (Size v) Word32))
-> T [] Word32 -> ConstValue (Vector (Size v) Word32)
forall a b. (a -> b) -> a -> b
$
(Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
x) Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1) Word32 -> [Word32] -> T [] Word32
forall a (f :: * -> *). a -> f a -> T f a
!: [Word32
0..]) v
x
rotateDown ::
(Simple v) =>
v -> CodeGenFunction r v
rotateDown :: forall v r. Simple v => v -> CodeGenFunction r v
rotateDown v
x =
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall r.
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch
(T [] Word32 -> ConstValue (Vector (Size v) Word32)
forall a n.
(IsConst a, Positive n) =>
T [] a -> ConstValue (Vector n a)
constCyclicVector (T [] Word32 -> ConstValue (Vector (Size v) Word32))
-> T [] Word32 -> ConstValue (Vector (Size v) Word32)
forall a b. (a -> b) -> a -> b
$
[Word32] -> Word32 -> T [] Word32
forall (f :: * -> *) a. Traversable f => f a -> a -> T f a
NonEmpty.snoc (Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
List.take (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) [Word32
1..]) Word32
0) v
x
reverse ::
(Simple v) =>
v -> CodeGenFunction r v
reverse :: forall v r. Simple v => v -> CodeGenFunction r v
reverse v
x =
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall r.
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch
(T [] Word32 -> ConstValue (Vector (Size v) Word32)
forall a n.
(IsConst a, Positive n) =>
T [] a -> ConstValue (Vector n a)
constCyclicVector (T [] Word32 -> ConstValue (Vector (Size v) Word32))
-> T [] Word32 -> ConstValue (Vector (Size v) Word32)
forall a b. (a -> b) -> a -> b
$
T [] Word32
-> (T [] Word32 -> T [] Word32)
-> Maybe (T [] Word32)
-> T [] Word32
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> T [] Word32
forall a. HasCallStack => [Char] -> a
error [Char]
"vector size must be positive") T [] Word32 -> T [] Word32
forall (f :: * -> *) a.
(Traversable f, Reverse f) =>
T f a -> T f a
NonEmpty.reverse (Maybe (T [] Word32) -> T [] Word32)
-> Maybe (T [] Word32) -> T [] Word32
forall a b. (a -> b) -> a -> b
$
[Word32] -> Maybe (T [] Word32)
forall (f :: * -> *) a. ViewL f => f a -> Maybe (T f a)
NonEmpty.fetch ([Word32] -> Maybe (T [] Word32))
-> [Word32] -> Maybe (T [] Word32)
forall a b. (a -> b) -> a -> b
$
Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
List.take (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
x) [Word32
0..])
v
x
shiftUp ::
(C v) =>
Element v -> v -> CodeGenFunction r (Element v, v)
shiftUp :: forall v r.
C v =>
Element v -> v -> CodeGenFunction r (Element v, v)
shiftUp Element v
x0 v
x = do
v
y <-
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall r.
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch
(T [] (ConstValue Word32) -> ConstValue (Vector (Size v) Word32)
forall a n.
Positive n =>
T [] (ConstValue a) -> ConstValue (Vector n a)
LLVM.constCyclicVector (T [] (ConstValue Word32) -> ConstValue (Vector (Size v) Word32))
-> T [] (ConstValue Word32) -> ConstValue (Vector (Size v) Word32)
forall a b. (a -> b) -> a -> b
$ ConstValue Word32
forall a. IsType a => ConstValue a
undef ConstValue Word32
-> [ConstValue Word32] -> T [] (ConstValue Word32)
forall a (f :: * -> *). a -> f a -> T f a
!: (Word32 -> ConstValue Word32) -> [Word32] -> [ConstValue Word32]
forall a b. (a -> b) -> [a] -> [b]
List.map Word32 -> ConstValue Word32
forall a. IsConst a => a -> ConstValue a
constOf [Word32
0..]) v
x
(Element v -> v -> (Element v, v))
-> CodeGenFunction r (Element v)
-> CodeGenFunction r v
-> CodeGenFunction r (Element v, v)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,)
(Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
x) Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1)) v
x)
(Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert (ConstValue Word32 -> Value Word32
forall a. ConstValue a -> Value a
value ConstValue Word32
forall a. IsType a => ConstValue a
LLVM.zero) Element v
x0 v
y)
shiftDown ::
(C v) =>
Element v -> v -> CodeGenFunction r (Element v, v)
shiftDown :: forall v r.
C v =>
Element v -> v -> CodeGenFunction r (Element v, v)
shiftDown Element v
x0 v
x = do
v
y <-
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall r.
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch
(T [] (ConstValue Word32) -> ConstValue (Vector (Size v) Word32)
forall a n.
Positive n =>
T [] (ConstValue a) -> ConstValue (Vector n a)
LLVM.constCyclicVector (T [] (ConstValue Word32) -> ConstValue (Vector (Size v) Word32))
-> T [] (ConstValue Word32) -> ConstValue (Vector (Size v) Word32)
forall a b. (a -> b) -> a -> b
$
[ConstValue Word32]
-> ConstValue Word32 -> T [] (ConstValue Word32)
forall (f :: * -> *) a. Traversable f => f a -> a -> T f a
NonEmpty.snoc
((Word32 -> ConstValue Word32) -> [Word32] -> [ConstValue Word32]
forall a b. (a -> b) -> [a] -> [b]
List.map Word32 -> ConstValue Word32
forall a. IsConst a => a -> ConstValue a
constOf ([Word32] -> [ConstValue Word32])
-> [Word32] -> [ConstValue Word32]
forall a b. (a -> b) -> a -> b
$ Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
List.take (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) [Word32
1..])
ConstValue Word32
forall a. IsType a => ConstValue a
undef) v
x
(Element v -> v -> (Element v, v))
-> CodeGenFunction r (Element v)
-> CodeGenFunction r v
-> CodeGenFunction r (Element v, v)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,)
(Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (ConstValue Word32 -> Value Word32
forall a. ConstValue a -> Value a
value ConstValue Word32
forall a. IsType a => ConstValue a
LLVM.zero) v
x)
(Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
x) Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1)) Element v
x0 v
y)
shiftUpMultiZero ::
(C v, Tuple.Zero (Element v)) =>
Int -> v -> LLVM.CodeGenFunction r v
shiftUpMultiZero :: forall v r.
(C v, Zero (Element v)) =>
Int -> v -> CodeGenFunction r v
shiftUpMultiZero Int
n v
v =
[Element v] -> CodeGenFunction r v
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r v)
-> ([Element v] -> [Element v])
-> [Element v]
-> CodeGenFunction r v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Element v] -> [Element v]
forall a. Int -> [a] -> [a]
take (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
v) ([Element v] -> [Element v])
-> ([Element v] -> [Element v]) -> [Element v] -> [Element v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
(Int -> Element v -> [Element v]
forall a. Int -> a -> [a]
List.replicate Int
n Element v
forall a. Zero a => a
Tuple.zero [Element v] -> [Element v] -> [Element v]
forall a. [a] -> [a] -> [a]
++) ([Element v] -> CodeGenFunction r v)
-> CodeGenFunction r [Element v] -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< v -> CodeGenFunction r [Element v]
forall v r. Simple v => v -> CodeGenFunction r [Element v]
extractAll v
v
shiftDownMultiZero ::
(C v, Tuple.Zero (Element v)) =>
Int -> v -> LLVM.CodeGenFunction r v
shiftDownMultiZero :: forall v r.
(C v, Zero (Element v)) =>
Int -> v -> CodeGenFunction r v
shiftDownMultiZero Int
n v
v =
[Element v] -> CodeGenFunction r v
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r v)
-> ([Element v] -> [Element v])
-> [Element v]
-> CodeGenFunction r v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Element v] -> [Element v]
forall a. Int -> [a] -> [a]
take (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
v) ([Element v] -> [Element v])
-> ([Element v] -> [Element v]) -> [Element v] -> [Element v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
([Element v] -> [Element v] -> [Element v]
forall a. [a] -> [a] -> [a]
++ Element v -> [Element v]
forall a. a -> [a]
List.repeat Element v
forall a. Zero a => a
Tuple.zero) ([Element v] -> [Element v])
-> ([Element v] -> [Element v]) -> [Element v] -> [Element v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [Element v] -> [Element v]
forall a. Int -> [a] -> [a]
List.drop Int
n
([Element v] -> CodeGenFunction r v)
-> CodeGenFunction r [Element v] -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< v -> CodeGenFunction r [Element v]
forall v r. Simple v => v -> CodeGenFunction r [Element v]
extractAll v
v
shuffleMatchTraversable ::
(Simple v, Trav.Traversable f) =>
ConstValue (Vector (Size v) Word32) -> f v -> CodeGenFunction r (f v)
shuffleMatchTraversable :: forall v (f :: * -> *) r.
(Simple v, Traversable f) =>
ConstValue (Vector (Size v) Word32)
-> f v -> CodeGenFunction r (f v)
shuffleMatchTraversable ConstValue (Vector (Size v) Word32)
is f v
v =
(v -> CodeGenFunction r v) -> f v -> CodeGenFunction r (f v)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> f a -> m (f b)
Trav.mapM (ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall r.
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
forall v r.
Simple v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatch ConstValue (Vector (Size v) Word32)
is) f v
v
shuffleMatchAccess ::
(C v) =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatchAccess :: forall v r.
C v =>
ConstValue (Vector (Size v) Word32) -> v -> CodeGenFunction r v
shuffleMatchAccess ConstValue (Vector (Size v) Word32)
is v
v =
[Element v] -> CodeGenFunction r v
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r v)
-> CodeGenFunction r [Element v] -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
(Word32 -> CodeGenFunction r (Element v))
-> [Word32] -> CodeGenFunction r [Element v]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM
((Value Word32 -> v -> CodeGenFunction r (Element v))
-> v -> Value Word32 -> CodeGenFunction r (Element v)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract v
v (Value Word32 -> CodeGenFunction r (Element v))
-> (Word32 -> CodeGenFunction r (Value Word32))
-> Word32
-> CodeGenFunction r (Element v)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=<
(Value Word32
-> Value (Vector (Size v) Word32)
-> CodeGenFunction r (Value Word32))
-> Value (Vector (Size v) Word32)
-> Value Word32
-> CodeGenFunction r (Value Word32)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value Word32
-> Value (Vector (Size v) Word32)
-> CodeGenFunction r (Value Word32)
Value Word32
-> Value (Vector (Size v) Word32)
-> CodeGenFunction r (Element (Value (Vector (Size v) Word32)))
forall r.
Value Word32
-> Value (Vector (Size v) Word32)
-> CodeGenFunction r (Element (Value (Vector (Size v) Word32)))
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (ConstValue (Vector (Size v) Word32)
-> Value (Vector (Size v) Word32)
forall a. ConstValue a -> Value a
value ConstValue (Vector (Size v) Word32)
is) (Value Word32 -> CodeGenFunction r (Value Word32))
-> (Word32 -> Value Word32)
-> Word32
-> CodeGenFunction r (Value Word32)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf)
(Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take (Value (Vector (Size v) Word32) -> Int
forall n a. Positive n => Value (Vector n a) -> Int
size (ConstValue (Vector (Size v) Word32)
-> Value (Vector (Size v) Word32)
forall a. ConstValue a -> Value a
value ConstValue (Vector (Size v) Word32)
is)) [Word32
0..])
shuffleMatchPlain1 ::
(TypeNum.Positive n, IsPrimitive a) =>
Value (Vector n a) ->
ConstValue (Vector n Word32) ->
CodeGenFunction r (Value (Vector n a))
shuffleMatchPlain1 :: forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
shuffleMatchPlain1 Value (Vector n a)
x =
Value (Vector n a)
-> Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a)
-> Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
shuffleMatchPlain2 Value (Vector n a)
x (ConstValue (Vector n a) -> Value (Vector n a)
forall a. ConstValue a -> Value a
value ConstValue (Vector n a)
forall a. IsType a => ConstValue a
undef)
shuffleMatchPlain2 ::
(TypeNum.Positive n, IsPrimitive a) =>
Value (Vector n a) ->
Value (Vector n a) ->
ConstValue (Vector n Word32) ->
CodeGenFunction r (Value (Vector n a))
shuffleMatchPlain2 :: forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a)
-> Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
shuffleMatchPlain2 =
Value (Vector n a)
-> Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
forall n m a r.
(Positive n, Positive m, IsPrimitive a) =>
Value (Vector n a)
-> Value (Vector n a)
-> ConstValue (Vector m Word32)
-> CodeGenFunction r (Value (Vector m a))
LLVM.shufflevector
insertTraversable ::
(C v, Trav.Traversable f, App.Applicative f) =>
Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)
insertTraversable :: forall v (f :: * -> *) r.
(C v, Traversable f, Applicative f) =>
Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)
insertTraversable Value Word32
n f (Element v)
a f v
v =
f (CodeGenFunction r v) -> CodeGenFunction r (f v)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
Trav.sequence ((Element v -> v -> CodeGenFunction r v)
-> f (Element v) -> f v -> f (CodeGenFunction r v)
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
n) f (Element v)
a f v
v)
extractTraversable ::
(Simple v, Trav.Traversable f) =>
Value Word32 -> f v -> CodeGenFunction r (f (Element v))
Value Word32
n f v
v =
(v -> CodeGenFunction r (Element v))
-> f v -> CodeGenFunction r (f (Element v))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> f a -> m (f b)
Trav.mapM (Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
n) f v
v
extractAll ::
(Simple v) =>
v -> LLVM.CodeGenFunction r [Element v]
= [CodeGenFunction r (Element v)] -> CodeGenFunction r [Element v]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([CodeGenFunction r (Element v)] -> CodeGenFunction r [Element v])
-> (v -> [CodeGenFunction r (Element v)])
-> v
-> CodeGenFunction r [Element v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. v -> [CodeGenFunction r (Element v)]
forall v r. Simple v => v -> [CodeGenFunction r (Element v)]
extractList
extractList ::
(Simple v) =>
v -> [LLVM.CodeGenFunction r (Element v)]
v
x =
(Word32 -> CodeGenFunction r (Element v))
-> [Word32] -> [CodeGenFunction r (Element v)]
forall a b. (a -> b) -> [a] -> [b]
List.map
((Value Word32 -> v -> CodeGenFunction r (Element v))
-> v -> Value Word32 -> CodeGenFunction r (Element v)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract v
x (Value Word32 -> CodeGenFunction r (Element v))
-> (Word32 -> Value Word32)
-> Word32
-> CodeGenFunction r (Element v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Value Word32
forall a. IsConst a => a -> Value a
LLVM.valueOf)
(Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
x) [Word32
0..])
modify ::
(C v) =>
Value Word32 ->
(Element v -> CodeGenFunction r (Element v)) ->
(v -> CodeGenFunction r v)
modify :: forall v r.
C v =>
Value Word32
-> (Element v -> CodeGenFunction r (Element v))
-> v
-> CodeGenFunction r v
modify Value Word32
k Element v -> CodeGenFunction r (Element v)
f v
v =
(Element v -> v -> CodeGenFunction r v)
-> v -> Element v -> CodeGenFunction r v
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert Value Word32
k) v
v (Element v -> CodeGenFunction r v)
-> CodeGenFunction r (Element v) -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Element v -> CodeGenFunction r (Element v)
f (Element v -> CodeGenFunction r (Element v))
-> CodeGenFunction r (Element v) -> CodeGenFunction r (Element v)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract Value Word32
k v
v
map, _mapByFold ::
(C v, C w, Size v ~ Size w) =>
(Element v -> CodeGenFunction r (Element w)) ->
(v -> CodeGenFunction r w)
map :: forall v w r.
(C v, C w, Size v ~ Size w) =>
(Element v -> CodeGenFunction r (Element w))
-> v -> CodeGenFunction r w
map Element v -> CodeGenFunction r (Element w)
f =
[Element w] -> CodeGenFunction r w
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble ([Element w] -> CodeGenFunction r w)
-> (v -> CodeGenFunction r [Element w]) -> v -> CodeGenFunction r w
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< (Element v -> CodeGenFunction r (Element w))
-> [Element v] -> CodeGenFunction r [Element w]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Element v -> CodeGenFunction r (Element w)
f ([Element v] -> CodeGenFunction r [Element w])
-> (v -> CodeGenFunction r [Element v])
-> v
-> CodeGenFunction r [Element w]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< v -> CodeGenFunction r [Element v]
forall v r. Simple v => v -> CodeGenFunction r [Element v]
extractAll
_mapByFold :: forall v w r.
(C v, C w, Size v ~ Size w) =>
(Element v -> CodeGenFunction r (Element w))
-> v -> CodeGenFunction r w
_mapByFold Element v -> CodeGenFunction r (Element w)
f v
a =
(w -> Word32 -> CodeGenFunction r w)
-> w -> [Word32] -> CodeGenFunction r w
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM
(\w
b Word32
n ->
Value Word32 -> v -> CodeGenFunction r (Element v)
forall r. Value Word32 -> v -> CodeGenFunction r (Element v)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
n) v
a CodeGenFunction r (Element v)
-> (Element v -> CodeGenFunction r (Element w))
-> CodeGenFunction r (Element w)
forall a b.
CodeGenFunction r a
-> (a -> CodeGenFunction r b) -> CodeGenFunction r b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
Element v -> CodeGenFunction r (Element w)
f CodeGenFunction r (Element w)
-> (Element w -> CodeGenFunction r w) -> CodeGenFunction r w
forall a b.
CodeGenFunction r a
-> (a -> CodeGenFunction r b) -> CodeGenFunction r b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
(Element w -> w -> CodeGenFunction r w)
-> w -> Element w -> CodeGenFunction r w
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Value Word32 -> Element w -> w -> CodeGenFunction r w
forall r. Value Word32 -> Element w -> w -> CodeGenFunction r w
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
n)) w
b)
w
forall a. Undefined a => a
Tuple.undef
(Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take (v -> Int
forall v. Simple v => v -> Int
sizeInTuple v
a) [Word32
0..])
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)
mapChunks :: forall ca cb va vb r.
(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
mapChunks ca -> CodeGenFunction r cb
f va
a =
(vb -> (CodeGenFunction r ca, Int) -> CodeGenFunction r vb)
-> vb -> [(CodeGenFunction r ca, Int)] -> CodeGenFunction r vb
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM
(\vb
b (CodeGenFunction r ca
am,Int
k) ->
CodeGenFunction r ca
am CodeGenFunction r ca
-> (ca -> CodeGenFunction r vb) -> CodeGenFunction r vb
forall a b.
CodeGenFunction r a
-> (a -> CodeGenFunction r b) -> CodeGenFunction r b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ca
ac ->
ca -> CodeGenFunction r cb
f ca
ac CodeGenFunction r cb
-> (cb -> CodeGenFunction r vb) -> CodeGenFunction r vb
forall a b.
CodeGenFunction r a
-> (a -> CodeGenFunction r b) -> CodeGenFunction r b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \cb
bc ->
Int -> cb -> vb -> CodeGenFunction r vb
forall c v r.
(C c, C v, Element c ~ Element v) =>
Int -> c -> v -> CodeGenFunction r v
insertChunk (Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
* ca -> Int
forall v. Simple v => v -> Int
sizeInTuple ca
ac) cb
bc vb
b)
vb
forall a. Undefined a => a
Tuple.undef ([(CodeGenFunction r ca, Int)] -> CodeGenFunction r vb)
-> [(CodeGenFunction r ca, Int)] -> CodeGenFunction r vb
forall a b. (a -> b) -> a -> b
$
[CodeGenFunction r ca] -> [Int] -> [(CodeGenFunction r ca, Int)]
forall a b. [a] -> [b] -> [(a, b)]
List.zip (va -> [CodeGenFunction r ca]
forall c v r.
(C c, C v, Element c ~ Element v) =>
v -> [CodeGenFunction r c]
chop va
a) [Int
0..]
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)
zipChunksWith :: forall ca cb cc va vb vc r.
(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
zipChunksWith ca -> cb -> CodeGenFunction r cc
f va
a vb
b =
((ca, cb) -> CodeGenFunction r cc)
-> (va, vb) -> CodeGenFunction r vc
forall ca cb va vb r.
(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
mapChunks ((ca -> cb -> CodeGenFunction r cc)
-> (ca, cb) -> CodeGenFunction r cc
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ca -> cb -> CodeGenFunction r cc
f) (va
a,vb
b)
mapChunks2 ::
(C ca, C cb, Size ca ~ Size cb,
C la, C lb, Size la ~ Size lb,
C va, C vb, Size va ~ Size vb,
Element ca ~ Element va, Element la ~ Element va,
Element cb ~ Element vb, Element lb ~ Element vb) =>
(ca -> CodeGenFunction r cb) ->
(la -> CodeGenFunction r lb) ->
(va -> CodeGenFunction r vb)
mapChunks2 :: forall ca cb la lb va vb r.
(C ca, C cb, Size ca ~ Size cb, C la, C lb, Size la ~ Size lb,
C va, C vb, Size va ~ Size vb, Element ca ~ Element va,
Element la ~ Element va, Element cb ~ Element vb,
Element lb ~ Element vb) =>
(ca -> CodeGenFunction r cb)
-> (la -> CodeGenFunction r lb) -> va -> CodeGenFunction r vb
mapChunks2 ca -> CodeGenFunction r cb
f la -> CodeGenFunction r lb
g va
a = do
let chunkSize :: C ca => (ca -> cgf) -> TypeNum.Singleton (Size ca) -> Int
chunkSize :: forall ca cgf. C ca => (ca -> cgf) -> Singleton (Size ca) -> Int
chunkSize ca -> cgf
_ = Singleton (Size ca) -> Int
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton
[Element va]
xs <- va -> CodeGenFunction r [Element va]
forall v r. Simple v => v -> CodeGenFunction r [Element v]
extractAll va
a
case [[Element va]] -> Maybe ([[Element va]], [Element va])
forall a. [a] -> Maybe ([a], a)
ListHT.viewR ([[Element va]] -> Maybe ([[Element va]], [Element va]))
-> [[Element va]] -> Maybe ([[Element va]], [Element va])
forall a b. (a -> b) -> a -> b
$
Int -> [Element va] -> [[Element va]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceVertical ((la -> CodeGenFunction r lb) -> Singleton (Size la) -> Int
forall ca cgf. C ca => (ca -> cgf) -> Singleton (Size ca) -> Int
chunkSize la -> CodeGenFunction r lb
g Singleton (Size la)
Singleton (Size lb)
forall x. Integer x => Singleton x
TypeNum.singleton) [Element va]
xs of
Maybe ([[Element va]], [Element va])
Nothing -> [Element vb] -> CodeGenFunction r vb
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble []
Just ([[Element va]]
cs,[Element va]
c) -> do
[[Element vb]]
ds <- ([Element va] -> CodeGenFunction r [Element vb])
-> [[Element va]] -> CodeGenFunction r [[Element vb]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (lb -> CodeGenFunction r [Element lb]
lb -> CodeGenFunction r [Element vb]
forall v r. Simple v => v -> CodeGenFunction r [Element v]
extractAll (lb -> CodeGenFunction r [Element vb])
-> ([Element va] -> CodeGenFunction r lb)
-> [Element va]
-> CodeGenFunction r [Element vb]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< la -> CodeGenFunction r lb
g (la -> CodeGenFunction r lb)
-> ([Element va] -> CodeGenFunction r la)
-> [Element va]
-> CodeGenFunction r lb
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Element la] -> CodeGenFunction r la
[Element va] -> CodeGenFunction r la
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble) [[Element va]]
cs
[Element vb]
d <-
if [Element va] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
List.length [Element va]
c Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= (ca -> CodeGenFunction r cb) -> Singleton (Size ca) -> Int
forall ca cgf. C ca => (ca -> cgf) -> Singleton (Size ca) -> Int
chunkSize ca -> CodeGenFunction r cb
f Singleton (Size ca)
Singleton (Size cb)
forall x. Integer x => Singleton x
TypeNum.singleton
then ([[Element vb]] -> [Element vb])
-> CodeGenFunction r [[Element vb]]
-> CodeGenFunction r [Element vb]
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [[Element vb]] -> [Element vb]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
List.concat (CodeGenFunction r [[Element vb]]
-> CodeGenFunction r [Element vb])
-> CodeGenFunction r [[Element vb]]
-> CodeGenFunction r [Element vb]
forall a b. (a -> b) -> a -> b
$
([Element va] -> CodeGenFunction r [Element vb])
-> [[Element va]] -> CodeGenFunction r [[Element vb]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (cb -> CodeGenFunction r [Element cb]
cb -> CodeGenFunction r [Element vb]
forall v r. Simple v => v -> CodeGenFunction r [Element v]
extractAll (cb -> CodeGenFunction r [Element vb])
-> ([Element va] -> CodeGenFunction r cb)
-> [Element va]
-> CodeGenFunction r [Element vb]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< ca -> CodeGenFunction r cb
f (ca -> CodeGenFunction r cb)
-> ([Element va] -> CodeGenFunction r ca)
-> [Element va]
-> CodeGenFunction r cb
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [Element ca] -> CodeGenFunction r ca
[Element va] -> CodeGenFunction r ca
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble) ([[Element va]] -> CodeGenFunction r [[Element vb]])
-> [[Element va]] -> CodeGenFunction r [[Element vb]]
forall a b. (a -> b) -> a -> b
$
Int -> [Element va] -> [[Element va]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceVertical ((ca -> CodeGenFunction r cb) -> Singleton (Size ca) -> Int
forall ca cgf. C ca => (ca -> cgf) -> Singleton (Size ca) -> Int
chunkSize ca -> CodeGenFunction r cb
f Singleton (Size ca)
Singleton (Size cb)
forall x. Integer x => Singleton x
TypeNum.singleton) [Element va]
c
else lb -> CodeGenFunction r [Element lb]
lb -> CodeGenFunction r [Element vb]
forall v r. Simple v => v -> CodeGenFunction r [Element v]
extractAll (lb -> CodeGenFunction r [Element vb])
-> CodeGenFunction r lb -> CodeGenFunction r [Element vb]
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< la -> CodeGenFunction r lb
g (la -> CodeGenFunction r lb)
-> CodeGenFunction r la -> CodeGenFunction r lb
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Element la] -> CodeGenFunction r la
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble [Element la]
[Element va]
c
[Element vb] -> CodeGenFunction r vb
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble ([Element vb] -> CodeGenFunction r vb)
-> [Element vb] -> CodeGenFunction r vb
forall a b. (a -> b) -> a -> b
$ [[Element vb]] -> [Element vb]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
List.concat [[Element vb]]
ds [Element vb] -> [Element vb] -> [Element vb]
forall a. [a] -> [a] -> [a]
++ [Element vb]
d
_zipChunks2With ::
(C ca, C cb, C cc, Size ca ~ Size cb, Size cb ~ Size cc,
C la, C lb, C lc, Size la ~ Size lb, Size lb ~ Size lc,
C va, C vb, C vc, Size va ~ Size vb, Size vb ~ Size vc,
Element ca ~ Element va, Element la ~ Element va,
Element cb ~ Element vb, Element lb ~ Element vb,
Element cc ~ Element vc, Element lc ~ Element vc) =>
(ca -> cb -> CodeGenFunction r cc) ->
(la -> lb -> CodeGenFunction r lc) ->
(va -> vb -> CodeGenFunction r vc)
_zipChunks2With :: forall ca cb cc la lb lc va vb vc r.
(C ca, C cb, C cc, Size ca ~ Size cb, Size cb ~ Size cc, C la,
C lb, C lc, Size la ~ Size lb, Size lb ~ Size lc, C va, C vb, C vc,
Size va ~ Size vb, Size vb ~ Size vc, Element ca ~ Element va,
Element la ~ Element va, Element cb ~ Element vb,
Element lb ~ Element vb, Element cc ~ Element vc,
Element lc ~ Element vc) =>
(ca -> cb -> CodeGenFunction r cc)
-> (la -> lb -> CodeGenFunction r lc)
-> va
-> vb
-> CodeGenFunction r vc
_zipChunks2With ca -> cb -> CodeGenFunction r cc
f la -> lb -> CodeGenFunction r lc
g va
a vb
b =
((ca, cb) -> CodeGenFunction r cc)
-> ((la, lb) -> CodeGenFunction r lc)
-> (va, vb)
-> CodeGenFunction r vc
forall ca cb la lb va vb r.
(C ca, C cb, Size ca ~ Size cb, C la, C lb, Size la ~ Size lb,
C va, C vb, Size va ~ Size vb, Element ca ~ Element va,
Element la ~ Element va, Element cb ~ Element vb,
Element lb ~ Element vb) =>
(ca -> CodeGenFunction r cb)
-> (la -> CodeGenFunction r lb) -> va -> CodeGenFunction r vb
mapChunks2 ((ca -> cb -> CodeGenFunction r cc)
-> (ca, cb) -> CodeGenFunction r cc
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ca -> cb -> CodeGenFunction r cc
f) ((la -> lb -> CodeGenFunction r lc)
-> (la, lb) -> CodeGenFunction r lc
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry la -> lb -> CodeGenFunction r lc
g) (va
a,vb
b)
dotProductPartial ::
(TypeNum.Positive n, LLVM.IsPrimitive a, LLVM.IsArithmetic a) =>
Int ->
Value (Vector n a) ->
Value (Vector n a) ->
CodeGenFunction r (Value a)
dotProductPartial :: forall n a r.
(Positive n, IsPrimitive a, IsArithmetic a) =>
Int
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value a)
dotProductPartial Int
n Value (Vector n a)
x Value (Vector n a)
y =
Int -> Value (Vector n a) -> CodeGenFunction r (Value a)
forall n a r.
(Positive n, IsPrimitive a, IsArithmetic a) =>
Int -> Value (Vector n a) -> CodeGenFunction r (Value a)
sumPartial Int
n (Value (Vector n a) -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value (Vector n a))
-> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.mul Value (Vector n a)
x Value (Vector n a)
y
sumPartial ::
(TypeNum.Positive n, LLVM.IsPrimitive a, LLVM.IsArithmetic a) =>
Int ->
Value (Vector n a) ->
CodeGenFunction r (Value a)
sumPartial :: forall n a r.
(Positive n, IsPrimitive a, IsArithmetic a) =>
Int -> Value (Vector n a) -> CodeGenFunction r (Value a)
sumPartial Int
n Value (Vector n a)
x =
(CodeGenFunction r (Value a)
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value a))
-> [CodeGenFunction r (Value a)] -> CodeGenFunction r (Value a)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1
((Value a -> Value a -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value a)
-> CodeGenFunction r (Value a)
-> CodeGenFunction r (Value a)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
M.liftJoin2 Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add)
((Word32 -> CodeGenFunction r (Value a))
-> [Word32] -> [CodeGenFunction r (Value a)]
forall a b. (a -> b) -> [a] -> [b]
List.map (Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
LLVM.extractelement Value (Vector n a)
x (Value Word32 -> CodeGenFunction r (Value a))
-> (Word32 -> Value Word32)
-> Word32
-> CodeGenFunction r (Value a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf) ([Word32] -> [CodeGenFunction r (Value a)])
-> [Word32] -> [CodeGenFunction r (Value a)]
forall a b. (a -> b) -> a -> b
$ Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take Int
n ([Word32] -> [Word32]) -> [Word32] -> [Word32]
forall a b. (a -> b) -> a -> b
$ [Word32
0..])
chop ::
(C c, C v, Element c ~ Element v) =>
v -> [CodeGenFunction r c]
chop :: forall c v r.
(C c, C v, Element c ~ Element v) =>
v -> [CodeGenFunction r c]
chop = Singleton (Size c) -> v -> [CodeGenFunction r c]
forall c v r.
(C c, C v, Element c ~ Element v) =>
Singleton (Size c) -> v -> [CodeGenFunction r c]
chopCore Singleton (Size c)
forall x. Integer x => Singleton x
TypeNum.singleton
chopCore ::
(C c, C v, Element c ~ Element v) =>
TypeNum.Singleton (Size c) -> v -> [CodeGenFunction r c]
chopCore :: forall c v r.
(C c, C v, Element c ~ Element v) =>
Singleton (Size c) -> v -> [CodeGenFunction r c]
chopCore Singleton (Size c)
m v
x =
([CodeGenFunction r (Element v)] -> CodeGenFunction r c)
-> [[CodeGenFunction r (Element v)]] -> [CodeGenFunction r c]
forall a b. (a -> b) -> [a] -> [b]
List.map ([Element c] -> CodeGenFunction r c
[Element v] -> CodeGenFunction r c
forall v r. C v => [Element v] -> CodeGenFunction r v
assemble ([Element v] -> CodeGenFunction r c)
-> ([CodeGenFunction r (Element v)]
-> CodeGenFunction r [Element v])
-> [CodeGenFunction r (Element v)]
-> CodeGenFunction r c
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< [CodeGenFunction r (Element v)] -> CodeGenFunction r [Element v]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence) ([[CodeGenFunction r (Element v)]] -> [CodeGenFunction r c])
-> [[CodeGenFunction r (Element v)]] -> [CodeGenFunction r c]
forall a b. (a -> b) -> a -> b
$
Int
-> [CodeGenFunction r (Element v)]
-> [[CodeGenFunction r (Element v)]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceVertical (Singleton (Size c) -> Int
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton Singleton (Size c)
m) ([CodeGenFunction r (Element v)]
-> [[CodeGenFunction r (Element v)]])
-> [CodeGenFunction r (Element v)]
-> [[CodeGenFunction r (Element v)]]
forall a b. (a -> b) -> a -> b
$
v -> [CodeGenFunction r (Element v)]
forall v r. Simple v => v -> [CodeGenFunction r (Element v)]
extractList v
x
concat ::
(C c, C v, Element c ~ Element v) =>
[c] -> CodeGenFunction r v
concat :: forall c v r.
(C c, C v, Element c ~ Element v) =>
[c] -> CodeGenFunction r v
concat [c]
xs =
(v -> ([Word32], c) -> CodeGenFunction r v)
-> v -> [([Word32], c)] -> CodeGenFunction r v
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM
(\v
v0 ([Word32]
js,c
c) ->
(v -> (Word32, Word32) -> CodeGenFunction r v)
-> v -> [(Word32, Word32)] -> CodeGenFunction r v
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM
(\v
v (Word32
i,Word32
j) -> do
Element v
x <- Value Word32 -> c -> CodeGenFunction r (Element c)
forall r. Value Word32 -> c -> CodeGenFunction r (Element c)
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
i) c
c
Value Word32 -> Element v -> v -> CodeGenFunction r v
forall r. Value Word32 -> Element v -> v -> CodeGenFunction r v
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
j) Element v
x v
v)
v
v0 ([(Word32, Word32)] -> CodeGenFunction r v)
-> [(Word32, Word32)] -> CodeGenFunction r v
forall a b. (a -> b) -> a -> b
$
[Word32] -> [Word32] -> [(Word32, Word32)]
forall a b. [a] -> [b] -> [(a, b)]
List.zip [Word32
0..] [Word32]
js)
v
forall a. Undefined a => a
Tuple.undef ([([Word32], c)] -> CodeGenFunction r v)
-> [([Word32], c)] -> CodeGenFunction r v
forall a b. (a -> b) -> a -> b
$
[[Word32]] -> [c] -> [([Word32], c)]
forall a b. [a] -> [b] -> [(a, b)]
List.zip
(Int -> [Word32] -> [[Word32]]
forall a. Int -> [a] -> [[a]]
ListHT.sliceVertical (c -> Int
forall v. Simple v => v -> Int
sizeInTuple ([c] -> c
forall a. HasCallStack => [a] -> a
head [c]
xs)) [Word32
0..])
[c]
xs
getLowestPair ::
(TypeNum.Positive n, IsPrimitive a) =>
Value (Vector n a) ->
CodeGenFunction r (Value a, Value a)
getLowestPair :: forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Value a, Value a)
getLowestPair Value (Vector n a)
x =
(Value a -> Value a -> (Value a, Value a))
-> CodeGenFunction r (Value a)
-> CodeGenFunction r (Value a)
-> CodeGenFunction r (Value a, Value a)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,)
(Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
extractelement Value (Vector n a)
x (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
0))
(Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
extractelement Value (Vector n a)
x (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
1))
_reduceAddInterleaved ::
(IsArithmetic a, IsPrimitive a,
TypeNum.Positive n, TypeNum.Positive m, (m :+: m) ~ n) =>
TypeNum.Singleton m ->
Value (Vector n a) ->
CodeGenFunction r (Value (Vector m a))
_reduceAddInterleaved :: forall a n m r.
(IsArithmetic a, IsPrimitive a, Positive n, Positive m,
(m :+: m) ~ n) =>
Singleton m
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector m a))
_reduceAddInterleaved Singleton m
tm Value (Vector n a)
v = do
let m :: Word32
m = Singleton m -> Word32
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton Singleton m
tm
Value (Vector m a)
x <- Value (Vector n a)
-> ConstValue (Vector (Size (Value (Vector m a))) Word32)
-> CodeGenFunction r (Value (Vector m a))
forall v w r.
(C v, C w, Element v ~ Element w) =>
v -> ConstValue (Vector (Size w) Word32) -> CodeGenFunction r w
shuffle Value (Vector n a)
v (T [] Word32
-> ConstValue (Vector (Size (Value (Vector m a))) Word32)
forall a n.
(IsConst a, Positive n) =>
T [] a -> ConstValue (Vector n a)
constCyclicVector (T [] Word32
-> ConstValue (Vector (Size (Value (Vector m a))) Word32))
-> T [] Word32
-> ConstValue (Vector (Size (Value (Vector m a))) Word32)
forall a b. (a -> b) -> a -> b
$ (Word32 -> Word32) -> Word32 -> T [] Word32
forall a. (a -> a) -> a -> T [] a
forall (f :: * -> *) a. Iterate f => (a -> a) -> a -> f a
NonEmptyC.iterate Word32 -> Word32
forall a. Enum a => a -> a
succ Word32
0)
Value (Vector m a)
y <- Value (Vector n a)
-> ConstValue (Vector (Size (Value (Vector m a))) Word32)
-> CodeGenFunction r (Value (Vector m a))
forall v w r.
(C v, C w, Element v ~ Element w) =>
v -> ConstValue (Vector (Size w) Word32) -> CodeGenFunction r w
shuffle Value (Vector n a)
v (T [] Word32
-> ConstValue (Vector (Size (Value (Vector m a))) Word32)
forall a n.
(IsConst a, Positive n) =>
T [] a -> ConstValue (Vector n a)
constCyclicVector (T [] Word32
-> ConstValue (Vector (Size (Value (Vector m a))) Word32))
-> T [] Word32
-> ConstValue (Vector (Size (Value (Vector m a))) Word32)
forall a b. (a -> b) -> a -> b
$ (Word32 -> Word32) -> Word32 -> T [] Word32
forall a. (a -> a) -> a -> T [] a
forall (f :: * -> *) a. Iterate f => (a -> a) -> a -> f a
NonEmptyC.iterate Word32 -> Word32
forall a. Enum a => a -> a
succ Word32
m)
Value (Vector m a)
-> Value (Vector m a) -> CodeGenFunction r (Value (Vector m a))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value (Vector m a)
x Value (Vector m a)
y
sumGeneric ::
(IsArithmetic a, IsPrimitive a, TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value a)
sumGeneric :: forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value a)
sumGeneric =
(Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a))
-> Value Word32
-> Value (Vector n a)
-> CodeGenFunction r (Value a)
forall a b c. (a -> b -> c) -> b -> a -> c
flip Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> Value Word32 -> CodeGenFunction r (Value a)
extractelement (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
0) (Value (Vector n a) -> CodeGenFunction r (Value a))
-> (Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> Value (Vector n a)
-> CodeGenFunction r (Value a)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=<
Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
reduceSumInterleaved Int
1
sumToPairGeneric ::
(Arithmetic a, TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value a, Value a)
sumToPairGeneric :: forall a n r.
(Arithmetic a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value a, Value a)
sumToPairGeneric Value (Vector n a)
v =
let n2 :: Int
n2 = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div (Value (Vector n a) -> Int
forall n a. Positive n => Value (Vector n a) -> Int
size Value (Vector n a)
v) Int
2
in Value (Vector n a) -> CodeGenFunction r (Value a, Value a)
forall a n r.
(Arithmetic a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value a, Value a)
forall n r.
Positive n =>
Value (Vector n a) -> CodeGenFunction r (Value a, Value a)
sumInterleavedToPair (Value (Vector n a) -> CodeGenFunction r (Value a, Value a))
-> CodeGenFunction r (Value (Vector n a))
-> CodeGenFunction r (Value a, Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
shuffleMatchPlain1 Value (Vector n a)
v
(ConstValue (Vector n Word32)
-> (T [] (ConstValue Word32) -> ConstValue (Vector n Word32))
-> Maybe (T [] (ConstValue Word32))
-> ConstValue (Vector n Word32)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ([Char] -> ConstValue (Vector n Word32)
forall a. HasCallStack => [Char] -> a
error [Char]
"vector size must be positive") T [] (ConstValue Word32) -> ConstValue (Vector n Word32)
forall a n.
Positive n =>
T [] (ConstValue a) -> ConstValue (Vector n a)
LLVM.constCyclicVector (Maybe (T [] (ConstValue Word32)) -> ConstValue (Vector n Word32))
-> Maybe (T [] (ConstValue Word32)) -> ConstValue (Vector n Word32)
forall a b. (a -> b) -> a -> b
$
[ConstValue Word32] -> Maybe (T [] (ConstValue Word32))
forall (f :: * -> *) a. ViewL f => f a -> Maybe (T f a)
NonEmpty.fetch ([ConstValue Word32] -> Maybe (T [] (ConstValue Word32)))
-> [ConstValue Word32] -> Maybe (T [] (ConstValue Word32))
forall a b. (a -> b) -> a -> b
$
(Int -> ConstValue Word32) -> [Int] -> [ConstValue Word32]
forall a b. (a -> b) -> [a] -> [b]
List.map (Word32 -> ConstValue Word32
forall a. IsConst a => a -> ConstValue a
constOf (Word32 -> ConstValue Word32)
-> (Int -> Word32) -> Int -> ConstValue Word32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral) ([Int] -> [ConstValue Word32]) -> [Int] -> [ConstValue Word32]
forall a b. (a -> b) -> a -> b
$
(Int -> [Int]) -> [Int] -> [Int]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\Int
k -> [Int
k, Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
n2]) [Int
0..])
reduceSumInterleaved ::
(IsArithmetic a, IsPrimitive a, TypeNum.Positive n) =>
Int ->
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
reduceSumInterleaved :: forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
reduceSumInterleaved Int
m Value (Vector n a)
x0 =
let go ::
(IsArithmetic a, IsPrimitive a, TypeNum.Positive n) =>
Int ->
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
go :: forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
go Int
n Value (Vector n a)
x =
if Int
mInt -> Int -> Bool
forall a. Eq a => a -> a -> Bool
==Int
n
then Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return Value (Vector n a)
x
else
let n2 :: Int
n2 = Int -> Int -> Int
forall a. Integral a => a -> a -> a
div Int
n Int
2
in Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
go Int
n2
(Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n a))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value (Vector n a)
x
(Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n a))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a)
-> ConstValue (Vector n Word32)
-> CodeGenFunction r (Value (Vector n a))
shuffleMatchPlain1 Value (Vector n a)
x
(T [] (ConstValue Word32) -> ConstValue (Vector n Word32)
forall a n.
Positive n =>
T [] (ConstValue a) -> ConstValue (Vector n a)
LLVM.constCyclicVector (T [] (ConstValue Word32) -> ConstValue (Vector n Word32))
-> T [] (ConstValue Word32) -> ConstValue (Vector n Word32)
forall a b. (a -> b) -> a -> b
$
[ConstValue Word32]
-> T [] (ConstValue Word32) -> T [] (ConstValue Word32)
forall (f :: * -> *) a.
(Append f, Traversable f) =>
f a -> T f a -> T f a
NonEmpty.appendLeft
((Word32 -> ConstValue Word32) -> [Word32] -> [ConstValue Word32]
forall a b. (a -> b) -> [a] -> [b]
List.map Word32 -> ConstValue Word32
forall a. IsConst a => a -> ConstValue a
constOf ([Word32] -> [ConstValue Word32])
-> [Word32] -> [ConstValue Word32]
forall a b. (a -> b) -> a -> b
$
Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take Int
n2 [Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n2 ..])
(ConstValue Word32 -> T [] (ConstValue Word32)
forall a. a -> T [] a
forall (f :: * -> *) a. Repeat f => a -> f a
NonEmptyC.repeat ConstValue Word32
forall a. IsType a => ConstValue a
undef))
in Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
go (Value (Vector n a) -> Int
forall n a. Positive n => Value (Vector n a) -> Int
size Value (Vector n a)
x0) Value (Vector n a)
x0
cumulateGeneric, _cumulateSimple ::
(IsArithmetic a, IsPrimitive a, TypeNum.Positive n) =>
Value a -> Value (Vector n a) ->
CodeGenFunction r (Value a, Value (Vector n a))
_cumulateSimple :: forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Value a
-> Value (Vector n a)
-> CodeGenFunction r (Value a, Value (Vector n a))
_cumulateSimple Value a
a Value (Vector n a)
x =
((Value a, Value (Vector n a))
-> Word32 -> CodeGenFunction r (Value a, Value (Vector n a)))
-> (Value a, Value (Vector n a))
-> [Word32]
-> CodeGenFunction r (Value a, Value (Vector n a))
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM
(\(Value a
a0,Value (Vector n a)
y0) Word32
k -> do
Value a
a1 <- Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value a
a0 (Value a -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value Word32
-> Value (Vector n a)
-> CodeGenFunction r (Element (Value (Vector n a)))
forall r.
Value Word32
-> Value (Vector n a)
-> CodeGenFunction r (Element (Value (Vector n a)))
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
k) Value (Vector n a)
x
Value (Vector n a)
y1 <- Value Word32
-> Element (Value (Vector n a))
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n a))
forall r.
Value Word32
-> Element (Value (Vector n a))
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n a))
forall v r.
C v =>
Value Word32 -> Element v -> v -> CodeGenFunction r v
insert (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf Word32
k) Value a
Element (Value (Vector n a))
a0 Value (Vector n a)
y0
(Value a, Value (Vector n a))
-> CodeGenFunction r (Value a, Value (Vector n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (Value a
a1,Value (Vector n a)
y1))
(Value a
a, Value (Vector n a)
forall a. Undefined a => a
Tuple.undef)
(Int -> [Word32] -> [Word32]
forall a. Int -> [a] -> [a]
take (Value (Vector n a) -> Int
forall v. Simple v => v -> Int
sizeInTuple Value (Vector n a)
x) ([Word32] -> [Word32]) -> [Word32] -> [Word32]
forall a b. (a -> b) -> a -> b
$ [Word32
0..])
cumulateGeneric :: forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Value a
-> Value (Vector n a)
-> CodeGenFunction r (Value a, Value (Vector n a))
cumulateGeneric =
(Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> Value a
-> Value (Vector n a)
-> CodeGenFunction r (Value a, Value (Vector n a))
forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
(Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> Value a
-> Value (Vector n a)
-> CodeGenFunction r (Value a, Value (Vector n a))
cumulateFrom1 Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
cumulate1
cumulateFrom1 ::
(IsArithmetic a, IsPrimitive a, TypeNum.Positive n) =>
(Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))) ->
Value a -> Value (Vector n a) ->
CodeGenFunction r (Value a, Value (Vector n a))
cumulateFrom1 :: forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
(Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> Value a
-> Value (Vector n a)
-> CodeGenFunction r (Value a, Value (Vector n a))
cumulateFrom1 Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
cum Value a
a Value (Vector n a)
x0 = do
(Value a
b,Value (Vector n a)
x1) <- Element (Value (Vector n a))
-> Value (Vector n a)
-> CodeGenFunction
r (Element (Value (Vector n a)), Value (Vector n a))
forall v r.
C v =>
Element v -> v -> CodeGenFunction r (Element v, v)
shiftUp Value a
Element (Value (Vector n a))
a Value (Vector n a)
x0
Value (Vector n a)
y <- Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
cum Value (Vector n a)
x1
Value a
z <- Value a -> Value a -> CodeGenFunction r (Value a)
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value a
b (Value a -> CodeGenFunction r (Value a))
-> CodeGenFunction r (Value a) -> CodeGenFunction r (Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value Word32
-> Value (Vector n a)
-> CodeGenFunction r (Element (Value (Vector n a)))
forall r.
Value Word32
-> Value (Vector n a)
-> CodeGenFunction r (Element (Value (Vector n a)))
forall v r.
Simple v =>
Value Word32 -> v -> CodeGenFunction r (Element v)
extract (Word32 -> Value Word32
forall a. IsConst a => a -> Value a
valueOf (Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Value (Vector n a) -> Int
forall v. Simple v => v -> Int
sizeInTuple Value (Vector n a)
x0) Word32 -> Word32 -> Word32
forall a. Num a => a -> a -> a
- Word32
1)) Value (Vector n a)
y
(Value a, Value (Vector n a))
-> CodeGenFunction r (Value a, Value (Vector n a))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (Value a
z,Value (Vector n a)
y)
cumulate1 ::
(IsArithmetic a, IsPrimitive a, TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
cumulate1 :: forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
cumulate1 Value (Vector n a)
x =
(Value (Vector n a)
-> Int -> CodeGenFunction r (Value (Vector n a)))
-> Value (Vector n a)
-> [Int]
-> CodeGenFunction r (Value (Vector n a))
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM
(\Value (Vector n a)
y Int
k -> Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.add Value (Vector n a)
y (Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n a))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall v r.
(C v, Zero (Element v)) =>
Int -> v -> CodeGenFunction r v
shiftUpMultiZero Int
k Value (Vector n a)
y)
Value (Vector n a)
x
((Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<Value (Vector n a) -> Int
forall v. Simple v => v -> Int
sizeInTuple Value (Vector n a)
x) ([Int] -> [Int]) -> [Int] -> [Int]
forall a b. (a -> b) -> a -> b
$ (Int -> Int) -> Int -> [Int]
forall a. (a -> a) -> a -> [a]
List.iterate (Int
2Int -> Int -> Int
forall a. Num a => a -> a -> a
*) Int
1)
signumIntGeneric ::
(TypeNum.Positive n,
IsPrimitive a, LLVM.IsInteger a,
LLVM.CmpRet a, LLVM.CmpResult a ~ b,
IsPrimitive b, LLVM.IsInteger b) =>
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
signumIntGeneric :: forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumIntGeneric Value (Vector n a)
x = do
let zero :: Value (Vector n a)
zero = ConstValue (Vector n a) -> Value (Vector n a)
forall a. ConstValue a -> Value a
LLVM.value ConstValue (Vector n a)
forall a. IsType a => ConstValue a
LLVM.zero
Value (Vector n a)
negative <- Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a))
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsInteger b,
ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.sadapt (Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n Bool))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< CmpPredicate
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n Bool))
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpLT Value (Vector n a)
x Value (Vector n a)
zero
Value (Vector n a)
positive <- Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a))
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsInteger b,
ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.sadapt (Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n Bool))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< CmpPredicate
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n Bool))
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpGT Value (Vector n a)
x Value (Vector n a)
zero
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.sub Value (Vector n a)
negative Value (Vector n a)
positive
signumWordGeneric ::
(TypeNum.Positive n,
IsPrimitive a, LLVM.IsInteger a,
LLVM.CmpRet a, LLVM.CmpResult a ~ b,
IsPrimitive b, LLVM.IsInteger b) =>
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
signumWordGeneric :: forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumWordGeneric Value (Vector n a)
x =
Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a))
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsInteger b,
ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.zadapt (Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n Bool))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< CmpPredicate
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n Bool))
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpGT Value (Vector n a)
x (ConstValue (Vector n a) -> Value (Vector n a)
forall a. ConstValue a -> Value a
LLVM.value ConstValue (Vector n a)
forall a. IsType a => ConstValue a
LLVM.zero)
signumFloatGeneric ::
(TypeNum.Positive n,
IsPrimitive a, IsArithmetic a, IsFloating a,
LLVM.CmpRet a, LLVM.CmpResult a ~ b,
IsPrimitive b, LLVM.IsInteger b) =>
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
signumFloatGeneric :: forall n a b r.
(Positive n, IsPrimitive a, IsArithmetic a, IsFloating a, CmpRet a,
CmpResult a ~ b, IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumFloatGeneric Value (Vector n a)
x = do
let zero :: Value (Vector n a)
zero = ConstValue (Vector n a) -> Value (Vector n a)
forall a. ConstValue a -> Value a
LLVM.value ConstValue (Vector n a)
forall a. IsType a => ConstValue a
LLVM.zero
Value (Vector n a)
negative <- Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a))
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsFloating b,
ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.sitofp (Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n Bool))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< CmpPredicate
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n Bool))
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpLT Value (Vector n a)
x Value (Vector n a)
zero
Value (Vector n a)
positive <- Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a))
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsFloating b,
ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.sitofp (Value (Vector n Bool) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n Bool))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< CmpPredicate
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value (Vector n Bool))
forall a b r.
(CmpRet a, CmpResult a ~ b) =>
CmpPredicate -> Value a -> Value a -> CodeGenFunction r (Value b)
A.cmp CmpPredicate
LLVM.CmpGT Value (Vector n a)
x Value (Vector n a)
zero
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.sub Value (Vector n a)
negative Value (Vector n a)
positive
signedFraction ::
(IsFloating a, IsConst a, Real a, TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
signedFraction :: forall a n r.
(IsFloating a, IsConst a, Real a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signedFraction Value (Vector n a)
x =
Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.sub Value (Vector n a)
x (Value (Vector n a) -> CodeGenFunction r (Value (Vector n a)))
-> CodeGenFunction r (Value (Vector n a))
-> CodeGenFunction r (Value (Vector n a))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(Real a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall n r.
Positive n =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
truncate Value (Vector n a)
x
class (IsArithmetic a, IsPrimitive a) => Arithmetic a where
sum ::
(TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value a)
sum = Value (Vector n a) -> CodeGenFunction r (Value a)
forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value a)
sumGeneric
sumToPair ::
(TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value a, Value a)
sumToPair = Value (Vector n a) -> CodeGenFunction r (Value a, Value a)
forall a n r.
(Arithmetic a, Positive n) =>
Value (Vector n a) -> CodeGenFunction r (Value a, Value a)
sumToPairGeneric
sumInterleavedToPair ::
(TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value a, Value a)
sumInterleavedToPair Value (Vector n a)
v =
Value (Vector n a) -> CodeGenFunction r (Value a, Value a)
forall n a r.
(Positive n, IsPrimitive a) =>
Value (Vector n a) -> CodeGenFunction r (Value a, Value a)
getLowestPair (Value (Vector n a) -> CodeGenFunction r (Value a, Value a))
-> CodeGenFunction r (Value (Vector n a))
-> CodeGenFunction r (Value a, Value a)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Int -> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
reduceSumInterleaved Int
2 Value (Vector n a)
v
cumulate ::
(TypeNum.Positive n) =>
Value a -> Value (Vector n a) ->
CodeGenFunction r (Value a, Value (Vector n a))
cumulate = Value a
-> Value (Vector n a)
-> CodeGenFunction r (Value a, Value (Vector n a))
forall a n r.
(IsArithmetic a, IsPrimitive a, Positive n) =>
Value a
-> Value (Vector n a)
-> CodeGenFunction r (Value a, Value (Vector n a))
cumulateGeneric
dotProduct ::
(TypeNum.Positive n) =>
Value (Vector n a) ->
Value (Vector n a) ->
CodeGenFunction r (Value a)
dotProduct Value (Vector n a)
x Value (Vector n a)
y =
Int
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value a)
forall n a r.
(Positive n, IsPrimitive a, IsArithmetic a) =>
Int
-> Value (Vector n a)
-> Value (Vector n a)
-> CodeGenFunction r (Value a)
dotProductPartial (Value (Vector n a) -> Int
forall n a. Positive n => Value (Vector n a) -> Int
size Value (Vector n a)
x) Value (Vector n a)
x Value (Vector n a)
y
mul ::
(TypeNum.Positive n) =>
Value (Vector n a) ->
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
mul = Value (Vector n a)
-> Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.mul
instance Arithmetic Float where
instance Arithmetic Double where
instance Arithmetic Int where
instance Arithmetic Int8 where
instance Arithmetic Int16 where
instance Arithmetic Int32 where
instance Arithmetic Int64 where
instance Arithmetic Word where
instance Arithmetic Word8 where
instance Arithmetic Word16 where
instance Arithmetic Word32 where
instance Arithmetic Word64 where
class (Arithmetic a, LLVM.CmpRet a, LLVM.IsPrimitive a, IsConst a) =>
Real a where
min, max ::
(TypeNum.Positive n) =>
Value (Vector n a) ->
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
abs ::
(TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
signum ::
(TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
truncate, floor, fraction ::
(TypeNum.Positive n) =>
Value (Vector n a) ->
CodeGenFunction r (Value (Vector n a))
instance Real Float where
min :: forall n r.
Positive n =>
Value (Vector n Float)
-> Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
min = Value (Vector n Float)
-> Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.min
max :: forall n r.
Positive n =>
Value (Vector n Float)
-> Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
max = Value (Vector n Float)
-> Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.max
abs :: forall n r.
Positive n =>
Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
abs = Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
forall a r.
IsArithmetic a =>
Value a -> CodeGenFunction r (Value a)
Intrinsic.abs
signum :: forall n r.
Positive n =>
Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
signum = Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
forall n a b r.
(Positive n, IsPrimitive a, IsArithmetic a, IsFloating a, CmpRet a,
CmpResult a ~ b, IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumFloatGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
truncate = Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
Intrinsic.truncate
floor :: forall n r.
Positive n =>
Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
floor = Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
Intrinsic.floor
fraction :: forall n r.
Positive n =>
Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
fraction = Value (Vector n Float)
-> CodeGenFunction r (Value (Vector n Float))
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
A.fraction
instance Real Double where
min :: forall n r.
Positive n =>
Value (Vector n Double)
-> Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
min = Value (Vector n Double)
-> Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.min
max :: forall n r.
Positive n =>
Value (Vector n Double)
-> Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
max = Value (Vector n Double)
-> Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
forall a r.
IsArithmetic a =>
Value a -> Value a -> CodeGenFunction r (Value a)
Intrinsic.max
abs :: forall n r.
Positive n =>
Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
abs = Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
forall a r.
IsArithmetic a =>
Value a -> CodeGenFunction r (Value a)
Intrinsic.abs
signum :: forall n r.
Positive n =>
Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
signum = Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
forall n a b r.
(Positive n, IsPrimitive a, IsArithmetic a, IsFloating a, CmpRet a,
CmpResult a ~ b, IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumFloatGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
truncate = Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
Intrinsic.truncate
floor :: forall n r.
Positive n =>
Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
floor = Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
Intrinsic.floor
fraction :: forall n r.
Positive n =>
Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
fraction = Value (Vector n Double)
-> CodeGenFunction r (Value (Vector n Double))
forall a r. IsFloating a => Value a -> CodeGenFunction r (Value a)
A.fraction
instance Real Int where
min :: forall n r.
Positive n =>
Value (Vector n Int)
-> Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
min = Value (Vector n Int)
-> Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Int)
-> Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
max = Value (Vector n Int)
-> Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
abs = Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs
signum :: forall n r.
Positive n =>
Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
signum = Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumIntGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
truncate = Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
floor = Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
fraction = CodeGenFunction r (Value (Vector n Int))
-> Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Int))
-> Value (Vector n Int)
-> CodeGenFunction r (Value (Vector n Int)))
-> CodeGenFunction r (Value (Vector n Int))
-> Value (Vector n Int)
-> CodeGenFunction r (Value (Vector n Int))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Int) -> CodeGenFunction r (Value (Vector n Int))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Int) -> Value (Vector n Int)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Int)
forall a. IsType a => ConstValue a
LLVM.zero)
instance Real Int8 where
min :: forall n r.
Positive n =>
Value (Vector n Int8)
-> Value (Vector n Int8)
-> CodeGenFunction r (Value (Vector n Int8))
min = Value (Vector n Int8)
-> Value (Vector n Int8)
-> CodeGenFunction r (Value (Vector n Int8))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Int8)
-> Value (Vector n Int8)
-> CodeGenFunction r (Value (Vector n Int8))
max = Value (Vector n Int8)
-> Value (Vector n Int8)
-> CodeGenFunction r (Value (Vector n Int8))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
abs = Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs
signum :: forall n r.
Positive n =>
Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
signum = Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumIntGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
truncate = Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
floor = Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
fraction = CodeGenFunction r (Value (Vector n Int8))
-> Value (Vector n Int8)
-> CodeGenFunction r (Value (Vector n Int8))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Int8))
-> Value (Vector n Int8)
-> CodeGenFunction r (Value (Vector n Int8)))
-> CodeGenFunction r (Value (Vector n Int8))
-> Value (Vector n Int8)
-> CodeGenFunction r (Value (Vector n Int8))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Int8) -> CodeGenFunction r (Value (Vector n Int8))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Int8) -> Value (Vector n Int8)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Int8)
forall a. IsType a => ConstValue a
LLVM.zero)
instance Real Int16 where
min :: forall n r.
Positive n =>
Value (Vector n Int16)
-> Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
min = Value (Vector n Int16)
-> Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Int16)
-> Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
max = Value (Vector n Int16)
-> Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
abs = Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs
signum :: forall n r.
Positive n =>
Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
signum = Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumIntGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
truncate = Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
floor = Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
fraction = CodeGenFunction r (Value (Vector n Int16))
-> Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Int16))
-> Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16)))
-> CodeGenFunction r (Value (Vector n Int16))
-> Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Int16)
-> CodeGenFunction r (Value (Vector n Int16))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Int16) -> Value (Vector n Int16)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Int16)
forall a. IsType a => ConstValue a
LLVM.zero)
instance Real Int32 where
min :: forall n r.
Positive n =>
Value (Vector n Int32)
-> Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
min = Value (Vector n Int32)
-> Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Int32)
-> Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
max = Value (Vector n Int32)
-> Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
abs = Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs
signum :: forall n r.
Positive n =>
Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
signum = Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumIntGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
truncate = Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
floor = Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
fraction = CodeGenFunction r (Value (Vector n Int32))
-> Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Int32))
-> Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32)))
-> CodeGenFunction r (Value (Vector n Int32))
-> Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Int32)
-> CodeGenFunction r (Value (Vector n Int32))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Int32) -> Value (Vector n Int32)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Int32)
forall a. IsType a => ConstValue a
LLVM.zero)
instance Real Int64 where
min :: forall n r.
Positive n =>
Value (Vector n Int64)
-> Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
min = Value (Vector n Int64)
-> Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Int64)
-> Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
max = Value (Vector n Int64)
-> Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
abs = Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
forall a r.
(IsArithmetic a, CmpRet a) =>
Value a -> CodeGenFunction r (Value a)
A.abs
signum :: forall n r.
Positive n =>
Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
signum = Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumIntGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
truncate = Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
floor = Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
fraction = CodeGenFunction r (Value (Vector n Int64))
-> Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Int64))
-> Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64)))
-> CodeGenFunction r (Value (Vector n Int64))
-> Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Int64)
-> CodeGenFunction r (Value (Vector n Int64))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Int64) -> Value (Vector n Int64)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Int64)
forall a. IsType a => ConstValue a
LLVM.zero)
instance Real Word where
min :: forall n r.
Positive n =>
Value (Vector n Word)
-> Value (Vector n Word)
-> CodeGenFunction r (Value (Vector n Word))
min = Value (Vector n Word)
-> Value (Vector n Word)
-> CodeGenFunction r (Value (Vector n Word))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Word)
-> Value (Vector n Word)
-> CodeGenFunction r (Value (Vector n Word))
max = Value (Vector n Word)
-> Value (Vector n Word)
-> CodeGenFunction r (Value (Vector n Word))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
abs = Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
signum :: forall n r.
Positive n =>
Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
signum = Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumWordGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
truncate = Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
floor = Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
fraction = CodeGenFunction r (Value (Vector n Word))
-> Value (Vector n Word)
-> CodeGenFunction r (Value (Vector n Word))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Word))
-> Value (Vector n Word)
-> CodeGenFunction r (Value (Vector n Word)))
-> CodeGenFunction r (Value (Vector n Word))
-> Value (Vector n Word)
-> CodeGenFunction r (Value (Vector n Word))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Word) -> CodeGenFunction r (Value (Vector n Word))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Word) -> Value (Vector n Word)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Word)
forall a. IsType a => ConstValue a
LLVM.zero)
instance Real Word8 where
min :: forall n r.
Positive n =>
Value (Vector n Word8)
-> Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
min = Value (Vector n Word8)
-> Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Word8)
-> Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
max = Value (Vector n Word8)
-> Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
abs = Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
signum :: forall n r.
Positive n =>
Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
signum = Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumWordGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
truncate = Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
floor = Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
fraction = CodeGenFunction r (Value (Vector n Word8))
-> Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Word8))
-> Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8)))
-> CodeGenFunction r (Value (Vector n Word8))
-> Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Word8)
-> CodeGenFunction r (Value (Vector n Word8))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Word8) -> Value (Vector n Word8)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Word8)
forall a. IsType a => ConstValue a
LLVM.zero)
instance Real Word16 where
min :: forall n r.
Positive n =>
Value (Vector n Word16)
-> Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
min = Value (Vector n Word16)
-> Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Word16)
-> Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
max = Value (Vector n Word16)
-> Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
abs = Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
signum :: forall n r.
Positive n =>
Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
signum = Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumWordGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
truncate = Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
floor = Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
fraction = CodeGenFunction r (Value (Vector n Word16))
-> Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Word16))
-> Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16)))
-> CodeGenFunction r (Value (Vector n Word16))
-> Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Word16)
-> CodeGenFunction r (Value (Vector n Word16))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Word16) -> Value (Vector n Word16)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Word16)
forall a. IsType a => ConstValue a
LLVM.zero)
instance Real Word32 where
min :: forall n r.
Positive n =>
Value (Vector n Word32)
-> Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
min = Value (Vector n Word32)
-> Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Word32)
-> Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
max = Value (Vector n Word32)
-> Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
abs = Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
signum :: forall n r.
Positive n =>
Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
signum = Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumWordGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
truncate = Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
floor = Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
fraction = CodeGenFunction r (Value (Vector n Word32))
-> Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Word32))
-> Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32)))
-> CodeGenFunction r (Value (Vector n Word32))
-> Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Word32)
-> CodeGenFunction r (Value (Vector n Word32))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Word32) -> Value (Vector n Word32)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Word32)
forall a. IsType a => ConstValue a
LLVM.zero)
instance Real Word64 where
min :: forall n r.
Positive n =>
Value (Vector n Word64)
-> Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
min = Value (Vector n Word64)
-> Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.min
max :: forall n r.
Positive n =>
Value (Vector n Word64)
-> Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
max = Value (Vector n Word64)
-> Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
forall a r.
CmpRet a =>
Value a -> Value a -> CodeGenFunction r (Value a)
A.max
abs :: forall n r.
Positive n =>
Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
abs = Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
signum :: forall n r.
Positive n =>
Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
signum = Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
forall n a b r.
(Positive n, IsPrimitive a, IsInteger a, CmpRet a, CmpResult a ~ b,
IsPrimitive b, IsInteger b) =>
Value (Vector n a) -> CodeGenFunction r (Value (Vector n a))
signumWordGeneric
truncate :: forall n r.
Positive n =>
Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
truncate = Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
floor :: forall n r.
Positive n =>
Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
floor = Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return
fraction :: forall n r.
Positive n =>
Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
fraction = CodeGenFunction r (Value (Vector n Word64))
-> Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
forall a b. a -> b -> a
const (CodeGenFunction r (Value (Vector n Word64))
-> Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64)))
-> CodeGenFunction r (Value (Vector n Word64))
-> Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
forall a b. (a -> b) -> a -> b
$ Value (Vector n Word64)
-> CodeGenFunction r (Value (Vector n Word64))
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (ConstValue (Vector n Word64) -> Value (Vector n Word64)
forall a. ConstValue a -> Value a
value ConstValue (Vector n Word64)
forall a. IsType a => ConstValue a
LLVM.zero)