MathObj.Matrix

Routines and abstractions for Matrices and basic linear algebra over fields or rings.

We stick to simple Int indices. Although advanced indices would be nice e.g. for matrices with sub-matrices, this is not easily implemented since arrays do only support a lower and an upper bound but no additional parameters.

ToDo: - Matrix inverse, determinant (see htam:Matrix)

Documentation

data T a

A matrix is a twodimensional array, indexed by integers.

Instances

Functor T

Defined in MathObj.Matrix

Methods

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

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

C T

Defined in MathObj.Matrix

Methods

zero :: C a => T a

(<+>) :: C a => T a -> T a -> T a

(*>) :: C a => a -> T a -> T a

C a b => C a (T b)

Defined in MathObj.Matrix

Methods

(*>) :: a -> T b -> T b

Eq a => Eq (T a)

Defined in MathObj.Matrix

Methods

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

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

Ord a => Ord (T a)

Defined in MathObj.Matrix

Methods

compare :: T a -> T a -> Ordering

(<) :: T a -> T a -> Bool

(<=) :: T a -> T a -> Bool

(>) :: T a -> T a -> Bool

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

max :: T a -> T a -> T a

min :: T a -> T a -> T a

Read a => Read (T a)

Defined in MathObj.Matrix

Methods

readsPrec :: Int -> ReadS (T a)

readList :: ReadS [T a]

readPrec :: ReadPrec (T a)

readListPrec :: ReadPrec [T a]

Show a => Show (T a)

Defined in MathObj.Matrix

Methods

showsPrec :: Int -> T a -> ShowS

show :: T a -> String

showList :: [T a] -> ShowS

C a => C (T a)

genIntMatrix /\ \a -> genSameMatrix a /\ \b -> Laws.commutative (+) a b

genIntMatrix /\ \a -> genSameMatrix a /\ \b -> genSameMatrix b /\ \c -> Laws.associative (+) a b c

Defined in MathObj.Matrix

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

genIntMatrix /\ \a -> Laws.leftIdentity  (*) (Matrix.one (Matrix.numRows a)) a

genIntMatrix /\ \a -> Laws.rightIdentity (*) (Matrix.one (Matrix.numColumns a)) a

genIntMatrix /\ \a -> genFactorMatrix a /\ \b -> Laws.homomorphism Matrix.transpose (*) (flip (*)) a b

genIntMatrix /\ \a -> genFactorMatrix a /\ \b -> genFactorMatrix b /\ \c -> Laws.associative (*) a b c

genIntMatrix /\ \b -> genSameMatrix b /\ \c -> genFactorMatrix b /\ \a -> Laws.leftDistributive (*) (+) a b c

genIntMatrix /\ \a -> genFactorMatrix a /\ \b -> genSameMatrix b /\ \c -> Laws.rightDistributive (*) (+) a b c

QC.choose (0,10) /\ \k -> genDimension /\ \n -> genMatrixFor n n /\ \a -> a^k == nest (fromInteger k) ((a::Matrix.T Integer)*) (Matrix.one n)

Defined in MathObj.Matrix

Methods

(*) :: T a -> T a -> T a

one :: T a

fromInteger :: Integer -> T a

(^) :: T a -> Integer -> T a

type Dimension = Int

format :: Show a => T a -> String

transpose :: T a -> T a

Transposition of matrices is just transposition in the sense of Data.List.

genIntMatrix /\ \a -> Matrix.rows a == Matrix.columns (Matrix.transpose a)

genIntMatrix /\ \a -> Matrix.columns a == Matrix.rows (Matrix.transpose a)

genIntMatrix /\ \a -> genSameMatrix a /\ \b -> Laws.homomorphism Matrix.transpose (+) (+) a b

rows :: T a -> [[a]]

columns :: T a -> [[a]]

index :: T a -> Dimension -> Dimension -> a

fromRows :: Dimension -> Dimension -> [[a]] -> T a

genIntMatrix /\ \a -> a == uncurry Matrix.fromRows (Matrix.dimension a) (Matrix.rows a)

fromColumns :: Dimension -> Dimension -> [[a]] -> T a

genIntMatrix /\ \a -> a == uncurry Matrix.fromColumns (Matrix.dimension a) (Matrix.columns a)

fromList :: Dimension -> Dimension -> [a] -> T a

dimension :: T a -> (Dimension, Dimension)

numRows :: T a -> Dimension

numColumns :: T a -> Dimension

zipWith :: (a -> b -> c) -> T a -> T b -> T c

zero :: C a => Dimension -> Dimension -> T a

genIntMatrix /\ \a -> Laws.identity (+) (uncurry Matrix.zero $ Matrix.dimension a) a

one :: C a => Dimension -> T a

diagonal :: C a => [a] -> T a

genDimension /\ \n -> Matrix.one n == Matrix.diagonal (replicate n Ring.one :: [Integer])

scale :: C a => a -> T a -> T a

random :: (RandomGen g, Random a) => Dimension -> Dimension -> g -> (T a, g)

randomR :: (RandomGen g, Random a) => Dimension -> Dimension -> (a, a) -> g -> (T a, g)