Clean up imports everywhere.

[numerical-analysis.git] / src / Linear / System.hs

diff --git a/src/Linear/System.hs b/src/Linear/System.hs
index e0fdf1ce8e15d58ccc32314c7d08135b2f517279..2d75f611de1dc85825677ce59e72fe008bdbd21d 100644 (file)
--- a/src/Linear/System.hs
+++ b/src/Linear/System.hs
@@ -2,46 +2,47 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies #-}
 
-module Linear.System
+module Linear.System (
+  backward_substitute,
+  forward_substitute )
 where
 
-import Data.Vector.Fixed (Dim, N1, Vector)
+import Data.Vector.Fixed ( Arity, N1 )
+import NumericPrelude hiding ( (*), abs )
+import qualified NumericPrelude as NP ( (*) )
+import qualified Algebra.Field as Field ( C )
 
-import Linear.Matrix
+import Linear.Matrix ( Mat(..), (!!!), construct, transpose )
 
-import NumericPrelude hiding ((*), abs)
-import qualified NumericPrelude as NP ((*))
-import qualified Algebra.Field as Field
-
-import Debug.Trace (trace, traceShow)
 
 -- | Solve the system m' * x = b', where m' is upper-triangular. Will
 --   probably crash if m' is non-singular. The result is the vector x.
 --
 --   Examples:
 --
+--   >>> import Linear.Matrix ( Mat2, Mat3, fromList, vec2d, vec3d )
+--
 --   >>> let identity = fromList [[1,0,0],[0,1,0],[0,0,1]] :: Mat3 Double
---   >>> let b = vec3d (1,2,3)
+--   >>> let b = vec3d (1, 2, 3::Double)
 --   >>> forward_substitute identity b
 --   ((1.0),(2.0),(3.0))
 --   >>> (forward_substitute identity b) == b
 --   True
 --
 --   >>> let m = fromList [[1,0],[1,1]] :: Mat2 Double
---   >>> let b = vec2d (1,1)
+--   >>> let b = vec2d (1, 1::Double)
 --   >>> forward_substitute m b
 --   ((1.0),(0.0))
 --
-forward_substitute :: forall a v w z.
-                      (Show a, Field.C a,
-                       Vector z a,
-                       Vector w (z a),
-                       Vector w a,
-                       Dim z ~ N1,
-                       v ~ w)
-                   => Mat v w a
-                   -> Mat w z a
-                   -> Mat w z a
+--   >>> let m = fromList [[4,0],[0,2]] :: Mat2 Double
+--   >>> let b = vec2d (2, 1.5 :: Double)
+--   >>> forward_substitute m b
+--   ((0.5),(0.75))
+--
+forward_substitute :: forall a m. (Field.C a, Arity m)
+                   => Mat m m a
+                   -> Mat m N1 a
+                   -> Mat m N1 a
 forward_substitute m' b' = x'
   where
     x' = construct lambda
@@ -71,25 +72,21 @@ forward_substitute m' b' = x'
 --
 --   Examples:
 --
+--   >>> import Linear.Matrix ( Mat3, fromList, vec3d )
+--
 --   >>> let identity = fromList [[1,0,0],[0,1,0],[0,0,1]] :: Mat3 Double
---   >>> let b = vec3d (1,2,3)
+--   >>> let b = vec3d (1, 2, 3::Double)
 --   >>> backward_substitute identity b
 --   ((1.0),(2.0),(3.0))
 --   >>> (backward_substitute identity b) == b
 --   True
 --
-backward_substitute :: (Show a, Field.C a,
-                        Vector z a,
-                        Vector v (w a),
-                        Vector w (z a),
-                        Vector w a,
-                        Dim z ~ N1,
-                        v ~ w)
-                    => Mat v w a
-                    -> Mat w z a
-                    -> Mat w z a
-backward_substitute m b =
-  forward_substitute (transpose m) b
+backward_substitute :: (Field.C a, Arity m)
+                    => Mat m m a
+                    -> Mat m N1 a
+                    -> Mat m N1 a
+backward_substitute m =
+  forward_substitute (transpose m)
 
 
 -- | Solve the linear system m*x = b where m is positive definite.