X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2FLinear%2FMatrix.hs;h=ea6bc5772422c620daa3057c0177a946442fc690;hb=ae914d13235a4582077a5cb2b1edd630d9c6ad62;hp=105acef6cc78a86914f66d68b158fce02c7e8eee;hpb=cc93d648089344338030a9b79cd7bea7c6e8c997;p=numerical-analysis.git

diff --git a/src/Linear/Matrix.hs b/src/Linear/Matrix.hs
index 105acef..ea6bc57 100644
--- a/src/Linear/Matrix.hs
+++ b/src/Linear/Matrix.hs
@@ -2,6 +2,7 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE NoMonomorphismRestriction #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE RebindableSyntax #-}
@@ -25,6 +26,7 @@ import Data.Vector.Fixed (
   N5,
   S,
   Z,
+  generate,
   mk1,
   mk2,
   mk3,
@@ -42,22 +44,23 @@ import qualified Data.Vector.Fixed as V (
   toList,
   zipWith
   )
-import Data.Vector.Fixed.Boxed (Vec)
-import Data.Vector.Fixed.Internal.Arity (Arity, arity)
-import Linear.Vector
-import Normed
-
-import NumericPrelude hiding ((*), abs)
-import qualified NumericPrelude as NP ((*))
-import qualified Algebra.Algebraic as Algebraic
-import Algebra.Algebraic (root)
-import qualified Algebra.Additive as Additive
-import qualified Algebra.Ring as Ring
-import qualified Algebra.Module as Module
-import qualified Algebra.RealRing as RealRing
-import qualified Algebra.ToRational as ToRational
-import qualified Algebra.Transcendental as Transcendental
-import qualified Prelude as P
+import Data.Vector.Fixed.Cont ( Arity, arity )
+import Linear.Vector ( Vec, delete, element_sum )
+import Normed ( Normed(..) )
+
+import NumericPrelude hiding ( (*), abs )
+import qualified NumericPrelude as NP ( (*) )
+import qualified Algebra.Absolute as Absolute ( C )
+import Algebra.Absolute ( abs )
+import qualified Algebra.Additive as Additive ( C )
+import qualified Algebra.Algebraic as Algebraic ( C )
+import Algebra.Algebraic ( root )
+import qualified Algebra.Ring as Ring ( C )
+import qualified Algebra.Module as Module ( C )
+import qualified Algebra.RealRing as RealRing ( C )
+import qualified Algebra.ToRational as ToRational ( C )
+import qualified Algebra.Transcendental as Transcendental ( C )
+import qualified Prelude as P ( map )
 
 data Mat m n a = (Arity m, Arity n) => Mat (Vec m (Vec n a))
 type Mat1 a = Mat N1 N1 a
@@ -198,8 +201,6 @@ symmetric m =
 --   entries in the matrix. The i,j entry of the resulting matrix will
 --   have the value returned by lambda i j.
 --
---   TODO: Don't cheat with fromList.
---
 --   Examples:
 --
 --   >>> let lambda i j = i + j
@@ -208,14 +209,24 @@ symmetric m =
 --
 construct :: forall m n a. (Arity m, Arity n)
           => (Int -> Int -> a) -> Mat m n a
-construct lambda = Mat rows
+construct lambda = Mat $ generate make_row
   where
-    -- The arity trick is used in Data.Vector.Fixed.length.
-    imax = (arity (undefined :: m)) - 1
-    jmax = (arity (undefined :: n)) - 1
-    row' i = V.fromList [ lambda i j | j <- [0..jmax] ]
-    rows = V.fromList [ row' i | i <- [0..imax] ]
+    make_row :: Int -> Vec n a
+    make_row i = generate (lambda i)
+
 
+-- | Create an identity matrix with the right dimensions.
+--
+--   Examples:
+--
+--   >>> identity_matrix :: Mat3 Int
+--   ((1,0,0),(0,1,0),(0,0,1))
+--   >>> identity_matrix :: Mat3 Double
+--   ((1.0,0.0,0.0),(0.0,1.0,0.0),(0.0,0.0,1.0))
+--
+identity_matrix :: (Arity m, Ring.C a) => Mat m m a
+identity_matrix =
+  construct (\i j -> if i == j then (fromInteger 1) else (fromInteger 0))
 
 -- | Given a positive-definite matrix @m@, computes the
 --   upper-triangular matrix @r@ with (transpose r)*r == m and all
@@ -241,21 +252,26 @@ cholesky m = construct r
 
 
 -- | Returns True if the given matrix is upper-triangular, and False
---   otherwise.
+--   otherwise. The parameter @epsilon@ lets the caller choose a
+--   tolerance.
 --
 --   Examples:
 --
---   >>> let m = fromList [[1,0],[1,1]] :: Mat2 Int
+--   >>> let m = fromList [[1,1],[1e-12,1]] :: Mat2 Double
 --   >>> is_upper_triangular m
 --   False
---
---   >>> let m = fromList [[1,2],[0,3]] :: Mat2 Int
---   >>> is_upper_triangular m
+--   >>> is_upper_triangular' 1e-10 m
 --   True
 --
-is_upper_triangular :: (Eq a, Ring.C a, Arity m, Arity n)
-                    => Mat m n a -> Bool
-is_upper_triangular m =
+--   TODO:
+--
+--     1. Don't cheat with lists.
+--
+is_upper_triangular' :: (Ord a, Ring.C a, Absolute.C a, Arity m, Arity n)
+                    => a -- ^ The tolerance @epsilon@.
+                    -> Mat m n a
+                    -> Bool
+is_upper_triangular' epsilon m =
   and $ concat results
   where
     results = [[ test i j | i <- [0..(nrows m)-1]] | j <- [0..(ncols m)-1] ]
@@ -263,11 +279,36 @@ is_upper_triangular m =
     test :: Int -> Int -> Bool
     test i j
       | i <= j = True
-      | otherwise = m !!! (i,j) == 0
+      -- use "less than or equal to" so zero is a valid epsilon
+      | otherwise = abs (m !!! (i,j)) <= epsilon
+
+
+-- | Returns True if the given matrix is upper-triangular, and False
+--   otherwise. A specialized version of 'is_upper_triangular\'' with
+--   @epsilon = 0@.
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,0],[1,1]] :: Mat2 Int
+--   >>> is_upper_triangular m
+--   False
+--
+--   >>> let m = fromList [[1,2],[0,3]] :: Mat2 Int
+--   >>> is_upper_triangular m
+--   True
+--
+--   TODO:
+--
+--     1. The Ord constraint is too strong here, Eq would suffice.
+--
+is_upper_triangular :: (Ord a, Ring.C a, Absolute.C a, Arity m, Arity n)
+                    => Mat m n a -> Bool
+is_upper_triangular = is_upper_triangular' 0
 
 
 -- | Returns True if the given matrix is lower-triangular, and False
---   otherwise.
+--   otherwise. This is a specialized version of 'is_lower_triangular\''
+--   with @epsilon = 0@.
 --
 --   Examples:
 --
@@ -279,8 +320,9 @@ is_upper_triangular m =
 --   >>> is_lower_triangular m
 --   False
 --
-is_lower_triangular :: (Eq a,
+is_lower_triangular :: (Ord a,
                         Ring.C a,
+                        Absolute.C a,
                         Arity m,
                         Arity n)
                     => Mat m n a
@@ -288,6 +330,29 @@ is_lower_triangular :: (Eq a,
 is_lower_triangular = is_upper_triangular . transpose
 
 
+-- | Returns True if the given matrix is lower-triangular, and False
+--   otherwise. The parameter @epsilon@ lets the caller choose a
+--   tolerance.
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,1e-12],[1,1]] :: Mat2 Double
+--   >>> is_lower_triangular m
+--   False
+--   >>> is_lower_triangular' 1e-12 m
+--   True
+--
+is_lower_triangular' :: (Ord a,
+                         Ring.C a,
+                         Absolute.C a,
+                         Arity m,
+                         Arity n)
+                    => a -- ^ The tolerance @epsilon@.
+                    -> Mat m n a
+                    -> Bool
+is_lower_triangular' epsilon = (is_upper_triangular' epsilon) . transpose
+
+
 -- | Returns True if the given matrix is triangular, and False
 --   otherwise.
 --
@@ -305,8 +370,9 @@ is_lower_triangular = is_upper_triangular . transpose
 --   >>> is_triangular m
 --   False
 --
-is_triangular :: (Eq a,
+is_triangular :: (Ord a,
                   Ring.C a,
+                  Absolute.C a,
                   Arity m,
                   Arity n)
               => Mat m n a
@@ -344,8 +410,9 @@ class (Eq a, Ring.C a) => Determined p a where
 instance (Eq a, Ring.C a) => Determined (Mat (S Z) (S Z)) a where
   determinant (Mat rows) = (V.head . V.head) rows
 
-instance (Eq a,
+instance (Ord a,
           Ring.C a,
+          Absolute.C a,
           Arity n,
           Determined (Mat (S n) (S n)) a)
          => Determined (Mat (S (S n)) (S (S n))) a where
@@ -419,8 +486,8 @@ instance (Algebraic.C a,
           ToRational.C a,
           Arity m)
          => Normed (Mat (S m) N1 a) where
-  -- | Generic p-norms. The usual norm in R^n is (norm_p 2). We treat
-  --   all matrices as big vectors.
+  -- | Generic p-norms for vectors in R^n that are represented as nx1
+  --   matrices.
   --
   --   Examples:
   --
@@ -448,7 +515,26 @@ instance (Algebraic.C a,
     fromRational' $ toRational $ V.maximum $ V.map V.maximum rows
 
 
-
+-- | Compute the Frobenius norm of a matrix. This essentially treats
+--   the matrix as one long vector containing all of its entries (in
+--   any order, it doesn't matter).
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1, 2, 3],[4,5,6],[7,8,9]] :: Mat3 Double
+--   >>> frobenius_norm m == sqrt 285
+--   True
+--
+--   >>> let m = fromList [[1, -1, 1],[-1,1,-1],[1,-1,1]] :: Mat3 Double
+--   >>> frobenius_norm m == 3
+--   True
+--
+frobenius_norm :: (Algebraic.C a, Ring.C a) => Mat m n a -> a
+frobenius_norm (Mat rows) =
+  sqrt $ element_sum $ V.map row_sum rows
+  where
+    -- | Square and add up the entries of a row.
+    row_sum = element_sum . V.map (^2)
 
 
 -- Vector helpers. We want it to be easy to create low-dimension
@@ -530,13 +616,83 @@ angle v1 v2 =
 --   Examples:
 --
 --   >>> let m = fromList [[1,2,3],[4,5,6],[7,8,9]] :: Mat3 Int
---   >>> diagonal m
+--   >>> diagonal_part m
 --   ((1,0,0),(0,5,0),(0,0,9))
 --
-diagonal :: (Arity m, Ring.C a)
+diagonal_part :: (Arity m, Ring.C a)
          => Mat m m a
          -> Mat m m a
-diagonal matrix =
+diagonal_part matrix =
   construct lambda
   where
     lambda i j = if i == j then matrix !!! (i,j) else 0
+
+
+-- | Given a square @matrix@, return a new matrix of the same size
+--   containing only the on-diagonal and below-diagonal entries of
+--   @matrix@. The above-diagonal entries are set to zero.
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,2,3],[4,5,6],[7,8,9]] :: Mat3 Int
+--   >>> lt_part m
+--   ((1,0,0),(4,5,0),(7,8,9))
+--
+lt_part :: (Arity m, Ring.C a)
+        => Mat m m a
+        -> Mat m m a
+lt_part matrix =
+  construct lambda
+  where
+    lambda i j = if i >= j then matrix !!! (i,j) else 0
+
+
+-- | Given a square @matrix@, return a new matrix of the same size
+--   containing only the below-diagonal entries of @matrix@. The on-
+--   and above-diagonal entries are set to zero.
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,2,3],[4,5,6],[7,8,9]] :: Mat3 Int
+--   >>> lt_part_strict m
+--   ((0,0,0),(4,0,0),(7,8,0))
+--
+lt_part_strict :: (Arity m, Ring.C a)
+        => Mat m m a
+        -> Mat m m a
+lt_part_strict matrix =
+  construct lambda
+  where
+    lambda i j = if i > j then matrix !!! (i,j) else 0
+
+
+-- | Given a square @matrix@, return a new matrix of the same size
+--   containing only the on-diagonal and above-diagonal entries of
+--   @matrix@. The below-diagonal entries are set to zero.
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,2,3],[4,5,6],[7,8,9]] :: Mat3 Int
+--   >>> ut_part m
+--   ((1,2,3),(0,5,6),(0,0,9))
+--
+ut_part :: (Arity m, Ring.C a)
+        => Mat m m a
+        -> Mat m m a
+ut_part = transpose . lt_part . transpose
+
+
+-- | Given a square @matrix@, return a new matrix of the same size
+--   containing only the above-diagonal entries of @matrix@. The on-
+--   and below-diagonal entries are set to zero.
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,2,3],[4,5,6],[7,8,9]] :: Mat3 Int
+--   >>> ut_part_strict m
+--   ((0,2,3),(0,0,6),(0,0,0))
+--
+ut_part_strict :: (Arity m, Ring.C a)
+        => Mat m m a
+        -> Mat m m a
+ut_part_strict = transpose . lt_part_strict . transpose