Safe Haskell	None
Language	Haskell2010

NumHask.Matrix

Contents

Conversion
Operations

Description

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.

Synopsis

Documentation

newtype Matrix m n a Source #

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) Source #
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) Source #
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) Source #
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) Source #
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) Source #

(KnownNat m, KnownNat n) => HasShape (Matrix Nat Nat m n) Source #
Associated Types type Shape (Matrix Nat Nat m n :: * -> ) :: Source # Methods shape :: Matrix Nat Nat m n a -> Shape (Matrix Nat Nat m n) Source # ndim :: Matrix Nat Nat m n a -> Int Source #
(KnownNat m, KnownNat n, AdditiveUnital a) => IsList (Matrix Nat Nat m n a) Source #	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) Source #
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) Source #
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) Source #
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) Source #
type Rep (Matrix Nat Nat m n) = (Int, Int)
type Shape (Matrix Nat Nat m n) Source #
type Shape (Matrix Nat Nat m n) = (Int, Int)
type Item (Matrix Nat Nat m n a) Source #
type Item (Matrix Nat Nat m n a) = a

data SomeMatrix a Source #

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 Source #
Methods fmap :: (a -> b) -> SomeMatrix a -> SomeMatrix b # (<$) :: a -> SomeMatrix b -> SomeMatrix a #
Foldable SomeMatrix Source #
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 Source #
Associated Types type Shape (SomeMatrix :: * -> ) :: Source # Methods shape :: SomeMatrix a -> Shape SomeMatrix Source # ndim :: SomeMatrix a -> Int Source #
IsList (SomeMatrix a) Source #	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) Source #
Methods (==) :: SomeMatrix a -> SomeMatrix a -> Bool # (/=) :: SomeMatrix a -> SomeMatrix a -> Bool #
Show a => Show (SomeMatrix a) Source #
Methods showsPrec :: Int -> SomeMatrix a -> ShowS # show :: SomeMatrix a -> String # showList :: [SomeMatrix a] -> ShowS #
Arbitrary a => Arbitrary (SomeMatrix a) Source #
Methods arbitrary :: Gen (SomeMatrix a) # shrink :: SomeMatrix a -> [SomeMatrix a] #
type Shape SomeMatrix Source #
type Shape SomeMatrix = (Int, Int)
type Item (SomeMatrix a) Source #
type Item (SomeMatrix a) = [a]

newtype ShapeM Source #

just used to get sensible arbitrary instances of SomeMatrix

Constructors

ShapeM
Fields unshapeM :: (Int, Int)

Instances

Arbitrary ShapeM Source #
Methods arbitrary :: Gen ShapeM # shrink :: ShapeM -> [ShapeM] #

Conversion

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

convert from a Matrix to a SomeMatrix

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

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) Source #

convert from a SomeMatrix to a Matrix, checking shape

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

conversion from a double Vector representation

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

convert a Vector to a column Matrix

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

convert a Vector to a row Matrix

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

convert a row Matrix to a Vector

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

convert a column Matrix to a Vector

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

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 Source #

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 Source #

matrix multiplication for a Matrix