NumHask.Matrix

Two-dimensional arrays. Two classes are supplied

• Matrix where shape information is held at type level, and
• SomeMatrix where shape is held at the value level.

In both cases, the underlying data is contained as a flat vector for efficiency purposes.

Documentation

newtype Matrix m n a

a two-dimensional array where shape is specified at the type level The main purpose of this, beyond safe typing, is to supply the Representable instance with an initial object. A single Boxed Vector is used underneath for efficient slicing, but this may change or become polymorphic in the future.

Constructors

Matrix

Fields

• flattenMatrix :: Vector a

Instances

Functor (Matrix k1 k m n)

Methods

fmap :: (a -> b) -> Matrix k1 k m n a -> Matrix k1 k m n b

(<$) :: a -> Matrix k1 k m n b -> Matrix k1 k m n a

Foldable (Matrix k1 k m n)

Methods

fold :: Monoid m => Matrix k1 k m n m -> m

foldMap :: Monoid m => (a -> m) -> Matrix k1 k m n a -> m

foldr :: (a -> b -> b) -> b -> Matrix k1 k m n a -> b

foldr' :: (a -> b -> b) -> b -> Matrix k1 k m n a -> b

foldl :: (b -> a -> b) -> b -> Matrix k1 k m n a -> b

foldl' :: (b -> a -> b) -> b -> Matrix k1 k m n a -> b

foldr1 :: (a -> a -> a) -> Matrix k1 k m n a -> a

foldl1 :: (a -> a -> a) -> Matrix k1 k m n a -> a

toList :: Matrix k1 k m n a -> [a]

null :: Matrix k1 k m n a -> Bool

length :: Matrix k1 k m n a -> Int

elem :: Eq a => a -> Matrix k1 k m n a -> Bool

maximum :: Ord a => Matrix k1 k m n a -> a

minimum :: Ord a => Matrix k1 k m n a -> a

sum :: Num a => Matrix k1 k m n a -> a

product :: Num a => Matrix k1 k m n a -> a

(KnownNat m, KnownNat n) => Distributive (Matrix Nat Nat m n)

Methods

distribute :: Functor f => f (Matrix Nat Nat m n a) -> Matrix Nat Nat m n (f a)

collect :: Functor f => (a -> Matrix Nat Nat m n b) -> f a -> Matrix Nat Nat m n (f b)

distributeM :: Monad m => m (Matrix Nat Nat m n a) -> Matrix Nat Nat m n (m a)

collectM :: Monad m => (a -> Matrix Nat Nat m n b) -> m a -> Matrix Nat Nat m n (m b)

(KnownNat m, KnownNat n) => Representable (Matrix Nat Nat m n)

Associated Types

type Rep (Matrix Nat Nat m n :: * -> *) :: *

Methods

tabulate :: (Rep (Matrix Nat Nat m n) -> a) -> Matrix Nat Nat m n a

index :: Matrix Nat Nat m n a -> Rep (Matrix Nat Nat m n) -> a

(KnownNat m, KnownNat n) => Naperian (Matrix Nat Nat m n)

(KnownNat m, KnownNat n) => HasShape (Matrix Nat Nat m n)

Associated Types

type Shape (Matrix Nat Nat m n :: * -> *) :: *

Methods

shape :: Matrix Nat Nat m n a -> Shape (Matrix Nat Nat m n)

ndim :: Matrix Nat Nat m n a -> Int

(KnownNat m, KnownNat n, AdditiveUnital a) => IsList (Matrix Nat Nat m n a)

from flat list

Associated Types

type Item (Matrix Nat Nat m n a) :: *

Methods

fromList :: [Item (Matrix Nat Nat m n a)] -> Matrix Nat Nat m n a

fromListN :: Int -> [Item (Matrix Nat Nat m n a)] -> Matrix Nat Nat m n a

toList :: Matrix Nat Nat m n a -> [Item (Matrix Nat Nat m n a)]

Eq a => Eq (Matrix k1 k m n a)

Methods

(==) :: Matrix k1 k m n a -> Matrix k1 k m n a -> Bool

(/=) :: Matrix k1 k m n a -> Matrix k1 k m n a -> Bool

(Show a, KnownNat m, KnownNat n) => Show (Matrix Nat Nat m n a)

Methods

showsPrec :: Int -> Matrix Nat Nat m n a -> ShowS

show :: Matrix Nat Nat m n a -> String

showList :: [Matrix Nat Nat m n a] -> ShowS

(KnownNat m, KnownNat n, Arbitrary a, AdditiveUnital a) => Arbitrary (Matrix Nat Nat m n a)

Methods

arbitrary :: Gen (Matrix Nat Nat m n a)

shrink :: Matrix Nat Nat m n a -> [Matrix Nat Nat m n a]

type Rep (Matrix Nat Nat m n)

type Rep (Matrix Nat Nat m n) = (Int, Int)

type Shape (Matrix Nat Nat m n)

type Shape (Matrix Nat Nat m n) = (Int, Int)

type Item (Matrix Nat Nat m n a)

type Item (Matrix Nat Nat m n a) = a

data SomeMatrix a

a two-dimensional array where shape is specified at the value level as a '(Int,Int)' Use this to avoid type-level hasochism by demoting a Matrix with someMatrix

Constructors

SomeMatrix (Int, Int) (Vector a)

Instances

Functor SomeMatrix

Methods

fmap :: (a -> b) -> SomeMatrix a -> SomeMatrix b

(<$) :: a -> SomeMatrix b -> SomeMatrix a

Foldable SomeMatrix

Methods

fold :: Monoid m => SomeMatrix m -> m

foldMap :: Monoid m => (a -> m) -> SomeMatrix a -> m

foldr :: (a -> b -> b) -> b -> SomeMatrix a -> b

foldr' :: (a -> b -> b) -> b -> SomeMatrix a -> b

foldl :: (b -> a -> b) -> b -> SomeMatrix a -> b

foldl' :: (b -> a -> b) -> b -> SomeMatrix a -> b

foldr1 :: (a -> a -> a) -> SomeMatrix a -> a

foldl1 :: (a -> a -> a) -> SomeMatrix a -> a

toList :: SomeMatrix a -> [a]

null :: SomeMatrix a -> Bool

length :: SomeMatrix a -> Int

elem :: Eq a => a -> SomeMatrix a -> Bool

maximum :: Ord a => SomeMatrix a -> a

minimum :: Ord a => SomeMatrix a -> a

sum :: Num a => SomeMatrix a -> a

product :: Num a => SomeMatrix a -> a

HasShape SomeMatrix

Associated Types

type Shape (SomeMatrix :: * -> *) :: *

Methods

shape :: SomeMatrix a -> Shape SomeMatrix

ndim :: SomeMatrix a -> Int

IsList (SomeMatrix a)

from nested list

Associated Types

type Item (SomeMatrix a) :: *

Methods

fromList :: [Item (SomeMatrix a)] -> SomeMatrix a

fromListN :: Int -> [Item (SomeMatrix a)] -> SomeMatrix a

toList :: SomeMatrix a -> [Item (SomeMatrix a)]

Eq a => Eq (SomeMatrix a)

Methods

(==) :: SomeMatrix a -> SomeMatrix a -> Bool

(/=) :: SomeMatrix a -> SomeMatrix a -> Bool

Show a => Show (SomeMatrix a)

Methods

showsPrec :: Int -> SomeMatrix a -> ShowS

show :: SomeMatrix a -> String

showList :: [SomeMatrix a] -> ShowS

Arbitrary a => Arbitrary (SomeMatrix a)

Methods

arbitrary :: Gen (SomeMatrix a)

shrink :: SomeMatrix a -> [SomeMatrix a]

type Shape SomeMatrix

type Shape SomeMatrix = (Int, Int)

type Item (SomeMatrix a)

type Item (SomeMatrix a) = [a]

newtype ShapeM

just used to get sensible arbitrary instances of SomeMatrix

Constructors

ShapeM

Fields

• unshapeM :: (Int, Int)

Instances

Arbitrary ShapeM

Methods

arbitrary :: Gen ShapeM

shrink :: ShapeM -> [ShapeM]

Conversion

someMatrix :: (KnownNat m, KnownNat n) => Matrix (m :: Nat) (n :: Nat) a -> SomeMatrix a

convert from a Matrix to a SomeMatrix

unsafeToMatrix :: SomeMatrix a -> Matrix (m :: Nat) (n :: Nat) a

convert from a SomeMatrix to a Matrix with no shape check

toMatrix :: forall a m n. (KnownNat m, KnownNat n) => SomeMatrix a -> Maybe (Matrix (m :: Nat) (n :: Nat) a)

convert from a SomeMatrix to a Matrix, checking shape

unsafeFromVV :: forall a m n. Vector m (Vector n a) -> Matrix m n a

conversion from a double Vector representation

toCol :: forall a n. Vector n a -> Matrix 1 n a

convert a Vector to a column Matrix

toRow :: forall a m. Vector m a -> Matrix m 1 a

convert a Vector to a row Matrix

fromCol :: forall a n. Matrix 1 n a -> Vector n a

convert a row Matrix to a Vector

fromRow :: forall a m. Matrix m 1 a -> Vector m a

convert a column Matrix to a Vector

col :: forall a m n. (KnownNat m, KnownNat n) => Int -> Matrix m n a -> Vector m a

extract a column from a Matrix as a Vector

row :: forall a m n. (KnownNat m, KnownNat n) => Int -> Matrix m n a -> Vector n a

extract a row from a Matrix as a Vector

Operations

mmult :: forall m n k a. (CRing a, KnownNat m, KnownNat n, KnownNat k) => Matrix m k a -> Matrix k n a -> Matrix m n a

matrix multiplication for a Matrix