{-# OPTIONS_GHC -fno-warn-unticked-promoted-constructors #-}
module Data.Repa.Scalar.Product
(
(:*:) (..)
, IsProdList (..)
, IsKeyValues (..)
, Select (..)
, Discard (..)
, Mask (..)
, Keep (..)
, Drop (..))
where
import Data.Repa.Scalar.Singleton.Nat
import qualified Data.Vector.Unboxed as U
import qualified Data.Vector.Generic as G
import qualified Data.Vector.Generic.Mutable as M
data a :*: b
= !a :*: !b
deriving ((a :*: b) -> (a :*: b) -> Bool
((a :*: b) -> (a :*: b) -> Bool)
-> ((a :*: b) -> (a :*: b) -> Bool) -> Eq (a :*: b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b. (Eq a, Eq b) => (a :*: b) -> (a :*: b) -> Bool
$c== :: forall a b. (Eq a, Eq b) => (a :*: b) -> (a :*: b) -> Bool
== :: (a :*: b) -> (a :*: b) -> Bool
$c/= :: forall a b. (Eq a, Eq b) => (a :*: b) -> (a :*: b) -> Bool
/= :: (a :*: b) -> (a :*: b) -> Bool
Eq, Int -> (a :*: b) -> ShowS
[a :*: b] -> ShowS
(a :*: b) -> String
(Int -> (a :*: b) -> ShowS)
-> ((a :*: b) -> String) -> ([a :*: b] -> ShowS) -> Show (a :*: b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. (Show a, Show b) => Int -> (a :*: b) -> ShowS
forall a b. (Show a, Show b) => [a :*: b] -> ShowS
forall a b. (Show a, Show b) => (a :*: b) -> String
$cshowsPrec :: forall a b. (Show a, Show b) => Int -> (a :*: b) -> ShowS
showsPrec :: Int -> (a :*: b) -> ShowS
$cshow :: forall a b. (Show a, Show b) => (a :*: b) -> String
show :: (a :*: b) -> String
$cshowList :: forall a b. (Show a, Show b) => [a :*: b] -> ShowS
showList :: [a :*: b] -> ShowS
Show)
infixr :*:
instance Functor ((:*:) a) where
fmap :: forall a b. (a -> b) -> (a :*: a) -> a :*: b
fmap a -> b
f ((:*:) a
x a
y) = a -> b -> a :*: b
forall a b. a -> b -> a :*: b
(:*:) a
x (a -> b
f a
y)
class IsProdList p where
isProdList :: p -> Bool
instance IsProdList () where
isProdList :: () -> Bool
isProdList ()
_ = Bool
True
{-# INLINE isProdList #-}
instance IsProdList fs => IsProdList (f :*: fs) where
isProdList :: (f :*: fs) -> Bool
isProdList (f
_ :*: fs
xs) = fs -> Bool
forall p. IsProdList p => p -> Bool
isProdList fs
xs
{-# INLINE isProdList #-}
class IsKeyValues p where
type Keys p
type Values p
keys :: p -> [Keys p]
values :: p -> Values p
instance IsKeyValues (k, v) where
type Keys (k, v) = k
type Values (k, v) = v
keys :: (k, v) -> [Keys (k, v)]
keys (k
k, v
_) = [k
Keys (k, v)
k]
{-# INLINE keys #-}
values :: (k, v) -> Values (k, v)
values (k
_, v
v) = v
Values (k, v)
v
{-# INLINE values #-}
instance (IsKeyValues p, IsKeyValues ps, Keys p ~ Keys ps)
=> IsKeyValues (p :*: ps) where
type Keys (p :*: ps) = Keys p
type Values (p :*: ps) = Values p :*: Values ps
keys :: (p :*: ps) -> [Keys (p :*: ps)]
keys (p
p :*: ps
ps) = p -> [Keys p]
forall p. IsKeyValues p => p -> [Keys p]
keys p
p [Keys ps] -> [Keys ps] -> [Keys ps]
forall a. [a] -> [a] -> [a]
++ ps -> [Keys ps]
forall p. IsKeyValues p => p -> [Keys p]
keys ps
ps
{-# INLINE keys #-}
values :: (p :*: ps) -> Values (p :*: ps)
values (p
p :*: ps
ps) = p -> Values p
forall p. IsKeyValues p => p -> Values p
values p
p Values p -> Values ps -> Values p :*: Values ps
forall a b. a -> b -> a :*: b
:*: ps -> Values ps
forall p. IsKeyValues p => p -> Values p
values ps
ps
{-# INLINE values #-}
class IsProdList t
=> Select (n :: N) t where
type Select' n t
select :: Nat n -> t -> Select' n t
instance IsProdList ts
=> Select Z (t1 :*: ts) where
type Select' Z (t1 :*: ts) = t1
select :: Nat 'Z -> (t1 :*: ts) -> Select' 'Z (t1 :*: ts)
select Nat 'Z
Zero (t1
t1 :*: ts
_) = t1
Select' 'Z (t1 :*: ts)
t1
{-# INLINE select #-}
instance Select n ts
=> Select (S n) (t1 :*: ts) where
type Select' (S n) (t1 :*: ts) = Select' n ts
select :: Nat ('S n) -> (t1 :*: ts) -> Select' ('S n) (t1 :*: ts)
select (Succ Nat n1
n) (t1
_ :*: ts
xs) = Nat n1 -> ts -> Select' n1 ts
forall (n :: N) t. Select n t => Nat n -> t -> Select' n t
select Nat n1
n ts
xs
{-# INLINE select #-}
class IsProdList t
=> Discard (n :: N) t where
type Discard' n t
discard :: Nat n -> t -> Discard' n t
instance IsProdList ts
=> Discard Z (t1 :*: ts) where
type Discard' Z (t1 :*: ts) = ts
discard :: Nat 'Z -> (t1 :*: ts) -> Discard' 'Z (t1 :*: ts)
discard Nat 'Z
Zero (t1
_ :*: ts
xs) = ts
Discard' 'Z (t1 :*: ts)
xs
{-# INLINE discard #-}
instance Discard n ts
=> Discard (S n) (t1 :*: ts) where
type Discard' (S n) (t1 :*: ts) = t1 :*: Discard' n ts
discard :: Nat ('S n) -> (t1 :*: ts) -> Discard' ('S n) (t1 :*: ts)
discard (Succ Nat n1
n) (t1
x1 :*: ts
xs) = t1
x1 t1 -> Discard' n ts -> t1 :*: Discard' n ts
forall a b. a -> b -> a :*: b
:*: Nat n1 -> ts -> Discard' n1 ts
forall (n :: N) t. Discard n t => Nat n -> t -> Discard' n t
discard Nat n1
n ts
xs
{-# INLINE discard #-}
data Drop = Drop
data Keep = Keep
class (IsProdList m, IsProdList t) => Mask m t where
type Mask' m t
mask :: m -> t -> Mask' m t
instance Mask () () where
type Mask' () () = ()
mask :: () -> () -> Mask' () ()
mask () () = ()
{-# INLINE mask #-}
instance Mask ms ts
=> Mask (Keep :*: ms) (t1 :*: ts) where
type Mask' (Keep :*: ms) (t1 :*: ts) = t1 :*: Mask' ms ts
mask :: (Keep :*: ms) -> (t1 :*: ts) -> Mask' (Keep :*: ms) (t1 :*: ts)
mask (Keep
_ :*: ms
ms) (t1
x1 :*: ts
xs) = t1
x1 t1 -> Mask' ms ts -> t1 :*: Mask' ms ts
forall a b. a -> b -> a :*: b
:*: ms -> ts -> Mask' ms ts
forall m t. Mask m t => m -> t -> Mask' m t
mask ms
ms ts
xs
{-# INLINE mask #-}
instance Mask ms ts
=> Mask (Drop :*: ms) (t1 :*: ts) where
type Mask' (Drop :*: ms) (t1 :*: ts) = Mask' ms ts
mask :: (Drop :*: ms) -> (t1 :*: ts) -> Mask' (Drop :*: ms) (t1 :*: ts)
mask (Drop
_ :*: ms
ms) (t1
_ :*: ts
xs) = ms -> ts -> Mask' ms ts
forall m t. Mask m t => m -> t -> Mask' m t
mask ms
ms ts
xs
{-# INLINE mask #-}
data instance U.Vector (a :*: b)
= V_Prod
{-# UNPACK #-} !Int
!(U.Vector a)
!(U.Vector b)
instance (U.Unbox a, U.Unbox b)
=> U.Unbox (a :*: b)
data instance U.MVector s (a :*: b)
= MV_Prod {-# UNPACK #-} !Int
!(U.MVector s a)
!(U.MVector s b)
instance (U.Unbox a, U.Unbox b)
=> M.MVector U.MVector (a :*: b) where
basicLength :: forall s. MVector s (a :*: b) -> Int
basicLength (MV_Prod Int
n_ MVector s a
_as MVector s b
_bs) = Int
n_
{-# INLINE basicLength #-}
basicUnsafeSlice :: forall s. Int -> Int -> MVector s (a :*: b) -> MVector s (a :*: b)
basicUnsafeSlice Int
i_ Int
m_ (MV_Prod Int
_n_ MVector s a
as MVector s b
bs)
= Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod Int
m_ (Int -> Int -> MVector s a -> MVector s a
forall s. Int -> Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice Int
i_ Int
m_ MVector s a
as)
(Int -> Int -> MVector s b -> MVector s b
forall s. Int -> Int -> MVector s b -> MVector s b
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice Int
i_ Int
m_ MVector s b
bs)
{-# INLINE basicUnsafeSlice #-}
basicOverlaps :: forall s. MVector s (a :*: b) -> MVector s (a :*: b) -> Bool
basicOverlaps (MV_Prod Int
_n_1 MVector s a
as1 MVector s b
bs1) (MV_Prod Int
_n_2 MVector s a
as2 MVector s b
bs2)
= MVector s a -> MVector s a -> Bool
forall s. MVector s a -> MVector s a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s a
as1 MVector s a
as2
Bool -> Bool -> Bool
|| MVector s b -> MVector s b -> Bool
forall s. MVector s b -> MVector s b -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s b
bs1 MVector s b
bs2
{-# INLINE basicOverlaps #-}
basicUnsafeNew :: forall s. Int -> ST s (MVector s (a :*: b))
basicUnsafeNew Int
n_
= do MVector s a
as <- Int -> ST s (MVector s a)
forall s. Int -> ST s (MVector s a)
forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a)
M.basicUnsafeNew Int
n_
MVector s b
bs <- Int -> ST s (MVector s b)
forall s. Int -> ST s (MVector s b)
forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a)
M.basicUnsafeNew Int
n_
MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s (a :*: b) -> ST s (MVector s (a :*: b)))
-> MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod Int
n_ MVector s a
as MVector s b
bs
{-# INLINE basicUnsafeNew #-}
basicInitialize :: forall s. MVector s (a :*: b) -> ST s ()
basicInitialize (MV_Prod Int
_ MVector s a
_as MVector s b
_bs)
= do MVector s a -> ST s ()
forall s. MVector s a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicInitialize MVector s a
_as
MVector s b -> ST s ()
forall s. MVector s b -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicInitialize MVector s b
_bs
{-# INLINE basicInitialize #-}
basicUnsafeReplicate :: forall s. Int -> (a :*: b) -> ST s (MVector s (a :*: b))
basicUnsafeReplicate Int
n_ (a
a :*: b
b)
= do MVector s a
as <- Int -> a -> ST s (MVector s a)
forall s. Int -> a -> ST s (MVector s a)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> a -> ST s (v s a)
M.basicUnsafeReplicate Int
n_ a
a
MVector s b
bs <- Int -> b -> ST s (MVector s b)
forall s. Int -> b -> ST s (MVector s b)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> a -> ST s (v s a)
M.basicUnsafeReplicate Int
n_ b
b
MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s (a :*: b) -> ST s (MVector s (a :*: b)))
-> MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod Int
n_ MVector s a
as MVector s b
bs
{-# INLINE basicUnsafeReplicate #-}
basicUnsafeRead :: forall s. MVector s (a :*: b) -> Int -> ST s (a :*: b)
basicUnsafeRead (MV_Prod Int
_n_ MVector s a
as MVector s b
bs) Int
i_
= do a
a <- MVector s a -> Int -> ST s a
forall s. MVector s a -> Int -> ST s a
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
M.basicUnsafeRead MVector s a
as Int
i_
b
b <- MVector s b -> Int -> ST s b
forall s. MVector s b -> Int -> ST s b
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
M.basicUnsafeRead MVector s b
bs Int
i_
(a :*: b) -> ST s (a :*: b)
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a a -> b -> a :*: b
forall a b. a -> b -> a :*: b
:*: b
b)
{-# INLINE basicUnsafeRead #-}
basicUnsafeWrite :: forall s. MVector s (a :*: b) -> Int -> (a :*: b) -> ST s ()
basicUnsafeWrite (MV_Prod Int
_n_ MVector s a
as MVector s b
bs) Int
i_ (a
a :*: b
b)
= do MVector s a -> Int -> a -> ST s ()
forall s. MVector s a -> Int -> a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
M.basicUnsafeWrite MVector s a
as Int
i_ a
a
MVector s b -> Int -> b -> ST s ()
forall s. MVector s b -> Int -> b -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
M.basicUnsafeWrite MVector s b
bs Int
i_ b
b
{-# INLINE basicUnsafeWrite #-}
basicClear :: forall s. MVector s (a :*: b) -> ST s ()
basicClear (MV_Prod Int
_n_ MVector s a
as MVector s b
bs)
= do MVector s a -> ST s ()
forall s. MVector s a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicClear MVector s a
as
MVector s b -> ST s ()
forall s. MVector s b -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicClear MVector s b
bs
{-# INLINE basicClear #-}
basicSet :: forall s. MVector s (a :*: b) -> (a :*: b) -> ST s ()
basicSet (MV_Prod Int
_n_ MVector s a
as MVector s b
bs) (a
a :*: b
b)
= do MVector s a -> a -> ST s ()
forall s. MVector s a -> a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s ()
M.basicSet MVector s a
as a
a
MVector s b -> b -> ST s ()
forall s. MVector s b -> b -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s ()
M.basicSet MVector s b
bs b
b
{-# INLINE basicSet #-}
basicUnsafeCopy :: forall s. MVector s (a :*: b) -> MVector s (a :*: b) -> ST s ()
basicUnsafeCopy (MV_Prod Int
_n_1 MVector s a
as1 MVector s b
bs1) (MV_Prod Int
_n_2 MVector s a
as2 MVector s b
bs2)
= do MVector s a -> MVector s a -> ST s ()
forall s. MVector s a -> MVector s a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
M.basicUnsafeCopy MVector s a
as1 MVector s a
as2
MVector s b -> MVector s b -> ST s ()
forall s. MVector s b -> MVector s b -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
M.basicUnsafeCopy MVector s b
bs1 MVector s b
bs2
{-# INLINE basicUnsafeCopy #-}
basicUnsafeMove :: forall s. MVector s (a :*: b) -> MVector s (a :*: b) -> ST s ()
basicUnsafeMove (MV_Prod Int
_n_1 MVector s a
as1 MVector s b
bs1) (MV_Prod Int
_n_2 MVector s a
as2 MVector s b
bs2)
= do MVector s a -> MVector s a -> ST s ()
forall s. MVector s a -> MVector s a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
M.basicUnsafeMove MVector s a
as1 MVector s a
as2
MVector s b -> MVector s b -> ST s ()
forall s. MVector s b -> MVector s b -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
M.basicUnsafeMove MVector s b
bs1 MVector s b
bs2
{-# INLINE basicUnsafeMove #-}
basicUnsafeGrow :: forall s. MVector s (a :*: b) -> Int -> ST s (MVector s (a :*: b))
basicUnsafeGrow (MV_Prod Int
n_ MVector s a
as MVector s b
bs) Int
m_
= do MVector s a
as' <- MVector s a -> Int -> ST s (MVector s a)
forall s. MVector s a -> Int -> ST s (MVector s a)
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s (v s a)
M.basicUnsafeGrow MVector s a
as Int
m_
MVector s b
bs' <- MVector s b -> Int -> ST s (MVector s b)
forall s. MVector s b -> Int -> ST s (MVector s b)
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s (v s a)
M.basicUnsafeGrow MVector s b
bs Int
m_
MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s (a :*: b) -> ST s (MVector s (a :*: b)))
-> MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod (Int
m_ Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n_) MVector s a
as' MVector s b
bs'
{-# INLINE basicUnsafeGrow #-}
instance (U.Unbox a, U.Unbox b)
=> G.Vector U.Vector (a :*: b) where
basicUnsafeFreeze :: forall s. Mutable Vector s (a :*: b) -> ST s (Vector (a :*: b))
basicUnsafeFreeze (MV_Prod Int
n_ MVector s a
as MVector s b
bs)
= do Vector a
as' <- Mutable Vector s a -> ST s (Vector a)
forall s. Mutable Vector s a -> ST s (Vector a)
forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
G.basicUnsafeFreeze Mutable Vector s a
MVector s a
as
Vector b
bs' <- Mutable Vector s b -> ST s (Vector b)
forall s. Mutable Vector s b -> ST s (Vector b)
forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
G.basicUnsafeFreeze Mutable Vector s b
MVector s b
bs
Vector (a :*: b) -> ST s (Vector (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector (a :*: b) -> ST s (Vector (a :*: b)))
-> Vector (a :*: b) -> ST s (Vector (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> Vector a -> Vector b -> Vector (a :*: b)
forall a b. Int -> Vector a -> Vector b -> Vector (a :*: b)
V_Prod Int
n_ Vector a
as' Vector b
bs'
{-# INLINE basicUnsafeFreeze #-}
basicUnsafeThaw :: forall s. Vector (a :*: b) -> ST s (Mutable Vector s (a :*: b))
basicUnsafeThaw (V_Prod Int
n_ Vector a
as Vector b
bs)
= do MVector s a
as' <- Vector a -> ST s (Mutable Vector s a)
forall s. Vector a -> ST s (Mutable Vector s a)
forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
G.basicUnsafeThaw Vector a
as
MVector s b
bs' <- Vector b -> ST s (Mutable Vector s b)
forall s. Vector b -> ST s (Mutable Vector s b)
forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
G.basicUnsafeThaw Vector b
bs
MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s (a :*: b) -> ST s (MVector s (a :*: b)))
-> MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod Int
n_ MVector s a
as' MVector s b
bs'
{-# INLINE basicUnsafeThaw #-}
basicLength :: Vector (a :*: b) -> Int
basicLength (V_Prod Int
n_ Vector a
_as Vector b
_bs)
= Int
n_
{-# INLINE basicLength #-}
basicUnsafeSlice :: Int -> Int -> Vector (a :*: b) -> Vector (a :*: b)
basicUnsafeSlice Int
i_ Int
m_ (V_Prod Int
_n_ Vector a
as Vector b
bs)
= Int -> Vector a -> Vector b -> Vector (a :*: b)
forall a b. Int -> Vector a -> Vector b -> Vector (a :*: b)
V_Prod Int
m_ (Int -> Int -> Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i_ Int
m_ Vector a
as)
(Int -> Int -> Vector b -> Vector b
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i_ Int
m_ Vector b
bs)
{-# INLINE basicUnsafeSlice #-}
basicUnsafeIndexM :: Vector (a :*: b) -> Int -> Box (a :*: b)
basicUnsafeIndexM (V_Prod Int
_n_ Vector a
as Vector b
bs) Int
i_
= do a
a <- Vector a -> Int -> Box a
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
G.basicUnsafeIndexM Vector a
as Int
i_
b
b <- Vector b -> Int -> Box b
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
G.basicUnsafeIndexM Vector b
bs Int
i_
(a :*: b) -> Box (a :*: b)
forall a. a -> Box a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a a -> b -> a :*: b
forall a b. a -> b -> a :*: b
:*: b
b)
{-# INLINE basicUnsafeIndexM #-}
basicUnsafeCopy :: forall s. Mutable Vector s (a :*: b) -> Vector (a :*: b) -> ST s ()
basicUnsafeCopy (MV_Prod Int
_n_1 MVector s a
as1 MVector s b
bs1) (V_Prod Int
_n_2 Vector a
as2 Vector b
bs2)
= do Mutable Vector s a -> Vector a -> ST s ()
forall s. Mutable Vector s a -> Vector a -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
G.basicUnsafeCopy Mutable Vector s a
MVector s a
as1 Vector a
as2
Mutable Vector s b -> Vector b -> ST s ()
forall s. Mutable Vector s b -> Vector b -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
G.basicUnsafeCopy Mutable Vector s b
MVector s b
bs1 Vector b
bs2
{-# INLINE basicUnsafeCopy #-}
elemseq :: forall b. Vector (a :*: b) -> (a :*: b) -> b -> b
elemseq Vector (a :*: b)
_ (a
a :*: b
b)
= Vector a -> a -> b -> b
forall b. Vector a -> a -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (Vector a
forall a. HasCallStack => a
undefined :: U.Vector a) a
a
(b -> b) -> (b -> b) -> b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector b -> b -> b -> b
forall b. Vector b -> b -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (Vector b
forall a. HasCallStack => a
undefined :: U.Vector b) b
b
{-# INLINE elemseq #-}