{-# LANGUAGE StandaloneDeriving,GeneralizedNewtypeDeriving #-}
 {-# OPTIONS_GHC -fplugin=GHC.TypeLits.KnownNat.Solver -fplugin=GHC.TypeLits.Normalise -fconstraint-solver-iterations=10 #-}
-- | Vectors and Matrices with statically typed dimensions.
module Goal.Core.Vector.Generic
    ( -- * Vector
      module Data.Vector.Generic.Sized
    , VectorClass
    -- * Construction
    , doubleton
    , range
    , breakEvery
    -- * Deconstruction
    , concat
    -- * Matrix
    , Matrix (Matrix,toVector)
    , nRows
    , nColumns
    -- ** Construction
    , fromRows
    , fromColumns
    -- ** Deconstruction
    , toPair
    , toRows
    , toColumns
    -- ** Manipulation
    , columnVector
    , rowVector
    -- ** BLAS
    , transpose
    , dotProduct
    , weakDotProduct
    , outerProduct
    , matrixVectorMultiply
    , matrixMatrixMultiply
    ) where


--- Imports ---


-- Goal --

import Goal.Core.Util hiding (breakEvery,range)

-- Unqualified --

import GHC.TypeNats
import Data.Proxy
import Control.DeepSeq
import Data.Vector.Generic.Sized
import Data.Vector.Generic.Sized.Internal
import Foreign.Storable
import Prelude hiding (concatMap,concat,map,sum,replicate)

-- Qualified --

import qualified Data.Vector.Generic as G
import qualified Data.Vector.Storable as S

import Numeric.LinearAlgebra (Numeric)

--- Vector ---


type VectorClass = G.Vector

-- | Create a 'Matrix' from a 'Vector' of 'Vector's which represent the rows.
concat :: (KnownNat n, G.Vector v x, G.Vector v (Vector v n x)) => Vector v m (Vector v n x) -> Vector v (m*n) x
{-# INLINE concat #-}
concat :: Vector v m (Vector v n x) -> Vector v (m * n) x
concat = (Vector v n x -> Vector v n x)
-> Vector v m (Vector v n x) -> Vector v (m * n) x
forall (v :: Type -> Type) a (v' :: Type -> Type) b (m :: Nat)
       (n :: Nat).
(Vector v a, Vector v' b) =>
(a -> Vector v' m b) -> Vector v n a -> Vector v' (n * m) b
concatMap Vector v n x -> Vector v n x
forall a. a -> a
id

-- | Collect two values into a length 2 'Vector'.
doubleton :: G.Vector v x => x -> x -> Vector v 2 x
{-# INLINE doubleton #-}
doubleton :: x -> x -> Vector v 2 x
doubleton x
x1 x
x2 = x -> Vector v 1 x -> Vector v (1 + 1) x
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
a -> Vector v n a -> Vector v (1 + n) a
cons x
x1 (Vector v 1 x -> Vector v (1 + 1) x)
-> Vector v 1 x -> Vector v (1 + 1) x
forall a b. (a -> b) -> a -> b
$ x -> Vector v 1 x
forall (v :: Type -> Type) a. Vector v a => a -> Vector v 1 a
singleton x
x2

-- | Breaks a 'Vector' into a Vector of Vectors.
breakEvery
    :: forall v n k a . (G.Vector v a, G.Vector v (Vector v k a), KnownNat n, KnownNat k)
    => Vector v (n*k) a -> Vector v n (Vector v k a)
{-# INLINE breakEvery #-}
breakEvery :: Vector v (n * k) a -> Vector v n (Vector v k a)
breakEvery Vector v (n * k) a
v0 =
    let k :: Int
k = Proxy k -> Int
forall (n :: Nat). KnownNat n => Proxy n -> Int
natValInt (Proxy k
forall k (t :: k). Proxy t
Proxy :: Proxy k)
        v :: v a
v = Vector v (n * k) a -> v a
forall (v :: Type -> Type) (n :: Nat) a. Vector v n a -> v a
fromSized Vector v (n * k) a
v0
     in (Finite n -> Vector v k a) -> Vector v n (Vector v k a)
forall (v :: Type -> Type) (n :: Nat) a.
(KnownNat n, Vector v a) =>
(Finite n -> a) -> Vector v n a
generate (\Finite n
i -> v a -> Vector v k a
forall (v :: Type -> Type) (n :: Nat) a. v a -> Vector v n a
Vector (v a -> Vector v k a) -> v a -> Vector v k a
forall a b. (a -> b) -> a -> b
$ Int -> Int -> v a -> v a
forall (v :: Type -> Type) a.
Vector v a =>
Int -> Int -> v a -> v a
G.unsafeSlice (Finite n -> Int
forall (n :: Nat). KnownNat n => Finite n -> Int
finiteInt Finite n
iInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
k) Int
k v a
v)

-- | Reshapes a length 2 'Vector' into a pair of values.
toPair :: G.Vector v a => Vector v 2 a -> (a,a)
{-# INLINE toPair #-}
toPair :: Vector v 2 a -> (a, a)
toPair Vector v 2 a
v = (Vector v 2 a -> Int -> a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v n a -> Int -> a
unsafeIndex Vector v 2 a
v Int
0, Vector v 2 a -> Int -> a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v n a -> Int -> a
unsafeIndex Vector v 2 a
v Int
1)

-- | Uniform partition of an interval into a 'Vector'.
range
    :: forall v n x. (G.Vector v x, KnownNat n, Fractional x)
    => x -> x -> Vector v n x
{-# INLINE range #-}
range :: x -> x -> Vector v n x
range x
mn x
mx =
    let n :: Int
n = Proxy n -> Int
forall (n :: Nat). KnownNat n => Proxy n -> Int
natValInt (Proxy n
forall k (t :: k). Proxy t
Proxy :: Proxy n)
        stp :: x
stp = (x
mx x -> x -> x
forall a. Num a => a -> a -> a
- x
mn)x -> x -> x
forall a. Fractional a => a -> a -> a
/Int -> x
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
     in x -> x -> Vector v n x
forall (v :: Type -> Type) (n :: Nat) a.
(KnownNat n, Vector v a, Num a) =>
a -> a -> Vector v n a
enumFromStepN x
mn x
stp


--- Matrix ---


-- | Matrices with static dimensions.
newtype Matrix v (m :: Nat) (n :: Nat) a = Matrix { Matrix v m n a -> Vector v (m * n) a
toVector :: Vector v (m*n) a }
    deriving (Matrix v m n a -> Matrix v m n a -> Bool
(Matrix v m n a -> Matrix v m n a -> Bool)
-> (Matrix v m n a -> Matrix v m n a -> Bool)
-> Eq (Matrix v m n a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Eq (v a) =>
Matrix v m n a -> Matrix v m n a -> Bool
/= :: Matrix v m n a -> Matrix v m n a -> Bool
$c/= :: forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Eq (v a) =>
Matrix v m n a -> Matrix v m n a -> Bool
== :: Matrix v m n a -> Matrix v m n a -> Bool
$c== :: forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Eq (v a) =>
Matrix v m n a -> Matrix v m n a -> Bool
Eq,Int -> Matrix v m n a -> ShowS
[Matrix v m n a] -> ShowS
Matrix v m n a -> String
(Int -> Matrix v m n a -> ShowS)
-> (Matrix v m n a -> String)
-> ([Matrix v m n a] -> ShowS)
-> Show (Matrix v m n a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Show (v a) =>
Int -> Matrix v m n a -> ShowS
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Show (v a) =>
[Matrix v m n a] -> ShowS
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Show (v a) =>
Matrix v m n a -> String
showList :: [Matrix v m n a] -> ShowS
$cshowList :: forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Show (v a) =>
[Matrix v m n a] -> ShowS
show :: Matrix v m n a -> String
$cshow :: forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Show (v a) =>
Matrix v m n a -> String
showsPrec :: Int -> Matrix v m n a -> ShowS
$cshowsPrec :: forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Show (v a) =>
Int -> Matrix v m n a -> ShowS
Show,Matrix v m n a -> ()
(Matrix v m n a -> ()) -> NFData (Matrix v m n a)
forall a. (a -> ()) -> NFData a
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
NFData (v a) =>
Matrix v m n a -> ()
rnf :: Matrix v m n a -> ()
$crnf :: forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
NFData (v a) =>
Matrix v m n a -> ()
NFData)

deriving instance (KnownNat m, KnownNat n, Storable x) => Storable (Matrix S.Vector m n x)
deriving instance (KnownNat m, KnownNat n, Numeric x, Num x)
  => Num (Matrix S.Vector m n x)
deriving instance (KnownNat m, KnownNat n, Numeric x, Fractional x)
  => Fractional (Matrix S.Vector m n x)
deriving instance (KnownNat m, KnownNat n, Numeric x, Floating x)
  => Floating (Matrix S.Vector m n x)

-- | Turn a 'Vector' into a single column 'Matrix'.
columnVector :: Vector v n a -> Matrix v n 1 a
{-# INLINE columnVector #-}
columnVector :: Vector v n a -> Matrix v n 1 a
columnVector = Vector v n a -> Matrix v n 1 a
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Vector v (m * n) a -> Matrix v m n a
Matrix

-- | Turn a 'Vector' into a single row 'Matrix'.
rowVector :: Vector v n a -> Matrix v 1 n a
{-# INLINE rowVector #-}
rowVector :: Vector v n a -> Matrix v 1 n a
rowVector = Vector v n a -> Matrix v 1 n a
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Vector v (m * n) a -> Matrix v m n a
Matrix

-- | Create a 'Matrix' from a 'Vector' of 'Vector's which represent the rows.
fromRows :: (G.Vector v x, G.Vector v (Vector v n x), KnownNat n) => Vector v m (Vector v n x) -> Matrix v m n x
{-# INLINE fromRows #-}
fromRows :: Vector v m (Vector v n x) -> Matrix v m n x
fromRows = Vector v (m * n) x -> Matrix v m n x
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
Vector v (m * n) a -> Matrix v m n a
Matrix (Vector v (m * n) x -> Matrix v m n x)
-> (Vector v m (Vector v n x) -> Vector v (m * n) x)
-> Vector v m (Vector v n x)
-> Matrix v m n x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector v m (Vector v n x) -> Vector v (m * n) x
forall (n :: Nat) (v :: Type -> Type) x (m :: Nat).
(KnownNat n, Vector v x, Vector v (Vector v n x)) =>
Vector v m (Vector v n x) -> Vector v (m * n) x
concat

-- | Create a 'Matrix' from a 'Vector' of 'Vector's which represent the columns.
fromColumns
    :: (G.Vector v x, G.Vector v Int, G.Vector v (Vector v n x), G.Vector v (Vector v m x), KnownNat n, KnownNat m)
    => Vector v n (Vector v m x) -> Matrix v m n x
{-# INLINE fromColumns #-}
fromColumns :: Vector v n (Vector v m x) -> Matrix v m n x
fromColumns = Matrix v n m x -> Matrix v m n x
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
(KnownNat m, KnownNat n, Vector v Int, Vector v a,
 Vector v (Vector v m a)) =>
Matrix v m n a -> Matrix v n m a
transpose (Matrix v n m x -> Matrix v m n x)
-> (Vector v n (Vector v m x) -> Matrix v n m x)
-> Vector v n (Vector v m x)
-> Matrix v m n x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector v n (Vector v m x) -> Matrix v n m x
forall (v :: Type -> Type) x (n :: Nat) (m :: Nat).
(Vector v x, Vector v (Vector v n x), KnownNat n) =>
Vector v m (Vector v n x) -> Matrix v m n x
fromRows

-- | The number of rows in the 'Matrix'.
nRows :: forall v m n a . KnownNat m => Matrix v m n a -> Int
{-# INLINE nRows #-}
nRows :: Matrix v m n a -> Int
nRows Matrix v m n a
_ = Proxy m -> Int
forall (n :: Nat). KnownNat n => Proxy n -> Int
natValInt (Proxy m
forall k (t :: k). Proxy t
Proxy :: Proxy m)

-- | The number of columns in the 'Matrix'.
nColumns :: forall v m n a . KnownNat n => Matrix v m n a -> Int
{-# INLINE nColumns #-}
nColumns :: Matrix v m n a -> Int
nColumns Matrix v m n a
_ = Proxy n -> Int
forall (n :: Nat). KnownNat n => Proxy n -> Int
natValInt (Proxy n
forall k (t :: k). Proxy t
Proxy :: Proxy n)

-- | Convert a 'Matrix' into a 'Vector' of 'Vector's of rows.
toRows :: (G.Vector v a, G.Vector v (Vector v n a), KnownNat n, KnownNat m)
       => Matrix v m n a -> Vector v m (Vector v n a)
{-# INLINE toRows #-}
toRows :: Matrix v m n a -> Vector v m (Vector v n a)
toRows (Matrix Vector v (m * n) a
v) = Vector v (m * n) a -> Vector v m (Vector v n a)
forall (v :: Type -> Type) (n :: Nat) (k :: Nat) a.
(Vector v a, Vector v (Vector v k a), KnownNat n, KnownNat k) =>
Vector v (n * k) a -> Vector v n (Vector v k a)
breakEvery Vector v (m * n) a
v

-- | Convert a 'Matrix' into a 'Vector' of 'Vector's of columns.
toColumns
    :: (G.Vector v a, G.Vector v (Vector v m a), KnownNat m, KnownNat n, G.Vector v Int)
    => Matrix v m n a -> Vector v n (Vector v m a)
{-# INLINE toColumns #-}
toColumns :: Matrix v m n a -> Vector v n (Vector v m a)
toColumns = Matrix v n m a -> Vector v n (Vector v m a)
forall (v :: Type -> Type) a (n :: Nat) (m :: Nat).
(Vector v a, Vector v (Vector v n a), KnownNat n, KnownNat m) =>
Matrix v m n a -> Vector v m (Vector v n a)
toRows (Matrix v n m a -> Vector v n (Vector v m a))
-> (Matrix v m n a -> Matrix v n m a)
-> Matrix v m n a
-> Vector v n (Vector v m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Matrix v m n a -> Matrix v n m a
forall (v :: Type -> Type) (m :: Nat) (n :: Nat) a.
(KnownNat m, KnownNat n, Vector v Int, Vector v a,
 Vector v (Vector v m a)) =>
Matrix v m n a -> Matrix v n m a
transpose


--- BLAS ---


-- | Pure implementation of 'Matrix' transposition.
transpose
    :: forall v m n a . (KnownNat m, KnownNat n, G.Vector v Int, G.Vector v a, G.Vector v (Vector v m a))
    => Matrix v m n a -> Matrix v n m a
{-# INLINE transpose #-}
transpose :: Matrix v m n a -> Matrix v n m a
transpose (Matrix Vector v (m * n) a
v) =
    let n :: Int
n = Proxy n -> Int
forall (n :: Nat). KnownNat n => Proxy n -> Int
natValInt (Proxy n
forall k (t :: k). Proxy t
Proxy :: Proxy n)
     in Vector v n (Vector v m a) -> Matrix v n m a
forall (v :: Type -> Type) x (n :: Nat) (m :: Nat).
(Vector v x, Vector v (Vector v n x), KnownNat n) =>
Vector v m (Vector v n x) -> Matrix v m n x
fromRows (Vector v n (Vector v m a) -> Matrix v n m a)
-> Vector v n (Vector v m a) -> Matrix v n m a
forall a b. (a -> b) -> a -> b
$ (Finite n -> Vector v m a) -> Vector v n (Vector v m a)
forall (v :: Type -> Type) (n :: Nat) a.
(KnownNat n, Vector v a) =>
(Finite n -> a) -> Vector v n a
generate (\Finite n
j -> (Finite m -> a) -> Vector v m a
forall (v :: Type -> Type) (n :: Nat) a.
(KnownNat n, Vector v a) =>
(Finite n -> a) -> Vector v n a
generate (\Finite m
i -> Vector v (m * n) a -> Int -> a
forall (v :: Type -> Type) (n :: Nat) a.
Vector v a =>
Vector v n a -> Int -> a
unsafeIndex Vector v (m * n) a
v (Int -> a) -> Int -> a
forall a b. (a -> b) -> a -> b
$ Finite n -> Int
forall (n :: Nat). KnownNat n => Finite n -> Int
finiteInt Finite n
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Finite m -> Int
forall (n :: Nat). KnownNat n => Finite n -> Int
finiteInt Finite m
iInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
n) :: Vector v m a)

-- | Pure implementation of the dot product.
dotProduct :: (G.Vector v x, Num x) => Vector v n x -> Vector v n x -> x
{-# INLINE dotProduct #-}
dotProduct :: Vector v n x -> Vector v n x -> x
dotProduct Vector v n x
v1 Vector v n x
v2 = v x -> v x -> x
forall (v :: Type -> Type) x.
(Vector v x, Num x) =>
v x -> v x -> x
weakDotProduct (Vector v n x -> v x
forall (v :: Type -> Type) (n :: Nat) a. Vector v n a -> v a
fromSized Vector v n x
v1) (Vector v n x -> v x
forall (v :: Type -> Type) (n :: Nat) a. Vector v n a -> v a
fromSized Vector v n x
v2)

-- | Pure implementation of the outer product.
outerProduct
    :: ( KnownNat m, KnownNat n, Num x
       , G.Vector v Int, G.Vector v x, G.Vector v (Vector v n x), G.Vector v (Vector v m x), G.Vector v (Vector v 1 x) )
     => Vector v n x -> Vector v m x -> Matrix v n m x
{-# INLINE outerProduct #-}
outerProduct :: Vector v n x -> Vector v m x -> Matrix v n m x
outerProduct Vector v n x
v1 Vector v m x
v2 = Matrix v n 1 x -> Matrix v 1 m x -> Matrix v n m x
forall (m :: Nat) (n :: Nat) (o :: Nat) x (v :: Type -> Type).
(KnownNat m, KnownNat n, KnownNat o, Num x, Vector v Int,
 Vector v x, Vector v (Vector v m x), Vector v (Vector v n x),
 Vector v (Vector v o x)) =>
Matrix v m n x -> Matrix v n o x -> Matrix v m o x
matrixMatrixMultiply (Vector v n x -> Matrix v n 1 x
forall (v :: Type -> Type) (n :: Nat) a.
Vector v n a -> Matrix v n 1 a
columnVector Vector v n x
v1) (Vector v m x -> Matrix v 1 m x
forall (v :: Type -> Type) (n :: Nat) a.
Vector v n a -> Matrix v 1 n a
rowVector Vector v m x
v2)

-- | Pure implementation of the dot product on standard vectors.
weakDotProduct :: (G.Vector v x, Num x) => v x -> v x -> x
{-# INLINE weakDotProduct #-}
weakDotProduct :: v x -> v x -> x
weakDotProduct v x
v1 v x
v2 = (x -> Int -> x) -> x -> Vector Int -> x
forall (v :: Type -> Type) b a.
Vector v b =>
(a -> b -> a) -> a -> v b -> a
G.foldl x -> Int -> x
foldFun x
0 (Int -> Int -> Vector Int
forall (v :: Type -> Type) a.
(Vector v a, Num a) =>
a -> Int -> v a
G.enumFromN Int
0 (v x -> Int
forall (v :: Type -> Type) a. Vector v a => v a -> Int
G.length v x
v1) :: S.Vector Int)
    where foldFun :: x -> Int -> x
foldFun x
d Int
i = x
d x -> x -> x
forall a. Num a => a -> a -> a
+ v x -> Int -> x
forall (v :: Type -> Type) a. Vector v a => v a -> Int -> a
G.unsafeIndex v x
v1 Int
i x -> x -> x
forall a. Num a => a -> a -> a
* v x -> Int -> x
forall (v :: Type -> Type) a. Vector v a => v a -> Int -> a
G.unsafeIndex v x
v2 Int
i

-- | Pure 'Matrix' x 'Vector' multiplication.
matrixVectorMultiply
    :: (KnownNat m, KnownNat n, G.Vector v x, G.Vector v (Vector v n x), Num x)
    => Matrix v m n x
    -> Vector v n x
    -> Vector v m x
{-# INLINE matrixVectorMultiply #-}
matrixVectorMultiply :: Matrix v m n x -> Vector v n x -> Vector v m x
matrixVectorMultiply Matrix v m n x
mtx Vector v n x
v =
    (Vector v n x -> x) -> Vector v m (Vector v n x) -> Vector v m x
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
map (Vector v n x -> Vector v n x -> x
forall (v :: Type -> Type) x (n :: Nat).
(Vector v x, Num x) =>
Vector v n x -> Vector v n x -> x
dotProduct Vector v n x
v) (Vector v m (Vector v n x) -> Vector v m x)
-> Vector v m (Vector v n x) -> Vector v m x
forall a b. (a -> b) -> a -> b
$ Matrix v m n x -> Vector v m (Vector v n x)
forall (v :: Type -> Type) a (n :: Nat) (m :: Nat).
(Vector v a, Vector v (Vector v n a), KnownNat n, KnownNat m) =>
Matrix v m n a -> Vector v m (Vector v n a)
toRows Matrix v m n x
mtx

-- | Pure 'Matrix' x 'Matrix' multiplication.
matrixMatrixMultiply
    :: ( KnownNat m, KnownNat n, KnownNat o, Num x
       , G.Vector v Int, G.Vector v x, G.Vector v (Vector v m x), G.Vector v (Vector v n x), G.Vector v (Vector v o x) )
    => Matrix v m n x
    -> Matrix v n o x
    -> Matrix v m o x
{-# INLINE matrixMatrixMultiply #-}
matrixMatrixMultiply :: Matrix v m n x -> Matrix v n o x -> Matrix v m o x
matrixMatrixMultiply Matrix v m n x
mtx1 Matrix v n o x
mtx2 =
    Vector v o (Vector v m x) -> Matrix v m o x
forall (v :: Type -> Type) x (n :: Nat) (m :: Nat).
(Vector v x, Vector v Int, Vector v (Vector v n x),
 Vector v (Vector v m x), KnownNat n, KnownNat m) =>
Vector v n (Vector v m x) -> Matrix v m n x
fromColumns (Vector v o (Vector v m x) -> Matrix v m o x)
-> (Vector v o (Vector v n x) -> Vector v o (Vector v m x))
-> Vector v o (Vector v n x)
-> Matrix v m o x
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Vector v n x -> Vector v m x)
-> Vector v o (Vector v n x) -> Vector v o (Vector v m x)
forall (v :: Type -> Type) a b (n :: Nat).
(Vector v a, Vector v b) =>
(a -> b) -> Vector v n a -> Vector v n b
map (Matrix v m n x -> Vector v n x -> Vector v m x
forall (m :: Nat) (n :: Nat) (v :: Type -> Type) x.
(KnownNat m, KnownNat n, Vector v x, Vector v (Vector v n x),
 Num x) =>
Matrix v m n x -> Vector v n x -> Vector v m x
matrixVectorMultiply Matrix v m n x
mtx1) (Vector v o (Vector v n x) -> Matrix v m o x)
-> Vector v o (Vector v n x) -> Matrix v m o x
forall a b. (a -> b) -> a -> b
$ Matrix v n o x -> Vector v o (Vector v n x)
forall (v :: Type -> Type) a (m :: Nat) (n :: Nat).
(Vector v a, Vector v (Vector v m a), KnownNat m, KnownNat n,
 Vector v Int) =>
Matrix v m n a -> Vector v n (Vector v m a)
toColumns Matrix v n o x
mtx2


--- Numeric Classes ---


--instance (Storable x, Numeric x, KnownNat n, KnownNat m)
--  => Num (Matrix S.Vector n m x) where
--    {-# INLINE (+) #-}
--    (+) (Matrix (Vector v1)) (Matrix (Vector v2)) = Matrix $ Vector (H.add v1 v2)
--    {-# INLINE (*) #-}
--    (*) (Matrix xs) (Matrix xs') = Matrix $ xs * xs'
--    {-# INLINE negate #-}
--    negate (Matrix (Vector v)) = Matrix $ Vector (H.scale (-1) v)
--    {-# INLINE abs #-}
--    abs (Matrix xs) = Matrix $ abs xs
--    {-# INLINE signum #-}
--    signum (Matrix xs) = Matrix $ signum xs
--    {-# INLINE fromInteger #-}
--    fromInteger x = Matrix . replicate $ fromInteger x