{-# LANGUAGE TypeFamilies #-}

module Data.Mat2x2 where

import Data.Primitive
import qualified Data.Vector.Generic as G
import qualified Data.Vector.Generic.Mutable as GM
import qualified Data.Vector.Unboxed as U
import qualified Data.Vector.Unboxed.Mutable as UM

data Mat2x2 a = Mat2x2 !a !a !a !a
  deriving (Mat2x2 a -> Mat2x2 a -> Bool
(Mat2x2 a -> Mat2x2 a -> Bool)
-> (Mat2x2 a -> Mat2x2 a -> Bool) -> Eq (Mat2x2 a)
forall a. Eq a => Mat2x2 a -> Mat2x2 a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Mat2x2 a -> Mat2x2 a -> Bool
== :: Mat2x2 a -> Mat2x2 a -> Bool
$c/= :: forall a. Eq a => Mat2x2 a -> Mat2x2 a -> Bool
/= :: Mat2x2 a -> Mat2x2 a -> Bool
Eq, Eq (Mat2x2 a)
Eq (Mat2x2 a) =>
(Mat2x2 a -> Mat2x2 a -> Ordering)
-> (Mat2x2 a -> Mat2x2 a -> Bool)
-> (Mat2x2 a -> Mat2x2 a -> Bool)
-> (Mat2x2 a -> Mat2x2 a -> Bool)
-> (Mat2x2 a -> Mat2x2 a -> Bool)
-> (Mat2x2 a -> Mat2x2 a -> Mat2x2 a)
-> (Mat2x2 a -> Mat2x2 a -> Mat2x2 a)
-> Ord (Mat2x2 a)
Mat2x2 a -> Mat2x2 a -> Bool
Mat2x2 a -> Mat2x2 a -> Ordering
Mat2x2 a -> Mat2x2 a -> Mat2x2 a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Mat2x2 a)
forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Bool
forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Ordering
forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Mat2x2 a
$ccompare :: forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Ordering
compare :: Mat2x2 a -> Mat2x2 a -> Ordering
$c< :: forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Bool
< :: Mat2x2 a -> Mat2x2 a -> Bool
$c<= :: forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Bool
<= :: Mat2x2 a -> Mat2x2 a -> Bool
$c> :: forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Bool
> :: Mat2x2 a -> Mat2x2 a -> Bool
$c>= :: forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Bool
>= :: Mat2x2 a -> Mat2x2 a -> Bool
$cmax :: forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Mat2x2 a
max :: Mat2x2 a -> Mat2x2 a -> Mat2x2 a
$cmin :: forall a. Ord a => Mat2x2 a -> Mat2x2 a -> Mat2x2 a
min :: Mat2x2 a -> Mat2x2 a -> Mat2x2 a
Ord, Int -> Mat2x2 a -> ShowS
[Mat2x2 a] -> ShowS
Mat2x2 a -> String
(Int -> Mat2x2 a -> ShowS)
-> (Mat2x2 a -> String) -> ([Mat2x2 a] -> ShowS) -> Show (Mat2x2 a)
forall a. Show a => Int -> Mat2x2 a -> ShowS
forall a. Show a => [Mat2x2 a] -> ShowS
forall a. Show a => Mat2x2 a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Mat2x2 a -> ShowS
showsPrec :: Int -> Mat2x2 a -> ShowS
$cshow :: forall a. Show a => Mat2x2 a -> String
show :: Mat2x2 a -> String
$cshowList :: forall a. Show a => [Mat2x2 a] -> ShowS
showList :: [Mat2x2 a] -> ShowS
Show)

appMat2x2 :: (Num a) => Mat2x2 a -> a -> a -> (a, a)
appMat2x2 :: forall a. Num a => Mat2x2 a -> a -> a -> (a, a)
appMat2x2 (Mat2x2 a
a a
b a
c a
d) a
x a
y = (a
x', a
y')
  where
    !x' :: a
x' = a
a a -> a -> a
forall a. Num a => a -> a -> a
* a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
b a -> a -> a
forall a. Num a => a -> a -> a
* a
y
    !y' :: a
y' = a
c a -> a -> a
forall a. Num a => a -> a -> a
* a
x a -> a -> a
forall a. Num a => a -> a -> a
+ a
d a -> a -> a
forall a. Num a => a -> a -> a
* a
y

instance (Num a) => Num (Mat2x2 a) where
  (Mat2x2 a
a0 a
b0 a
c0 a
d0) + :: Mat2x2 a -> Mat2x2 a -> Mat2x2 a
+ (Mat2x2 a
a1 a
b1 a
c1 a
d1) =
    a -> a -> a -> a -> Mat2x2 a
forall a. a -> a -> a -> a -> Mat2x2 a
Mat2x2 (a
a0 a -> a -> a
forall a. Num a => a -> a -> a
+ a
a1) (a
b0 a -> a -> a
forall a. Num a => a -> a -> a
+ a
b1) (a
c0 a -> a -> a
forall a. Num a => a -> a -> a
+ a
c1) (a
d0 a -> a -> a
forall a. Num a => a -> a -> a
+ a
d1)
  (Mat2x2 a
a0 a
b0 a
c0 a
d0) - :: Mat2x2 a -> Mat2x2 a -> Mat2x2 a
- (Mat2x2 a
a1 a
b1 a
c1 a
d1) =
    a -> a -> a -> a -> Mat2x2 a
forall a. a -> a -> a -> a -> Mat2x2 a
Mat2x2 (a
a0 a -> a -> a
forall a. Num a => a -> a -> a
- a
a1) (a
b0 a -> a -> a
forall a. Num a => a -> a -> a
- a
b1) (a
c0 a -> a -> a
forall a. Num a => a -> a -> a
- a
c1) (a
d0 a -> a -> a
forall a. Num a => a -> a -> a
- a
d1)
  (Mat2x2 a
a0 a
b0 a
c0 a
d0) * :: Mat2x2 a -> Mat2x2 a -> Mat2x2 a
* (Mat2x2 a
a1 a
b1 a
c1 a
d1) =
    a -> a -> a -> a -> Mat2x2 a
forall a. a -> a -> a -> a -> Mat2x2 a
Mat2x2
      ((a
a0 a -> a -> a
forall a. Num a => a -> a -> a
* a
a1) a -> a -> a
forall a. Num a => a -> a -> a
+ (a
b0 a -> a -> a
forall a. Num a => a -> a -> a
* a
c1))
      ((a
a0 a -> a -> a
forall a. Num a => a -> a -> a
* a
b1) a -> a -> a
forall a. Num a => a -> a -> a
+ (a
b0 a -> a -> a
forall a. Num a => a -> a -> a
* a
d1))
      ((a
c0 a -> a -> a
forall a. Num a => a -> a -> a
* a
a1) a -> a -> a
forall a. Num a => a -> a -> a
+ (a
d0 a -> a -> a
forall a. Num a => a -> a -> a
* a
c1))
      ((a
c0 a -> a -> a
forall a. Num a => a -> a -> a
* a
b1) a -> a -> a
forall a. Num a => a -> a -> a
+ (a
d0 a -> a -> a
forall a. Num a => a -> a -> a
* a
d1))
  negate :: Mat2x2 a -> Mat2x2 a
negate (Mat2x2 a
a a
b a
c a
d) = a -> a -> a -> a -> Mat2x2 a
forall a. a -> a -> a -> a -> Mat2x2 a
Mat2x2 (a -> a
forall a. Num a => a -> a
negate a
a) (a -> a
forall a. Num a => a -> a
negate a
b) (a -> a
forall a. Num a => a -> a
negate a
c) (a -> a
forall a. Num a => a -> a
negate a
d)
  abs :: Mat2x2 a -> Mat2x2 a
abs = Mat2x2 a -> Mat2x2 a
forall a. a -> a
id
  signum :: Mat2x2 a -> Mat2x2 a
signum = Mat2x2 a -> Mat2x2 a -> Mat2x2 a
forall a b. a -> b -> a
const Mat2x2 a
1
  fromInteger :: Integer -> Mat2x2 a
fromInteger Integer
x = a -> a -> a -> a -> Mat2x2 a
forall a. a -> a -> a -> a -> Mat2x2 a
Mat2x2 (Integer -> a
forall a. Num a => Integer -> a
fromInteger Integer
x) a
0 a
0 (Integer -> a
forall a. Num a => Integer -> a
fromInteger Integer
x)

data instance UM.MVector s (Mat2x2 a) = MV_Mat2x2 !Int !Int !(MutableByteArray s)
data instance U.Vector (Mat2x2 a) = V_Mat2x2 !Int !Int !ByteArray

instance (Prim a) => U.Unbox (Mat2x2 a)

instance (Prim a) => GM.MVector UM.MVector (Mat2x2 a) where
  basicLength :: forall s. MVector s (Mat2x2 a) -> Int
basicLength (MV_Mat2x2 Int
_ Int
n MutableByteArray s
_) = Int
n
  {-# INLINE basicLength #-}
  basicUnsafeSlice :: forall s.
Int -> Int -> MVector s (Mat2x2 a) -> MVector s (Mat2x2 a)
basicUnsafeSlice Int
i Int
n (MV_Mat2x2 Int
o Int
_ MutableByteArray s
mba) = Int -> Int -> MutableByteArray s -> MVector s (Mat2x2 a)
forall s a.
Int -> Int -> MutableByteArray s -> MVector s (Mat2x2 a)
MV_Mat2x2 (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int
n MutableByteArray s
mba
  {-# INLINE basicUnsafeSlice #-}
  basicOverlaps :: forall s. MVector s (Mat2x2 a) -> MVector s (Mat2x2 a) -> Bool
basicOverlaps (MV_Mat2x2 Int
ox Int
nx MutableByteArray s
xs) (MV_Mat2x2 Int
oy Int
ny MutableByteArray s
ys) =
    MutableByteArray s -> MutableByteArray s -> Bool
forall s. MutableByteArray s -> MutableByteArray s -> Bool
sameMutableByteArray MutableByteArray s
xs MutableByteArray s
ys
      Bool -> Bool -> Bool
&& Int
ox Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
oy Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
ny
      Bool -> Bool -> Bool
&& Int
oy Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
ox Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
nx
  {-# INLINE basicOverlaps #-}
  basicUnsafeNew :: forall s. Int -> ST s (MVector s (Mat2x2 a))
basicUnsafeNew Int
n = Int -> Int -> MutableByteArray s -> MVector s (Mat2x2 a)
forall s a.
Int -> Int -> MutableByteArray s -> MVector s (Mat2x2 a)
MV_Mat2x2 Int
0 Int
n (MutableByteArray s -> MVector s (Mat2x2 a))
-> ST s (MutableByteArray s) -> ST s (MVector s (Mat2x2 a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> ST s (MutableByteArray (PrimState (ST s)))
forall (m :: * -> *).
PrimMonad m =>
Int -> m (MutableByteArray (PrimState m))
newByteArray (forall a. Prim a => a -> Int
sizeOf @a a
forall a. HasCallStack => a
undefined Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n)
  {-# INLINE basicUnsafeNew #-}
  basicInitialize :: forall s. MVector s (Mat2x2 a) -> ST s ()
basicInitialize (MV_Mat2x2 Int
o Int
n MutableByteArray s
mba) = MutableByteArray (PrimState (ST s))
-> Int -> Int -> Word8 -> ST s ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> Int -> Int -> Word8 -> m ()
fillByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
o) (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n) Word8
0
    where
      sz :: Int
sz = forall a. Prim a => a -> Int
sizeOf @a a
forall a. HasCallStack => a
undefined
  {-# INLINE basicInitialize #-}
  basicUnsafeRead :: forall s. MVector s (Mat2x2 a) -> Int -> ST s (Mat2x2 a)
basicUnsafeRead (MV_Mat2x2 Int
o Int
_ MutableByteArray s
mba) Int
i = do
    a -> a -> a -> a -> Mat2x2 a
forall a. a -> a -> a -> a -> Mat2x2 a
Mat2x2
      (a -> a -> a -> a -> Mat2x2 a)
-> ST s a -> ST s (a -> a -> a -> Mat2x2 a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MutableByteArray (PrimState (ST s)) -> Int -> ST s a
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> m a
readByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i))
      ST s (a -> a -> a -> Mat2x2 a)
-> ST s a -> ST s (a -> a -> Mat2x2 a)
forall a b. ST s (a -> b) -> ST s a -> ST s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MutableByteArray (PrimState (ST s)) -> Int -> ST s a
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> m a
readByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
      ST s (a -> a -> Mat2x2 a) -> ST s a -> ST s (a -> Mat2x2 a)
forall a b. ST s (a -> b) -> ST s a -> ST s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MutableByteArray (PrimState (ST s)) -> Int -> ST s a
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> m a
readByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2)
      ST s (a -> Mat2x2 a) -> ST s a -> ST s (Mat2x2 a)
forall a b. ST s (a -> b) -> ST s a -> ST s b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> MutableByteArray (PrimState (ST s)) -> Int -> ST s a
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> m a
readByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3)
  {-# INLINE basicUnsafeRead #-}
  basicUnsafeWrite :: forall s. MVector s (Mat2x2 a) -> Int -> Mat2x2 a -> ST s ()
basicUnsafeWrite (MV_Mat2x2 Int
o Int
_ MutableByteArray s
mba) Int
i (Mat2x2 a
m00 a
m01 a
m10 a
m11) = do
    MutableByteArray (PrimState (ST s)) -> Int -> a -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i)) a
m00
    MutableByteArray (PrimState (ST s)) -> Int -> a -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) a
m01
    MutableByteArray (PrimState (ST s)) -> Int -> a -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2) a
m10
    MutableByteArray (PrimState (ST s)) -> Int -> a -> ST s ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutableByteArray (PrimState m) -> Int -> a -> m ()
writeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3) a
m11
  {-# INLINE basicUnsafeWrite #-}
  basicUnsafeCopy :: forall s. MVector s (Mat2x2 a) -> MVector s (Mat2x2 a) -> ST s ()
basicUnsafeCopy (MV_Mat2x2 Int
o Int
n MutableByteArray s
dst) (MV_Mat2x2 Int
o' Int
_ MutableByteArray s
src) =
    MutableByteArray (PrimState (ST s))
-> Int
-> MutableByteArray (PrimState (ST s))
-> Int
-> Int
-> ST s ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m)
-> Int -> MutableByteArray (PrimState m) -> Int -> Int -> m ()
copyMutableByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
o) MutableByteArray s
MutableByteArray (PrimState (ST s))
src (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
o') (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n)
    where
      sz :: Int
sz = forall a. Prim a => a -> Int
sizeOf @a a
forall a. HasCallStack => a
undefined
  {-# INLINE basicUnsafeCopy #-}

instance (Prim a) => G.Vector U.Vector (Mat2x2 a) where
  basicUnsafeFreeze :: forall s. Mutable Vector s (Mat2x2 a) -> ST s (Vector (Mat2x2 a))
basicUnsafeFreeze (MV_Mat2x2 Int
o Int
n MutableByteArray s
mba) = Int -> Int -> ByteArray -> Vector (Mat2x2 a)
forall a. Int -> Int -> ByteArray -> Vector (Mat2x2 a)
V_Mat2x2 Int
o Int
n (ByteArray -> Vector (Mat2x2 a))
-> ST s ByteArray -> ST s (Vector (Mat2x2 a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MutableByteArray (PrimState (ST s)) -> ST s ByteArray
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m) -> m ByteArray
unsafeFreezeByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
mba
  {-# INLINE basicUnsafeFreeze #-}
  basicUnsafeThaw :: forall s. Vector (Mat2x2 a) -> ST s (Mutable Vector s (Mat2x2 a))
basicUnsafeThaw (V_Mat2x2 Int
o Int
n ByteArray
ba) = Int -> Int -> MutableByteArray s -> MVector s (Mat2x2 a)
forall s a.
Int -> Int -> MutableByteArray s -> MVector s (Mat2x2 a)
MV_Mat2x2 Int
o Int
n (MutableByteArray s -> MVector s (Mat2x2 a))
-> ST s (MutableByteArray s) -> ST s (MVector s (Mat2x2 a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ByteArray -> ST s (MutableByteArray (PrimState (ST s)))
forall (m :: * -> *).
PrimMonad m =>
ByteArray -> m (MutableByteArray (PrimState m))
unsafeThawByteArray ByteArray
ba
  {-# INLINE basicUnsafeThaw #-}
  basicLength :: Vector (Mat2x2 a) -> Int
basicLength (V_Mat2x2 Int
_ Int
n ByteArray
_) = Int
n
  {-# INLINE basicLength #-}
  basicUnsafeSlice :: Int -> Int -> Vector (Mat2x2 a) -> Vector (Mat2x2 a)
basicUnsafeSlice Int
i Int
n (V_Mat2x2 Int
o Int
_ ByteArray
ba) = Int -> Int -> ByteArray -> Vector (Mat2x2 a)
forall a. Int -> Int -> ByteArray -> Vector (Mat2x2 a)
V_Mat2x2 (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int
n ByteArray
ba
  {-# INLINE basicUnsafeSlice #-}
  basicUnsafeIndexM :: Vector (Mat2x2 a) -> Int -> Box (Mat2x2 a)
basicUnsafeIndexM (V_Mat2x2 Int
o Int
_ ByteArray
ba) Int
i =
    Mat2x2 a -> Box (Mat2x2 a)
forall a. a -> Box a
forall (m :: * -> *) a. Monad m => a -> m a
return (Mat2x2 a -> Box (Mat2x2 a)) -> Mat2x2 a -> Box (Mat2x2 a)
forall a b. (a -> b) -> a -> b
$!
      a -> a -> a -> a -> Mat2x2 a
forall a. a -> a -> a -> a -> Mat2x2 a
Mat2x2
        (ByteArray -> Int -> a
forall a. Prim a => ByteArray -> Int -> a
indexByteArray ByteArray
ba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i)))
        (ByteArray -> Int -> a
forall a. Prim a => ByteArray -> Int -> a
indexByteArray ByteArray
ba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))
        (ByteArray -> Int -> a
forall a. Prim a => ByteArray -> Int -> a
indexByteArray ByteArray
ba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
2))
        (ByteArray -> Int -> a
forall a. Prim a => ByteArray -> Int -> a
indexByteArray ByteArray
ba (Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* (Int
o Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
3))
  {-# INLINE basicUnsafeIndexM #-}
  basicUnsafeCopy :: forall s.
Mutable Vector s (Mat2x2 a) -> Vector (Mat2x2 a) -> ST s ()
basicUnsafeCopy (MV_Mat2x2 Int
o Int
n MutableByteArray s
dst) (V_Mat2x2 Int
o' Int
_ ByteArray
src) =
    MutableByteArray (PrimState (ST s))
-> Int -> ByteArray -> Int -> Int -> ST s ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m)
-> Int -> ByteArray -> Int -> Int -> m ()
copyByteArray MutableByteArray s
MutableByteArray (PrimState (ST s))
dst (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
o) ByteArray
src (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
o') (Int
sz Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n)
    where
      sz :: Int
sz = forall a. Prim a => a -> Int
sizeOf @a a
forall a. HasCallStack => a
undefined
  elemseq :: forall b. Vector (Mat2x2 a) -> Mat2x2 a -> b -> b
elemseq Vector (Mat2x2 a)
_ = Mat2x2 a -> b -> b
forall a b. a -> b -> b
seq
  {-# INLINE elemseq #-}