X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=src%2FLinear%2FMatrix.hs;h=4d1dceb417c07e63992ec7afefd981a23d484c39;hb=3c226d5d5ceb0781b10d86dcb958846f1cc9b075;hp=dd89a9ff3f091490c3d1587b2839c338ec495468;hpb=4b7a8137a75e9fe186d1eb8976f7a47e82afc12b;p=numerical-analysis.git

diff --git a/src/Linear/Matrix.hs b/src/Linear/Matrix.hs
index dd89a9f..4d1dceb 100644
--- a/src/Linear/Matrix.hs
+++ b/src/Linear/Matrix.hs
@@ -31,16 +31,17 @@ import Data.Vector.Fixed (
   mk2,
   mk3,
   mk4,
-  mk5
-  )
+  mk5 )
 import qualified Data.Vector.Fixed as V (
   and,
   fromList,
   head,
-  length,
+  ifoldl,
+  imap,
   map,
   maximum,
   replicate,
+  reverse,
   toList,
   zipWith )
 import Data.Vector.Fixed.Cont ( Arity, arity )
@@ -144,67 +145,85 @@ instance (Show a) => Show (Mat m n a) where
 toList :: Mat m n a -> [[a]]
 toList (Mat rows) = map V.toList (V.toList rows)
 
+
 -- | Create a matrix from a nested list.
 fromList :: (Arity m, Arity n) => [[a]] -> Mat m n a
 fromList vs = Mat (V.fromList $ map V.fromList vs)
 
 
--- | Unsafe indexing.
+-- | Unsafe indexing. Much faster than the safe indexing.
 (!!!) :: (Arity m, Arity n) => Mat m n a -> (Int, Int) -> a
-(!!!) m (i, j) = (row m i) ! j
+(!!!) (Mat rows) (i, j) = (rows ! i) ! j
+
 
 -- | Safe indexing.
-(!!?) :: Mat m n a -> (Int, Int) -> Maybe a
-(!!?) m@(Mat rows) (i, j)
-  | i < 0 || j < 0 = Nothing
-  | i > V.length rows = Nothing
-  | otherwise = if j > V.length (row m j)
-                then Nothing
-                else Just $ (row m j) ! j
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,2],[3,4]] :: Mat2 Int
+--   >>> m !!? (-1,-1)
+--   Nothing
+--   >>>  m !!? (-1,0)
+--   Nothing
+--   >>>  m !!? (-1,1)
+--   Nothing
+--   >>>  m !!? (0,-1)
+--   Nothing
+--   >>>  m !!? (0,0)
+--   Just 1
+--   >>>  m !!? (0,1)
+--   Just 2
+--   >>>  m !!? (1,-1)
+--   Nothing
+--   >>>  m !!? (1,0)
+--   Just 3
+--   >>>  m !!? (1,1)
+--   Just 4
+--   >>>  m !!? (2,-1)
+--   Nothing
+--   >>>  m !!? (2,0)
+--   Nothing
+--   >>>  m !!? (2,1)
+--   Nothing
+--   >>>  m !!? (2,2)
+--   Nothing
+--
+(!!?) :: (Arity m, Arity n) => Mat m n a -> (Int, Int) -> Maybe a
+(!!?) matrix idx =
+  ifoldl2 f Nothing matrix
+  where
+    f k l found cur = if (k,l) == idx then (Just cur) else found
 
 
 -- | The number of rows in the matrix.
 nrows :: forall m n a. (Arity m) => Mat m n a -> Int
 nrows _ = arity (undefined :: m)
 
+
 -- | The number of columns in the first row of the
 --   matrix. Implementation stolen from Data.Vector.Fixed.length.
 ncols :: forall m n a. (Arity n) => Mat m n a -> Int
 ncols _ = arity (undefined :: n)
 
 
--- | Return the @i@th row of @m@. Unsafe.
-row :: Mat m n a -> Int -> (Vec n a)
-row (Mat rows) i = rows ! i
-
-
 -- | Return the @i@th row of @m@ as a matrix. Unsafe.
-row' :: (Arity m, Arity n) => Mat m n a -> Int -> Row n a
-row' m i =
+row :: (Arity m, Arity n) => Mat m n a -> Int -> Row n a
+row m i =
   construct lambda
   where
     lambda _ j = m !!! (i, j)
 
 
--- | Return the @j@th column of @m@. Unsafe.
-column :: Mat m n a -> Int -> (Vec m a)
-column (Mat rows) j =
-  V.map (element j) rows
-  where
-    element = flip (!)
-
-
 -- | Return the @j@th column of @m@ as a matrix. Unsafe.
-column' :: (Arity m, Arity n) => Mat m n a -> Int -> Col m a
-column' m j =
+column :: (Arity m, Arity n) => Mat m n a -> Int -> Col m a
+column m j =
   construct lambda
   where
     lambda i _ = m !!! (i, j)
 
 
 -- | Transpose @m@; switch it's columns and its rows. This is a dirty
---   implementation.. it would be a little cleaner to use imap, but it
---   doesn't seem to work.
+--   implementation, but I don't see a better way.
 --
 --   TODO: Don't cheat with fromList.
 --
@@ -215,9 +234,10 @@ column' m j =
 --   ((1,3),(2,4))
 --
 transpose :: (Arity m, Arity n) => Mat m n a -> Mat n m a
-transpose m = Mat $ V.fromList column_list
+transpose matrix =
+  construct lambda
   where
-    column_list = [ column m i | i <- [0..(ncols m)-1] ]
+    lambda i j = matrix !!! (j,i)
 
 
 -- | Is @m@ symmetric?
@@ -269,6 +289,7 @@ 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
 --   values on the diagonal of @r@ positive.
@@ -276,10 +297,34 @@ identity_matrix =
 --   Examples:
 --
 --   >>> let m1 = fromList [[20,-1], [-1,20]] :: Mat2 Double
---   >>> cholesky m1
---   ((4.47213595499958,-0.22360679774997896),(0.0,4.466542286825459))
---   >>> (transpose (cholesky m1)) * (cholesky m1)
---   ((20.000000000000004,-1.0),(-1.0,20.0))
+--   >>> let r = cholesky m1
+--   >>> frobenius_norm ((transpose r)*r - m1) < 1e-10
+--   True
+--   >>> is_upper_triangular r
+--   True
+--
+--   >>> import Naturals ( N7 )
+--   >>> let k1 = [6, -3, 0, 0, 0, 0, 0] :: [Double]
+--   >>> let k2 = [-3, 10.5, -7.5, 0, 0, 0, 0] :: [Double]
+--   >>> let k3 = [0, -7.5, 12.5, 0, 0, 0, 0] :: [Double]
+--   >>> let k4 = [0, 0, 0, 6, 0, 0, 0] :: [Double]
+--   >>> let k5 = [0, 0, 0, 0, 6, 0, 0] :: [Double]
+--   >>> let k6 = [0, 0, 0, 0, 0, 6, 0] :: [Double]
+--   >>> let k7 = [0, 0, 0, 0, 0, 0, 15] :: [Double]
+--   >>> let big_K = fromList [k1,k2,k3,k4,k5,k6,k7] :: Mat N7 N7 Double
+--
+--   >>> let e1 = [2.449489742783178,0,0,0,0,0,0] :: [Double]
+--   >>> let e2 = [-1.224744871391589,3,0,0,0,0,0] :: [Double]
+--   >>> let e3 = [0,-5/2,5/2,0,0,0,0] :: [Double]
+--   >>> let e4 = [0,0,0,2.449489742783178,0,0,0] :: [Double]
+--   >>> let e5 = [0,0,0,0,2.449489742783178,0,0] :: [Double]
+--   >>> let e6 = [0,0,0,0,0,2.449489742783178,0] :: [Double]
+--   >>> let e7 = [0,0,0,0,0,0,3.872983346207417] :: [Double]
+--   >>> let expected = fromList [e1,e2,e3,e4,e5,e6,e7] :: Mat N7 N7 Double
+--
+--   >>> let r = cholesky big_K
+--   >>> frobenius_norm (r - (transpose expected)) < 1e-12
+--   True
 --
 cholesky :: forall m n a. (Algebraic.C a, Arity m, Arity n)
          => (Mat m n a) -> (Mat m n a)
@@ -304,29 +349,26 @@ cholesky m = construct r
 --   >>> is_upper_triangular' 1e-10 m
 --   True
 --
---   TODO:
---
---     1. Don't cheat with lists.
---
-is_upper_triangular' :: (Ord a, Ring.C a, Absolute.C a, Arity m, Arity n)
+is_upper_triangular' :: forall m n a.
+                        (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
+is_upper_triangular' epsilon matrix =
+  ifoldl2 f True matrix
   where
-    results = [[ test i j | i <- [0..(nrows m)-1]] | j <- [0..(ncols m)-1] ]
-
-    test :: Int -> Int -> Bool
-    test i j
+    f :: Int -> Int -> Bool -> a -> Bool
+    f _ _ False _ = False
+    f i j True x
       | i <= j = True
       -- use "less than or equal to" so zero is a valid epsilon
-      | otherwise = abs (m !!! (i,j)) <= epsilon
+      | otherwise = abs x <= epsilon
 
 
 -- | Returns True if the given matrix is upper-triangular, and False
---   otherwise. A specialized version of 'is_upper_triangular\'' with
---   @epsilon = 0@.
+--   otherwise. We don't delegate to the general
+--   'is_upper_triangular'' here because it imposes additional
+--   typeclass constraints throughout the library.
 --
 --   Examples:
 --
@@ -338,18 +380,22 @@ is_upper_triangular' epsilon m =
 --   >>> 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)
+is_upper_triangular :: forall m n a.
+                       (Eq a, Ring.C a, Arity m, Arity n)
                     => Mat m n a -> Bool
-is_upper_triangular = is_upper_triangular' 0
+is_upper_triangular matrix =
+  ifoldl2 f True matrix
+  where
+    f :: Int -> Int -> Bool -> a -> Bool
+    f _ _ False _ = False
+    f i j True x
+      | i <= j = True
+      | otherwise = x == 0
+
 
 
 -- | Returns True if the given matrix is lower-triangular, and False
---   otherwise. This is a specialized version of 'is_lower_triangular\''
---   with @epsilon = 0@.
+--   otherwise.
 --
 --   Examples:
 --
@@ -361,9 +407,8 @@ is_upper_triangular = is_upper_triangular' 0
 --   >>> is_lower_triangular m
 --   False
 --
-is_lower_triangular :: (Ord a,
+is_lower_triangular :: (Eq a,
                         Ring.C a,
-                        Absolute.C a,
                         Arity m,
                         Arity n)
                     => Mat m n a
@@ -617,11 +662,16 @@ vec5d (v,w,x,y,z) = Mat (mk5 (mk1 v) (mk1 w) (mk1 x) (mk1 y) (mk1 z))
 scalar :: a -> Mat1 a
 scalar x = Mat (mk1 (mk1 x))
 
-dot :: (RealRing.C a, n ~ N1, m ~ S t, Arity t)
-       => Mat m n a
-       -> Mat m n a
+-- Get the scalar value out of a 1x1 matrix.
+unscalar :: Mat1 a -> a
+unscalar (Mat rows) = V.head $ V.head rows
+
+
+dot :: (Ring.C a, Arity m)
+       => Col (S m) a
+       -> Col (S m) a
        -> a
-v1 `dot` v2 = ((transpose v1) * v2) !!! (0, 0)
+v1 `dot` v2 = unscalar $ ((transpose v1) * v2)
 
 
 -- | The angle between @v1@ and @v2@ in Euclidean space.
@@ -635,12 +685,11 @@ v1 `dot` v2 = ((transpose v1) * v2) !!! (0, 0)
 --
 angle :: (Transcendental.C a,
           RealRing.C a,
-          n ~ N1,
           m ~ S t,
           Arity t,
           ToRational.C a)
-          => Mat m n a
-          -> Mat m n a
+          => Col m a
+          -> Col m a
           -> a
 angle v1 v2 =
   acos theta
@@ -774,37 +823,73 @@ trace matrix =
     element_sum $ V.map V.head rows
 
 
--- | Zip together two column matrices.
+-- | Zip together two matrices.
+--
+--   TODO: don't cheat with construct (map V.zips instead).
 --
 --   Examples:
 --
 --   >>> let m1 = fromList [[1],[1],[1]] :: Col3 Int
 --   >>> let m2 = fromList [[1],[2],[3]] :: Col3 Int
---   >>> colzip m1 m2
+--   >>> zip2 m1 m2
 --   (((1,1)),((1,2)),((1,3)))
 --
-colzip :: Arity m => Col m a -> Col m a -> Col m (a,a)
-colzip c1 c2 =
+--   >>> let m1 = fromList [[1,2],[3,4]] :: Mat2 Int
+--   >>> let m2 = fromList [[1,1],[1,1]] :: Mat2 Int
+--   >>> zip2 m1 m2
+--   (((1,1),(2,1)),((3,1),(4,1)))
+--
+zip2 :: (Arity m, Arity n) => Mat m n a -> Mat m n a -> Mat m n (a,a)
+zip2 m1 m2 =
   construct lambda
   where
-    lambda i j = (c1 !!! (i,j), c2 !!! (i,j))
+    lambda i j = (m1 !!! (i,j), m2 !!! (i,j))
 
 
--- | Zip together two column matrices using the supplied function.
+-- | Zip together three matrices.
+--
+--   TODO: don't cheat with construct (map V.zips instead).
+--
+--   Examples:
+--
+--   >>> let m1 = fromList [[1],[1],[1]] :: Col3 Int
+--   >>> let m2 = fromList [[1],[2],[3]] :: Col3 Int
+--   >>> let m3 = fromList [[4],[5],[6]] :: Col3 Int
+--   >>> zip2three m1 m2 m3
+--   (((1,1,4)),((1,2,5)),((1,3,6)))
+--
+--   >>> let m1 = fromList [[1,2],[3,4]] :: Mat2 Int
+--   >>> let m2 = fromList [[1,1],[1,1]] :: Mat2 Int
+--   >>> let m3 = fromList [[8,2],[6,3]] :: Mat2 Int
+--   >>> zip2three m1 m2 m3
+--   (((1,1,8),(2,1,2)),((3,1,6),(4,1,3)))
+--
+zip2three :: (Arity m, Arity n)
+          => Mat m n a
+          -> Mat m n a
+          -> Mat m n a
+          -> Mat m n (a,a,a)
+zip2three m1 m2 m3 =
+  construct lambda
+  where
+    lambda i j = (m1 !!! (i,j), m2 !!! (i,j), m3 !!! (i,j))
+
+
+-- | Zip together two matrices using the supplied function.
 --
 --   Examples:
 --
 --   >>> let c1 = fromList [[1],[2],[3]] :: Col3 Integer
 --   >>> let c2 = fromList [[4],[5],[6]] :: Col3 Integer
---   >>> colzipwith (^) c1 c2
+--   >>> zipwith2 (^) c1 c2
 --   ((1),(32),(729))
 --
-colzipwith :: Arity m
+zipwith2 :: Arity m
            => (a -> a -> b)
            -> Col m a
            -> Col m a
            -> Col m b
-colzipwith f c1 c2 =
+zipwith2 f c1 c2 =
   construct lambda
   where
     lambda i j = f (c1 !!! (i,j)) (c2 !!! (i,j))
@@ -815,11 +900,99 @@ colzipwith f c1 c2 =
 --   Examples:
 --
 --   >>> let m = fromList [[1,2],[3,4]] :: Mat2 Int
---   >>> matmap (^2) m
+--   >>> map2 (^2) m
 --   ((1,4),(9,16))
 --
-matmap :: (a -> b) -> Mat m n a -> Mat m n b
-matmap f (Mat rows) =
+map2 :: (a -> b) -> Mat m n a -> Mat m n b
+map2 f (Mat rows) =
   Mat $ V.map g rows
   where
     g = V.map f
+
+
+-- | Fold over the entire matrix passing the coordinates @i@ and @j@
+--   (of the row/column) to the accumulation function.
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,2,3],[4,5,6],[7,8,9]] :: Mat3 Int
+--   >>> ifoldl2 (\i j cur _ -> cur + i + j) 0 m
+--   18
+--
+ifoldl2 :: forall a b m n.
+           (Int -> Int -> b -> a -> b)
+        -> b
+        -> Mat m n a
+        -> b
+ifoldl2 f initial (Mat rows) =
+  V.ifoldl row_function initial rows
+  where
+    -- | The order that we need this in (so that @g idx@ makes sense)
+    --   is a little funny. So that we don't need to pass weird
+    --   functions into ifoldl2, we swap the second and third
+    --   arguments of @f@ calling the result @g@.
+    g :: Int -> b -> Int -> a -> b
+    g w x y = f w y x
+
+    row_function :: b -> Int -> Vec n a -> b
+    row_function rowinit idx r = V.ifoldl (g idx) rowinit r
+
+
+-- | Map a function over a matrix of any dimensions, passing the
+--   coordinates @i@ and @j@ to the function @f@.
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,2],[3,4]] :: Mat2 Int
+--   >>> imap2 (\i j _ -> i+j) m
+--   ((0,1),(1,2))
+--
+imap2 :: (Int -> Int -> a -> b) -> Mat m n a -> Mat m n b
+imap2 f (Mat rows) =
+  Mat $ V.imap g rows
+  where
+    g i = V.imap (f i)
+
+
+-- | Reverse the order of elements in a matrix.
+--
+--   Examples:
+--
+--   >>> let m1 = fromList [[1,2,3]] :: Row3 Int
+--   >>> reverse2 m1
+--   ((3,2,1))
+--
+--   >>> let m1 = vec3d (1,2,3 :: Int)
+--   >>> reverse2 m1
+--   ((3),(2),(1))
+--
+--   >>> let m = fromList [[1,2,3],[4,5,6],[7,8,9]] :: Mat3 Int
+--   >>> reverse2 m
+--   ((9,8,7),(6,5,4),(3,2,1))
+--
+reverse2 :: (Arity m, Arity n) => Mat m n a -> Mat m n a
+reverse2 (Mat rows) = Mat $ V.reverse $ V.map V.reverse rows
+
+
+-- | Unsafely set the (i,j) element of the given matrix.
+--
+--   Examples:
+--
+--   >>> let m = fromList [[1,2,3],[4,5,6],[7,8,9]] :: Mat3 Int
+--   >>> set_idx m (1,1) 17
+--   ((1,2,3),(4,17,6),(7,8,9))
+--
+set_idx :: forall m n a.
+           (Arity m, Arity n)
+        => Mat m n a
+        -> (Int, Int)
+        -> a
+        -> Mat m n a
+set_idx matrix (i,j) newval =
+  imap2 updater matrix
+  where
+    updater :: Int -> Int -> a -> a
+    updater k l existing =
+      if k == i && l == j
+      then newval
+      else existing