{-# 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, )


-- * target independent functions

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

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

   extract :: 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

{- |
Manually assemble a vector of equal values.
Better use ScalarOrVector.replicate.
-}
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)

{- |
construct a vector out of single elements

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

This can be considered the inverse of 'extractAll'.
-}
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..]
{- sends GHC into an infinite loop
   foldM (\(k,x) -> insert (valueOf k) x) Tuple.undef .
   List.zip [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..])

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

{- |
Rotate one element towards the higher elements.

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

{- |
Implement the 'shuffleMatch' method using the methods of the 'C' class.
-}
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))
extractTraversable :: forall v (f :: * -> *) r.
(Simple v, Traversable f) =>
Value Word32 -> f v -> CodeGenFunction r (f (Element v))
extractTraversable 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

{- |
provide the elements of a vector as a list of individual virtual registers

This can be considered the inverse of 'assemble'.
-}
extractAll ::
   (Simple v) =>
   v -> LLVM.CodeGenFunction r [Element v]
extractAll :: forall v r. Simple v => v -> CodeGenFunction r [Element v]
extractAll = [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)]
extractList :: forall v r. Simple v => v -> [CodeGenFunction r (Element v)]
extractList 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

{- |
Like LLVM.Util.Loop.mapVector but the loop is unrolled,
which is faster since it can be packed by the code generator.
-}
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)



{- |
Ideally on ix86 with SSE41 this would be translated to 'dpps'.
-}
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
      {- quite the same as (+) using LLVM.Arithmetic instances,
         but requires less type constraints -}
      ((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..])


{- |
If the target vector type is a native type
then the chop operation produces no actual machine instruction. (nop)
If the vector cannot be evenly divided into chunks
the last chunk will be padded with undefined values.
-}
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

{- |
The target size is determined by the type.
If the chunk list provides more data, the exceeding data is dropped.
If the chunk list provides too few data,
the target vector is filled with undefined elements.
-}
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..])

{- |
We partition a vector of size n into chunks of size m
and add these chunks using vector additions.
We do this by repeated halving of the vector,
since this way we do not need assumptions about the native vector size.

We reduce the vector size only virtually,
that is we maintain the vector size and fill with undefined values.
This is reasonable
since LLVM-2.5 and LLVM-2.6 does not allow shuffling between vectors of different size
and because it likes to do computations on Vector D2 Float
in MMX registers on ix86 CPU's,
which interacts badly with FPU usage.
Since we fill the vector with undefined values,
LLVM actually treats the vectors like vectors of smaller size.
-}
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)


{- |
Needs (log n) vector additions
-}
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)


{-
{- |
This one does not use vectorized select.
Cf. the outcommented signumInt.
-}
signumInt ::
   (TypeNum.Positive n,
    IsPrimitive a, IsArithmetic a, IsConst a, Num a,
    LLVM.CmpRet a, LLVM.CmpResult a ~ b,
    IsPrimitive b, LLVM.IsInteger b) =>
   Value (Vector n a) ->
   CodeGenFunction r (Value (Vector n a))
signumInt x = do
   let zero = LLVM.value LLVM.zero
   negative <- A.cmp LLVM.CmpLT x zero
   positive <- A.cmp LLVM.CmpGT x zero
   map
      (\(n,p) ->
         LLVM.select n (valueOf (-1))
            =<< LLVM.select p (valueOf 1) (LLVM.value LLVM.zero))
      (negative, positive)

signumWord ::
   (TypeNum.Positive n,
    IsPrimitive a, IsArithmetic a, IsConst a, Num a,
    LLVM.CmpRet a, LLVM.CmpResult a ~ b,
    IsPrimitive b, LLVM.IsInteger b) =>
   Value (Vector n a) ->
   CodeGenFunction r (Value (Vector n a))
signumWord x = do
   positive <- A.cmp LLVM.CmpGT x (LLVM.value LLVM.zero)
   map
      (\p -> LLVM.select p (valueOf 1) (LLVM.value LLVM.zero))
      positive
-}

signumIntGeneric ::
   (TypeNum.Positive n,
    {- TypeNum.Positive (n :*: LLVM.SizeOf a), -}
    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


-- * target independent functions with target dependent optimizations

{- |
The order of addition is chosen for maximum efficiency.
We do not try to prevent cancelations.
-}
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

   {- |
   The first result value is the sum of all vector elements from 0 to @div n 2 + 1@
   and the second result value is the sum of vector elements from @div n 2@ to @n-1@.
   n must be at least D2.
   -}
   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

   {- |
   Treat the vector as concatenation of pairs and all these pairs are added.
   Useful for stereo signal processing.
   n must be at least D2.
   -}
   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)