{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE MultiParamTypeClasses #-}
module LLVM.Extra.Multi.Value.Vector (
   cons,
   fst, snd,
   fst3, snd3, thd3,
   zip, zip3,
   unzip, unzip3,

   swap,
   mapFst, mapSnd,
   mapFst3, mapSnd3, mapThd3,

   extract, insert,
   replicate,
   iterate,
   dissect,
   dissect1,
   select,
   cmp,
   take, takeRev,

   NativeInteger,
   NativeFloating,
   fromIntegral,
   truncateToInt,
   splitFractionToInt,
   ) where

import qualified LLVM.Extra.Multi.Vector.Instance as Inst
import qualified LLVM.Extra.Multi.Vector as MultiVector
import qualified LLVM.Extra.Multi.Value.Private as MultiValue
import qualified LLVM.Extra.ScalarOrVector as SoV
import LLVM.Extra.Multi.Vector.Instance (MVVector)

import qualified LLVM.Core as LLVM

import qualified Type.Data.Num.Decimal as TypeNum


import qualified Data.NonEmpty as NonEmpty
import qualified Data.Tuple.HT as TupleHT
import qualified Data.Tuple as Tuple
import Data.Word (Word8, Word16, Word32, Word64, Word)
import Data.Int (Int8, Int16, Int32, Int64, Int)

import Prelude (Float, Double, Bool, fmap, (.))


cons ::
   (TypeNum.Positive n, MultiVector.C a) =>
   LLVM.Vector n a -> MVVector n a
cons :: forall n a. (Positive n, C a) => Vector n a -> MVVector n a
cons = T n a -> MVVector n a
forall n a. T n a -> MVVector n a
Inst.toMultiValue (T n a -> MVVector n a)
-> (Vector n a -> T n a) -> Vector n a -> MVVector n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector n a -> T n a
forall n. Positive n => Vector n a -> T n a
forall a n. (C a, Positive n) => Vector n a -> T n a
MultiVector.cons

fst :: MVVector n (a,b) -> MVVector n a
fst :: forall n a b. MVVector n (a, b) -> MVVector n a
fst = (Repr (Vector n (a, b)) -> Repr (Vector n a))
-> T (Vector n (a, b)) -> T (Vector n a)
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 (Repr n a, Repr n b) -> Repr n a
Repr (Vector n (a, b)) -> Repr (Vector n a)
forall a b. (a, b) -> a
Tuple.fst

snd :: MVVector n (a,b) -> MVVector n b
snd :: forall n a b. MVVector n (a, b) -> MVVector n b
snd = (Repr (Vector n (a, b)) -> Repr (Vector n b))
-> T (Vector n (a, b)) -> T (Vector n b)
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 (Repr n a, Repr n b) -> Repr n b
Repr (Vector n (a, b)) -> Repr (Vector n b)
forall a b. (a, b) -> b
Tuple.snd

swap :: MVVector n (a,b) -> MVVector n (b,a)
swap :: forall n a b. MVVector n (a, b) -> MVVector n (b, a)
swap = (Repr (Vector n (a, b)) -> Repr (Vector n (b, a)))
-> T (Vector n (a, b)) -> T (Vector n (b, a))
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 (Repr n a, Repr n b) -> (Repr n b, Repr n a)
Repr (Vector n (a, b)) -> Repr (Vector n (b, a))
forall a b. (a, b) -> (b, a)
TupleHT.swap

mapFst ::
   (MVVector n a0 -> MVVector n a1) ->
   MVVector n (a0,b) -> MVVector n (a1,b)
mapFst :: forall n a0 a1 b.
(MVVector n a0 -> MVVector n a1)
-> MVVector n (a0, b) -> MVVector n (a1, b)
mapFst MVVector n a0 -> MVVector n a1
f = (MVVector n a1 -> MVVector n b -> MVVector n (a1, b))
-> (MVVector n a1, MVVector n b) -> MVVector n (a1, b)
forall a b c. (a -> b -> c) -> (a, b) -> c
Tuple.uncurry MVVector n a1 -> MVVector n b -> MVVector n (a1, b)
forall n a b. MVVector n a -> MVVector n b -> MVVector n (a, b)
zip ((MVVector n a1, MVVector n b) -> MVVector n (a1, b))
-> (MVVector n (a0, b) -> (MVVector n a1, MVVector n b))
-> MVVector n (a0, b)
-> MVVector n (a1, b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MVVector n a0 -> MVVector n a1)
-> (MVVector n a0, MVVector n b) -> (MVVector n a1, MVVector n b)
forall a c b. (a -> c) -> (a, b) -> (c, b)
TupleHT.mapFst MVVector n a0 -> MVVector n a1
f ((MVVector n a0, MVVector n b) -> (MVVector n a1, MVVector n b))
-> (MVVector n (a0, b) -> (MVVector n a0, MVVector n b))
-> MVVector n (a0, b)
-> (MVVector n a1, MVVector n b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MVVector n (a0, b) -> (MVVector n a0, MVVector n b)
forall n a b. MVVector n (a, b) -> (MVVector n a, MVVector n b)
unzip

mapSnd ::
   (MVVector n b0 -> MVVector n b1) ->
   MVVector n (a,b0) -> MVVector n (a,b1)
mapSnd :: forall n b0 b1 a.
(MVVector n b0 -> MVVector n b1)
-> MVVector n (a, b0) -> MVVector n (a, b1)
mapSnd MVVector n b0 -> MVVector n b1
f = (MVVector n a -> MVVector n b1 -> MVVector n (a, b1))
-> (MVVector n a, MVVector n b1) -> MVVector n (a, b1)
forall a b c. (a -> b -> c) -> (a, b) -> c
Tuple.uncurry MVVector n a -> MVVector n b1 -> MVVector n (a, b1)
forall n a b. MVVector n a -> MVVector n b -> MVVector n (a, b)
zip ((MVVector n a, MVVector n b1) -> MVVector n (a, b1))
-> (MVVector n (a, b0) -> (MVVector n a, MVVector n b1))
-> MVVector n (a, b0)
-> MVVector n (a, b1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MVVector n b0 -> MVVector n b1)
-> (MVVector n a, MVVector n b0) -> (MVVector n a, MVVector n b1)
forall b c a. (b -> c) -> (a, b) -> (a, c)
TupleHT.mapSnd MVVector n b0 -> MVVector n b1
f ((MVVector n a, MVVector n b0) -> (MVVector n a, MVVector n b1))
-> (MVVector n (a, b0) -> (MVVector n a, MVVector n b0))
-> MVVector n (a, b0)
-> (MVVector n a, MVVector n b1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MVVector n (a, b0) -> (MVVector n a, MVVector n b0)
forall n a b. MVVector n (a, b) -> (MVVector n a, MVVector n b)
unzip


fst3 :: MVVector n (a,b,c) -> MVVector n a
fst3 :: forall n a b c. MVVector n (a, b, c) -> MVVector n a
fst3 = (Repr (Vector n (a, b, c)) -> Repr (Vector n a))
-> T (Vector n (a, b, c)) -> T (Vector n a)
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 (Repr n a, Repr n b, Repr n c) -> Repr n a
Repr (Vector n (a, b, c)) -> Repr (Vector n a)
forall a b c. (a, b, c) -> a
TupleHT.fst3

snd3 :: MVVector n (a,b,c) -> MVVector n b
snd3 :: forall n a b c. MVVector n (a, b, c) -> MVVector n b
snd3 = (Repr (Vector n (a, b, c)) -> Repr (Vector n b))
-> T (Vector n (a, b, c)) -> T (Vector n b)
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 (Repr n a, Repr n b, Repr n c) -> Repr n b
Repr (Vector n (a, b, c)) -> Repr (Vector n b)
forall a b c. (a, b, c) -> b
TupleHT.snd3

thd3 :: MVVector n (a,b,c) -> MVVector n c
thd3 :: forall n a b c. MVVector n (a, b, c) -> MVVector n c
thd3 = (Repr (Vector n (a, b, c)) -> Repr (Vector n c))
-> T (Vector n (a, b, c)) -> T (Vector n c)
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 (Repr n a, Repr n b, Repr n c) -> Repr n c
Repr (Vector n (a, b, c)) -> Repr (Vector n c)
forall a b c. (a, b, c) -> c
TupleHT.thd3

mapFst3 ::
   (MVVector n a0 -> MVVector n a1) ->
   MVVector n (a0,b,c) -> MVVector n (a1,b,c)
mapFst3 :: forall n a0 a1 b c.
(MVVector n a0 -> MVVector n a1)
-> MVVector n (a0, b, c) -> MVVector n (a1, b, c)
mapFst3 MVVector n a0 -> MVVector n a1
f = (MVVector n a1
 -> MVVector n b -> MVVector n c -> MVVector n (a1, b, c))
-> (MVVector n a1, MVVector n b, MVVector n c)
-> MVVector n (a1, b, c)
forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d
TupleHT.uncurry3 MVVector n a1
-> MVVector n b -> MVVector n c -> MVVector n (a1, b, c)
forall n a b c.
MVVector n a
-> MVVector n b -> MVVector n c -> MVVector n (a, b, c)
zip3 ((MVVector n a1, MVVector n b, MVVector n c)
 -> MVVector n (a1, b, c))
-> (MVVector n (a0, b, c)
    -> (MVVector n a1, MVVector n b, MVVector n c))
-> MVVector n (a0, b, c)
-> MVVector n (a1, b, c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MVVector n a0 -> MVVector n a1)
-> (MVVector n a0, MVVector n b, MVVector n c)
-> (MVVector n a1, MVVector n b, MVVector n c)
forall a d b c. (a -> d) -> (a, b, c) -> (d, b, c)
TupleHT.mapFst3 MVVector n a0 -> MVVector n a1
f ((MVVector n a0, MVVector n b, MVVector n c)
 -> (MVVector n a1, MVVector n b, MVVector n c))
-> (MVVector n (a0, b, c)
    -> (MVVector n a0, MVVector n b, MVVector n c))
-> MVVector n (a0, b, c)
-> (MVVector n a1, MVVector n b, MVVector n c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MVVector n (a0, b, c)
-> (MVVector n a0, MVVector n b, MVVector n c)
forall n a b c.
MVVector n (a, b, c) -> (MVVector n a, MVVector n b, MVVector n c)
unzip3

mapSnd3 ::
   (MVVector n b0 -> MVVector n b1) ->
   MVVector n (a,b0,c) -> MVVector n (a,b1,c)
mapSnd3 :: forall n b0 b1 a c.
(MVVector n b0 -> MVVector n b1)
-> MVVector n (a, b0, c) -> MVVector n (a, b1, c)
mapSnd3 MVVector n b0 -> MVVector n b1
f = (MVVector n a
 -> MVVector n b1 -> MVVector n c -> MVVector n (a, b1, c))
-> (MVVector n a, MVVector n b1, MVVector n c)
-> MVVector n (a, b1, c)
forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d
TupleHT.uncurry3 MVVector n a
-> MVVector n b1 -> MVVector n c -> MVVector n (a, b1, c)
forall n a b c.
MVVector n a
-> MVVector n b -> MVVector n c -> MVVector n (a, b, c)
zip3 ((MVVector n a, MVVector n b1, MVVector n c)
 -> MVVector n (a, b1, c))
-> (MVVector n (a, b0, c)
    -> (MVVector n a, MVVector n b1, MVVector n c))
-> MVVector n (a, b0, c)
-> MVVector n (a, b1, c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MVVector n b0 -> MVVector n b1)
-> (MVVector n a, MVVector n b0, MVVector n c)
-> (MVVector n a, MVVector n b1, MVVector n c)
forall b d a c. (b -> d) -> (a, b, c) -> (a, d, c)
TupleHT.mapSnd3 MVVector n b0 -> MVVector n b1
f ((MVVector n a, MVVector n b0, MVVector n c)
 -> (MVVector n a, MVVector n b1, MVVector n c))
-> (MVVector n (a, b0, c)
    -> (MVVector n a, MVVector n b0, MVVector n c))
-> MVVector n (a, b0, c)
-> (MVVector n a, MVVector n b1, MVVector n c)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MVVector n (a, b0, c)
-> (MVVector n a, MVVector n b0, MVVector n c)
forall n a b c.
MVVector n (a, b, c) -> (MVVector n a, MVVector n b, MVVector n c)
unzip3

mapThd3 ::
   (MVVector n c0 -> MVVector n c1) ->
   MVVector n (a,b,c0) -> MVVector n (a,b,c1)
mapThd3 :: forall n c0 c1 a b.
(MVVector n c0 -> MVVector n c1)
-> MVVector n (a, b, c0) -> MVVector n (a, b, c1)
mapThd3 MVVector n c0 -> MVVector n c1
f = (MVVector n a
 -> MVVector n b -> MVVector n c1 -> MVVector n (a, b, c1))
-> (MVVector n a, MVVector n b, MVVector n c1)
-> MVVector n (a, b, c1)
forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d
TupleHT.uncurry3 MVVector n a
-> MVVector n b -> MVVector n c1 -> MVVector n (a, b, c1)
forall n a b c.
MVVector n a
-> MVVector n b -> MVVector n c -> MVVector n (a, b, c)
zip3 ((MVVector n a, MVVector n b, MVVector n c1)
 -> MVVector n (a, b, c1))
-> (MVVector n (a, b, c0)
    -> (MVVector n a, MVVector n b, MVVector n c1))
-> MVVector n (a, b, c0)
-> MVVector n (a, b, c1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MVVector n c0 -> MVVector n c1)
-> (MVVector n a, MVVector n b, MVVector n c0)
-> (MVVector n a, MVVector n b, MVVector n c1)
forall c d a b. (c -> d) -> (a, b, c) -> (a, b, d)
TupleHT.mapThd3 MVVector n c0 -> MVVector n c1
f ((MVVector n a, MVVector n b, MVVector n c0)
 -> (MVVector n a, MVVector n b, MVVector n c1))
-> (MVVector n (a, b, c0)
    -> (MVVector n a, MVVector n b, MVVector n c0))
-> MVVector n (a, b, c0)
-> (MVVector n a, MVVector n b, MVVector n c1)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MVVector n (a, b, c0)
-> (MVVector n a, MVVector n b, MVVector n c0)
forall n a b c.
MVVector n (a, b, c) -> (MVVector n a, MVVector n b, MVVector n c)
unzip3


zip :: MVVector n a -> MVVector n b -> MVVector n (a,b)
zip :: forall n a b. MVVector n a -> MVVector n b -> MVVector n (a, b)
zip (MultiValue.Cons Repr (Vector n a)
a) (MultiValue.Cons Repr (Vector n b)
b) = Repr (Vector n (a, b)) -> T (Vector n (a, b))
forall a. Repr a -> T a
MultiValue.Cons (Repr (Vector n a)
Repr n a
a,Repr (Vector n b)
Repr n b
b)

zip3 :: MVVector n a -> MVVector n b -> MVVector n c -> MVVector n (a,b,c)
zip3 :: forall n a b c.
MVVector n a
-> MVVector n b -> MVVector n c -> MVVector n (a, b, c)
zip3 (MultiValue.Cons Repr (Vector n a)
a) (MultiValue.Cons Repr (Vector n b)
b) (MultiValue.Cons Repr (Vector n c)
c) =
   Repr (Vector n (a, b, c)) -> T (Vector n (a, b, c))
forall a. Repr a -> T a
MultiValue.Cons (Repr (Vector n a)
Repr n a
a,Repr (Vector n b)
Repr n b
b,Repr (Vector n c)
Repr n c
c)

unzip :: MVVector n (a,b) -> (MVVector n a, MVVector n b)
unzip :: forall n a b. MVVector n (a, b) -> (MVVector n a, MVVector n b)
unzip (MultiValue.Cons (Repr n a
a,Repr n b
b)) = (Repr (Vector n a) -> T (Vector n a)
forall a. Repr a -> T a
MultiValue.Cons Repr (Vector n a)
Repr n a
a, Repr (Vector n b) -> T (Vector n b)
forall a. Repr a -> T a
MultiValue.Cons Repr (Vector n b)
Repr n b
b)

unzip3 :: MVVector n (a,b,c) -> (MVVector n a, MVVector n b, MVVector n c)
unzip3 :: forall n a b c.
MVVector n (a, b, c) -> (MVVector n a, MVVector n b, MVVector n c)
unzip3 (MultiValue.Cons (Repr n a
a,Repr n b
b,Repr n c
c)) =
   (Repr (Vector n a) -> T (Vector n a)
forall a. Repr a -> T a
MultiValue.Cons Repr (Vector n a)
Repr n a
a, Repr (Vector n b) -> T (Vector n b)
forall a. Repr a -> T a
MultiValue.Cons Repr (Vector n b)
Repr n b
b, Repr (Vector n c) -> T (Vector n c)
forall a. Repr a -> T a
MultiValue.Cons Repr (Vector n c)
Repr n c
c)


extract ::
   (TypeNum.Positive n, MultiVector.C a) =>
   LLVM.Value Word32 -> MVVector n a ->
   LLVM.CodeGenFunction r (MultiValue.T a)
extract :: forall n a r.
(Positive n, C a) =>
Value Word32 -> MVVector n a -> CodeGenFunction r (T a)
extract Value Word32
k MVVector n a
v = Value Word32 -> T n a -> CodeGenFunction r (T a)
forall a n r.
(C a, Positive n) =>
Value Word32 -> T n a -> CodeGenFunction r (T a)
forall n r.
Positive n =>
Value Word32 -> T n a -> CodeGenFunction r (T a)
MultiVector.extract Value Word32
k (MVVector n a -> T n a
forall n a. MVVector n a -> T n a
Inst.fromMultiValue MVVector n a
v)

insert ::
   (TypeNum.Positive n, MultiVector.C a) =>
   LLVM.Value Word32 -> MultiValue.T a ->
   MVVector n a -> LLVM.CodeGenFunction r (MVVector n a)
insert :: forall n a r.
(Positive n, C a) =>
Value Word32
-> T a -> MVVector n a -> CodeGenFunction r (MVVector n a)
insert Value Word32
k T a
a = (T n a -> CodeGenFunction r (T n a))
-> MVVector n a -> CodeGenFunction r (MVVector n a)
forall (f :: * -> *) n a m b.
Functor f =>
(T n a -> f (T m b)) -> MVVector n a -> f (MVVector m b)
Inst.liftMultiValueM (Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
forall a n r.
(C a, Positive n) =>
Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
forall n r.
Positive n =>
Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
MultiVector.insert Value Word32
k T a
a)


replicate ::
   (TypeNum.Positive n, MultiVector.C a) =>
   MultiValue.T a -> LLVM.CodeGenFunction r (MVVector n a)
replicate :: forall n a r.
(Positive n, C a) =>
T a -> CodeGenFunction r (MVVector n a)
replicate = (T n a -> MVVector n a)
-> CodeGenFunction r (T n a) -> CodeGenFunction r (MVVector n a)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T n a -> MVVector n a
forall n a. T n a -> MVVector n a
Inst.toMultiValue (CodeGenFunction r (T n a) -> CodeGenFunction r (MVVector n a))
-> (T a -> CodeGenFunction r (T n a))
-> T a
-> CodeGenFunction r (MVVector n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T a -> CodeGenFunction r (T n a)
forall n a r. (Positive n, C a) => T a -> CodeGenFunction r (T n a)
MultiVector.replicate

iterate ::
   (TypeNum.Positive n, MultiVector.C a) =>
   (MultiValue.T a -> LLVM.CodeGenFunction r (MultiValue.T a)) ->
   MultiValue.T a -> LLVM.CodeGenFunction r (MVVector n a)
iterate :: forall n a r.
(Positive n, C a) =>
(T a -> CodeGenFunction r (T a))
-> T a -> CodeGenFunction r (MVVector n a)
iterate T a -> CodeGenFunction r (T a)
f = (T n a -> MVVector n a)
-> CodeGenFunction r (T n a) -> CodeGenFunction r (MVVector n a)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T n a -> MVVector n a
forall n a. T n a -> MVVector n a
Inst.toMultiValue (CodeGenFunction r (T n a) -> CodeGenFunction r (MVVector n a))
-> (T a -> CodeGenFunction r (T n a))
-> T a
-> CodeGenFunction r (MVVector n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T a -> CodeGenFunction r (T a))
-> T a -> CodeGenFunction r (T n a)
forall n a r.
(Positive n, C a) =>
(T a -> CodeGenFunction r (T a))
-> T a -> CodeGenFunction r (T n a)
MultiVector.iterate T a -> CodeGenFunction r (T a)
f

take ::
   (TypeNum.Positive n, TypeNum.Positive m, MultiVector.C a) =>
   MVVector n a -> LLVM.CodeGenFunction r (MVVector m a)
take :: forall n m a r.
(Positive n, Positive m, C a) =>
MVVector n a -> CodeGenFunction r (MVVector m a)
take = (T n a -> CodeGenFunction r (T m a))
-> MVVector n a -> CodeGenFunction r (MVVector m a)
forall (f :: * -> *) n a m b.
Functor f =>
(T n a -> f (T m b)) -> MVVector n a -> f (MVVector m b)
Inst.liftMultiValueM T n a -> CodeGenFunction r (T m a)
forall n m a r.
(Positive n, Positive m, C a) =>
T n a -> CodeGenFunction r (T m a)
MultiVector.take

takeRev ::
   (TypeNum.Positive n, TypeNum.Positive m, MultiVector.C a) =>
   MVVector n a -> LLVM.CodeGenFunction r (MVVector m a)
takeRev :: forall n m a r.
(Positive n, Positive m, C a) =>
MVVector n a -> CodeGenFunction r (MVVector m a)
takeRev = (T n a -> CodeGenFunction r (T m a))
-> MVVector n a -> CodeGenFunction r (MVVector m a)
forall (f :: * -> *) n a m b.
Functor f =>
(T n a -> f (T m b)) -> MVVector n a -> f (MVVector m b)
Inst.liftMultiValueM T n a -> CodeGenFunction r (T m a)
forall n m a r.
(Positive n, Positive m, C a) =>
T n a -> CodeGenFunction r (T m a)
MultiVector.takeRev


dissect ::
   (TypeNum.Positive n, MultiVector.C a) =>
   MVVector n a -> LLVM.CodeGenFunction r [MultiValue.T a]
dissect :: forall n a r.
(Positive n, C a) =>
MVVector n a -> CodeGenFunction r [T a]
dissect = T n a -> CodeGenFunction r [T a]
forall n a r. (Positive n, C a) => T n a -> CodeGenFunction r [T a]
MultiVector.dissect (T n a -> CodeGenFunction r [T a])
-> (MVVector n a -> T n a)
-> MVVector n a
-> CodeGenFunction r [T a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MVVector n a -> T n a
forall n a. MVVector n a -> T n a
Inst.fromMultiValue

dissect1 ::
   (TypeNum.Positive n, MultiVector.C a) =>
   MVVector n a -> LLVM.CodeGenFunction r (NonEmpty.T [] (MultiValue.T a))
dissect1 :: forall n a r.
(Positive n, C a) =>
MVVector n a -> CodeGenFunction r (T [] (T a))
dissect1 = T n a -> CodeGenFunction r (T [] (T a))
forall n a r.
(Positive n, C a) =>
T n a -> CodeGenFunction r (T [] (T a))
MultiVector.dissect1 (T n a -> CodeGenFunction r (T [] (T a)))
-> (MVVector n a -> T n a)
-> MVVector n a
-> CodeGenFunction r (T [] (T a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MVVector n a -> T n a
forall n a. MVVector n a -> T n a
Inst.fromMultiValue

select ::
   (TypeNum.Positive n, MultiVector.Select a) =>
   MVVector n Bool ->
   MVVector n a -> MVVector n a ->
   LLVM.CodeGenFunction r (MVVector n a)
select :: forall n a r.
(Positive n, Select a) =>
MVVector n Bool
-> MVVector n a -> MVVector n a -> CodeGenFunction r (MVVector n a)
select = (T n Bool -> T n a -> T n a -> CodeGenFunction r (T n a))
-> MVVector n Bool
-> MVVector n a
-> MVVector n a
-> CodeGenFunction r (MVVector n a)
forall (f :: * -> *) n a m b c k d.
Functor f =>
(T n a -> T m b -> T m c -> f (T k d))
-> MVVector n a -> MVVector m b -> MVVector m c -> f (MVVector k d)
Inst.liftMultiValueM3 T n Bool -> T n a -> T n a -> CodeGenFunction r (T n a)
forall a n r.
(Select a, Positive n) =>
T n Bool -> T n a -> T n a -> CodeGenFunction r (T n a)
forall n r.
Positive n =>
T n Bool -> T n a -> T n a -> CodeGenFunction r (T n a)
MultiVector.select

cmp ::
   (TypeNum.Positive n, MultiVector.Comparison a) =>
   LLVM.CmpPredicate ->
   MVVector n a -> MVVector n a ->
   LLVM.CodeGenFunction r (MVVector n Bool)
cmp :: forall n a r.
(Positive n, Comparison a) =>
CmpPredicate
-> MVVector n a
-> MVVector n a
-> CodeGenFunction r (MVVector n Bool)
cmp = (T n a -> T n a -> CodeGenFunction r (T n Bool))
-> MVVector n a
-> MVVector n a
-> CodeGenFunction r (MVVector n Bool)
forall (f :: * -> *) n a m b k c.
Functor f =>
(T n a -> T m b -> f (T k c))
-> MVVector n a -> MVVector m b -> f (MVVector k c)
Inst.liftMultiValueM2 ((T n a -> T n a -> CodeGenFunction r (T n Bool))
 -> MVVector n a
 -> MVVector n a
 -> CodeGenFunction r (MVVector n Bool))
-> (CmpPredicate -> T n a -> T n a -> CodeGenFunction r (T n Bool))
-> CmpPredicate
-> MVVector n a
-> MVVector n a
-> CodeGenFunction r (MVVector n Bool)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CmpPredicate -> T n a -> T n a -> CodeGenFunction r (T n Bool)
forall a n r.
(Comparison a, Positive n) =>
CmpPredicate -> T n a -> T n a -> CodeGenFunction r (T n Bool)
forall n r.
Positive n =>
CmpPredicate -> T n a -> T n a -> CodeGenFunction r (T n Bool)
MultiVector.cmp


{-
ToDo: make this a super-class of MultiValue.NativeInteger
problem: we need MultiValue.Repr, which provokes an import cycle
maybe we should break the cycle using a ConstraintKind,
i.e. define class NativeIntegerVec in MultiValue,
and define NativeInteger = MultiValue.NativeIntegerVec here
and export only MultiValueVec.NativeInteger constraint synonym.
-}
class
   (MultiValue.Repr i ~ LLVM.Value ir,
    LLVM.CmpRet ir, LLVM.IsInteger ir, SoV.IntegerConstant ir) =>
      NativeInteger i ir where

instance NativeInteger Word   Word   where
instance NativeInteger Word8  Word8  where
instance NativeInteger Word16 Word16 where
instance NativeInteger Word32 Word32 where
instance NativeInteger Word64 Word64 where

instance NativeInteger Int   Int   where
instance NativeInteger Int8  Int8  where
instance NativeInteger Int16 Int16 where
instance NativeInteger Int32 Int32 where
instance NativeInteger Int64 Int64 where

instance
   (TypeNum.Positive n, n ~ m,
    MultiVector.NativeInteger n i ir,
    MultiValue.NativeInteger i ir) =>
      NativeInteger (LLVM.Vector n i) (LLVM.Vector m ir) where


class
   (MultiValue.Repr a ~ LLVM.Value ar,
    LLVM.CmpRet ar,  SoV.RationalConstant ar, LLVM.IsFloating ar) =>
      NativeFloating a ar where

instance NativeFloating Float  Float  where
instance NativeFloating Double Double where

instance
   (TypeNum.Positive n, n ~ m,
    MultiVector.NativeFloating n a ar,
    MultiValue.NativeFloating a ar) =>
      NativeFloating (LLVM.Vector n a) (LLVM.Vector m ar) where

fromIntegral ::
   (NativeInteger i ir, NativeFloating a ar,
    LLVM.ShapeOf ir ~ LLVM.ShapeOf ar) =>
   MultiValue.T i -> LLVM.CodeGenFunction r (MultiValue.T a)
fromIntegral :: forall i ir a ar r.
(NativeInteger i ir, NativeFloating a ar,
 ShapeOf ir ~ ShapeOf ar) =>
T i -> CodeGenFunction r (T a)
fromIntegral = (Repr i -> CodeGenFunction r (Repr a))
-> T i -> CodeGenFunction r (T a)
forall (m :: * -> *) a b.
Monad m =>
(Repr a -> m (Repr b)) -> T a -> m (T b)
MultiValue.liftM Value ir -> CodeGenFunction r (Value ar)
Repr i -> CodeGenFunction r (Repr a)
forall (value :: * -> *) a b r.
(ValueCons value, IsInteger a, IsFloating b,
 ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.inttofp


truncateToInt ::
   (NativeInteger i ir, NativeFloating a ar,
    LLVM.ShapeOf ir ~ LLVM.ShapeOf ar) =>
   MultiValue.T a -> LLVM.CodeGenFunction r (MultiValue.T i)
truncateToInt :: forall i ir a ar r.
(NativeInteger i ir, NativeFloating a ar,
 ShapeOf ir ~ ShapeOf ar) =>
T a -> CodeGenFunction r (T i)
truncateToInt = (Repr a -> CodeGenFunction r (Repr i))
-> T a -> CodeGenFunction r (T i)
forall (m :: * -> *) a b.
Monad m =>
(Repr a -> m (Repr b)) -> T a -> m (T b)
MultiValue.liftM Value ar -> CodeGenFunction r (Value ir)
Repr a -> CodeGenFunction r (Repr i)
forall (value :: * -> *) a b r.
(ValueCons value, IsFloating a, IsInteger b,
 ShapeOf a ~ ShapeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.fptoint

splitFractionToInt ::
   (NativeInteger i ir, NativeFloating a ar,
    LLVM.ShapeOf ir ~ LLVM.ShapeOf ar) =>
   MultiValue.T a -> LLVM.CodeGenFunction r (MultiValue.T (i,a))
splitFractionToInt :: forall i ir a ar r.
(NativeInteger i ir, NativeFloating a ar,
 ShapeOf ir ~ ShapeOf ar) =>
T a -> CodeGenFunction r (T (i, a))
splitFractionToInt = (Repr a -> CodeGenFunction r (Repr (i, a)))
-> T a -> CodeGenFunction r (T (i, a))
forall (m :: * -> *) a b.
Monad m =>
(Repr a -> m (Repr b)) -> T a -> m (T b)
MultiValue.liftM Value ar -> CodeGenFunction r (Value ir, Value ar)
Repr a -> CodeGenFunction r (Repr (i, a))
forall a i r.
(IsFloating a, CmpRet a, IsInteger i, IntegerConstant i, CmpRet i,
 CmpResult a ~ CmpResult i, ShapeOf a ~ ShapeOf i) =>
Value a -> CodeGenFunction r (Value i, Value a)
SoV.splitFractionToInt