import Data.Vector.Fixed (
(!),
- N1,
- N2,
- N3,
- N4,
- N5,
- S,
- Z,
generate,
mk1,
mk2,
toList,
zipWith )
import Data.Vector.Fixed.Cont ( Arity, arity )
-import Linear.Vector ( Vec, delete, element_sum )
+import Linear.Vector ( Vec, delete )
+import Naturals ( N1, N2, N3, N4, N5, N6, N7, N8, N9, N10, S, Z )
import Normed ( Normed(..) )
import NumericPrelude hiding ( (*), abs )
type Col3 a = Col N3 a
type Col4 a = Col N4 a
type Col5 a = Col N5 a
-
--- We need a big column for Gaussian quadrature.
-type N10 = S (S (S (S (S N5))))
-type Col10 a = Col N10 a
+type Col6 a = Col N6 a
+type Col7 a = Col N7 a
+type Col8 a = Col N8 a
+type Col9 a = Col N9 a
+type Col10 a = Col N10 a -- We need a big column for Gaussian quadrature.
instance (Eq a) => Eq (Mat m n a) where
-- >>> 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]
--
infixl 7 *
(*) :: (Ring.C a, Arity m, Arity n, Arity p)
- => Mat m n a
- -> Mat n p a
- -> Mat m p a
+ => Mat (S m) (S n) a
+ -> Mat (S n) (S p) a
+ -> Mat (S m) (S p) a
(*) m1 m2 = construct lambda
where
- lambda i j =
- sum [(m1 !!! (i,k)) NP.* (m2 !!! (k,j)) | k <- [0..(ncols m1)-1] ]
+ lambda i j = (transpose $ row m1 i) `dot` (column m2 j)
zero = Mat (V.replicate $ V.replicate (fromInteger 0))
-instance (Ring.C a, Arity m, Arity n, m ~ n) => Ring.C (Mat m n a) where
+instance (Ring.C a, Arity m, Arity n, m ~ n) => Ring.C (Mat (S m) (S n) a) where
-- The first * is ring multiplication, the second is matrix
-- multiplication.
m1 * m2 = m1 * m2
x *> (Mat rows) = Mat $ V.map (V.map (NP.* x)) rows
-instance (Algebraic.C a,
+instance (Absolute.C a,
+ Algebraic.C a,
ToRational.C a,
Arity m)
- => Normed (Mat (S m) N1 a) where
- -- | Generic p-norms for vectors in R^n that are represented as nx1
+ => Normed (Col (S m) a) where
+ -- | Generic p-norms for vectors in R^n that are represented as n-by-1
-- matrices.
--
-- Examples:
-- >>> norm_p 2 v1
-- 5.0
--
+ -- >>> let v1 = vec2d (-1,1) :: Col2 Double
+ -- >>> norm_p 1 v1 :: Double
+ -- 2.0
+ --
norm_p p (Mat rows) =
- (root p') $ sum [fromRational' (toRational x)^p' | x <- xs]
+ (root p') $ sum [fromRational' (toRational $ abs x)^p' | x <- xs]
where
p' = toInteger p
xs = concat $ V.toList $ V.map V.toList rows
-- >>> 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
+frobenius_norm :: (Arity m, Arity n, Algebraic.C a, Ring.C a)
+ => Mat m n a
+ -> a
+frobenius_norm matrix =
+ sqrt $ element_sum2 $ squares
where
- -- | Square and add up the entries of a row.
- row_sum = element_sum . V.map (^2)
+ squares = map2 (^2) matrix
-- Vector helpers. We want it to be easy to create low-dimension
vec5d :: (a,a,a,a,a) -> Col5 a
vec5d (v,w,x,y,z) = Mat (mk5 (mk1 v) (mk1 w) (mk1 x) (mk1 y) (mk1 z))
+
-- Since we commandeered multiplication, we need to create 1x1
-- matrices in order to multiply things.
scalar :: a -> Mat1 a
=> Col (S m) a
-> Col (S m) a
-> a
-v1 `dot` v2 = unscalar $ ((transpose v1) * v2)
+v1 `dot` v2 = element_sum2 $ zipwith2 (NP.*) v1 v2
-- | The angle between @v1@ and @v2@ in Euclidean space.
-- 15
--
trace :: (Arity m, Ring.C a) => Mat m m a -> a
-trace matrix =
- let (Mat rows) = diagonal matrix
- in
- element_sum $ V.map V.head rows
+trace = element_sum2 . diagonal
+
-- | Zip together two matrices.
-- >>> 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 :: (Arity m, Arity n) => Mat m n a -> Mat m n b -> Mat m n (a,b)
zip2 m1 m2 =
construct lambda
where
-- >>> zipwith2 (^) c1 c2
-- ((1),(32),(729))
--
-zipwith2 :: Arity m
- => (a -> a -> b)
- -> Col m a
- -> Col m a
- -> Col m b
+zipwith2 :: (Arity m, Arity n)
+ => (a -> b -> c)
+ -> Mat m n a
+ -> Mat m n b
+ -> Mat m n c
zipwith2 f c1 c2 =
construct lambda
where
row_function rowinit idx r = V.ifoldl (g idx) rowinit r
+-- | Left fold over the entries of a matrix (top-left to bottom-right).
+--
+foldl2 :: forall a b m n.
+ (b -> a -> b)
+ -> b
+ -> Mat m n a
+ -> b
+foldl2 f initial matrix =
+ -- Use the index fold but ignore the index arguments.
+ let g _ _ = f in ifoldl2 g initial matrix
+
+
-- | Fold over the entire matrix passing the coordinates @i@ and @j@
-- (of the row/column) to the accumulation function. The fold occurs
-- from bottom-right to top-left.
where
lambda i j = cofactor matrix i j
+
+
+-- | Retrieve the rows of a matrix as a column matrix. If the given
+-- matrix is m-by-n, the result would be an m-by-1 column whose
+-- entries are 1-by-n row matrices.
+--
+-- Examples:
+--
+-- >>> let m = fromList [[1,2],[3,4]] :: Mat2 Int
+-- >>> (rows2 m) !!! (0,0)
+-- ((1,2))
+-- >>> (rows2 m) !!! (1,0)
+-- ((3,4))
+--
+rows2 :: (Arity m, Arity n)
+ => Mat m n a
+ -> Col m (Row n a)
+rows2 (Mat rows) =
+ Mat $ V.map (mk1. Mat . mk1) rows
+
+
+
+-- | Sum the elements of a matrix.
+--
+-- Examples:
+--
+-- >>> let m = fromList [[1,-1],[3,4]] :: Mat2 Int
+-- >>> element_sum2 m
+-- 7
+--
+element_sum2 :: (Arity m, Arity n, Additive.C a) => Mat m n a -> a
+element_sum2 = foldl2 (+) zero
projects / numerical-analysis.git / blobdiff