Clean up imports everywhere.

diff --git a/src/Integration/Simpson.hs b/src/Integration/Simpson.hs
index 6bfe258eb8e454b7a9dcc0c7221d4638eed3f61f..f0f57f29245db1a7db7bd10bd05a39a87c2347df 100644 (file)
--- a/src/Integration/Simpson.hs
+++ b/src/Integration/Simpson.hs
@@ -1,14 +1,17 @@
+{-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE RebindableSyntax #-}
 
-module Integration.Simpson
+module Integration.Simpson (
+  simpson,
+  simpson_1 )
 where
 
-import Misc (partition)
+import Misc ( partition )
 
-import NumericPrelude hiding (abs)
-import qualified Algebra.RealField as RealField
-import qualified Algebra.ToInteger as ToInteger
-import qualified Algebra.ToRational as ToRational
+import NumericPrelude hiding ( abs )
+import qualified Algebra.RealField as RealField ( C )
+import qualified Algebra.ToInteger as ToInteger ( C )
+import qualified Algebra.ToRational as ToRational ( C )
 
 -- | Use the Simpson's rule to numerically integrate @f@ over the
 --   interval [@a@, @b@].

diff --git a/src/Integration/Trapezoid.hs b/src/Integration/Trapezoid.hs
index 06350fcf54a70da55ac317610c1a7dca2f3b8a62..df4da781b6cea30e7fbe763ee20da9ba85549db7 100644 (file)
--- a/src/Integration/Trapezoid.hs
+++ b/src/Integration/Trapezoid.hs
@@ -1,15 +1,19 @@
+{-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE RebindableSyntax #-}
 
-module Integration.Trapezoid
+module Integration.Trapezoid (
+  trapezoid,
+  trapezoid_1 )
 where
 
-import Misc (partition)
+import Misc ( partition )
+
+import NumericPrelude hiding ( abs )
+import qualified Algebra.Field as Field ( C )
+import qualified Algebra.RealField as RealField ( C )
+import qualified Algebra.ToInteger as ToInteger ( C )
+import qualified Algebra.ToRational as ToRational ( C )
 
-import NumericPrelude hiding (abs)
-import qualified Algebra.Field as Field
-import qualified Algebra.RealField as RealField
-import qualified Algebra.ToInteger as ToInteger
-import qualified Algebra.ToRational as ToRational
 
 -- | Use the trapezoid rule to numerically integrate @f@ over the
 --   interval [@a@, @b@].

diff --git a/src/Linear/Iteration.hs b/src/Linear/Iteration.hs
index 7daf3b69b5f66c536d1a2567b7896fe54c972c57..06d30a802aa55717b6a9ec45b42c69a8b8f8b473 100644 (file)
--- a/src/Linear/Iteration.hs
+++ b/src/Linear/Iteration.hs
@@ -1,24 +1,42 @@
+{-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies #-}
 
 -- | Classical iterative methods to solve the system Ax = b.
 
-module Linear.Iteration
+module Linear.Iteration (
+  gauss_seidel_iteration,
+  gauss_seidel_iterations,
+  gauss_seidel_method,
+  jacobi_iteration,
+  jacobi_iterations,
+  jacobi_method,
+  rayleigh_quotient,
+  sor_iteration,
+  sor_iterations,
+  sor_method )
 where
 
-import Data.List (find)
-import Data.Maybe (fromJust)
-import Data.Vector.Fixed (Arity, N1, S)
-import NumericPrelude hiding ((*))
-import qualified Algebra.Algebraic as Algebraic
-import qualified Algebra.Field as Field
-import qualified Algebra.RealField as RealField
-import qualified Algebra.ToRational as ToRational
-import qualified Prelude as P
+import Data.List ( find )
+import Data.Maybe ( fromJust )
+import Data.Vector.Fixed ( Arity, N1, S )
+import NumericPrelude hiding ( (*) )
+import qualified Algebra.Algebraic as Algebraic ( C )
+import qualified Algebra.Field as Field ( C )
+import qualified Algebra.RealField as RealField ( C )
+import qualified Algebra.ToRational as ToRational ( C )
+
+import Linear.Matrix (
+  Mat(..),
+  (!!!),
+  (*),
+  diagonal_part,
+  dot,
+  lt_part_strict,
+  transpose )
+import Linear.System ( forward_substitute )
+import Normed ( Normed(..) )
 
-import Linear.Matrix
-import Linear.System
-import Normed
 
 -- | A generalized implementation for Jacobi, Gauss-Seidel, etc. All
 --   that we really need to know is how to construct the matrix M, so we
@@ -97,6 +115,8 @@ gauss_seidel_iterations matrix b =
 --
 --   Examples:
 --
+--   >>> import Linear.Matrix ( Mat2, fromList, vec2d )
+--
 --   >>> let m  = fromList [[4,2],[2,2]] :: Mat2 Double
 --   >>> let x0 = vec2d (0, 0::Double)
 --   >>> let b  = vec2d (1, 1::Double)
@@ -131,6 +151,8 @@ jacobi_iterations matrix b =
 --
 --   Examples:
 --
+--   >>> import Linear.Matrix ( Mat2, fromList, vec2d )
+--
 --   >>> let m  = fromList [[4,2],[2,2]] :: Mat2 Double
 --   >>> let x0 = vec2d (0, 0::Double)
 --   >>> let b  = vec2d (1, 1::Double)
@@ -160,6 +182,8 @@ jacobi_method =
 --
 --   Examples:
 --
+--   >>> import Linear.Matrix ( Mat2, fromList, vec2d )
+--
 --   >>> let m  = fromList [[4,2],[2,2]] :: Mat2 Double
 --   >>> let x0 = vec2d (0, 0::Double)
 --   >>> let b  = vec2d (1, 1::Double)
@@ -190,6 +214,8 @@ gauss_seidel_method =
 --
 --   Examples:
 --
+--   >>> import Linear.Matrix ( Mat2, fromList, vec2d )
+--
 --   >>> let m  = fromList [[4,2],[2,2]] :: Mat2 Double
 --   >>> let x0 = vec2d (0, 0::Double)
 --   >>> let b  = vec2d (1, 1::Double)
@@ -268,6 +294,8 @@ classical_method iterations_function matrix b x0 epsilon =
 --
 --   Examples:
 --
+--   >>> import Linear.Matrix ( Mat2, fromList, vec2d )
+--
 --   >>> let m = fromList [[3,1],[1,2]] :: Mat2 Rational
 --   >>> let v = vec2d (1, 1::Rational)
 --   >>> rayleigh_quotient m v

diff --git a/src/Linear/Matrix.hs b/src/Linear/Matrix.hs
index c6f4a83c71af1c5231113ec555fa79f2dcfcc038..ea6bc5772422c620daa3057c0177a946442fc690 100644 (file)
--- a/src/Linear/Matrix.hs
+++ b/src/Linear/Matrix.hs
@@ -44,23 +44,23 @@ import qualified Data.Vector.Fixed as V (
   toList,
   zipWith
   )
-import Data.Vector.Fixed.Cont (Arity, arity)
-import Linear.Vector
-import Normed
+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
-import qualified Algebra.Algebraic as Algebraic
-import Algebra.Algebraic (root)
-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 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

diff --git a/src/Linear/QR.hs b/src/Linear/QR.hs
index ea72958d74163c30679ce75231b5a48a8f0f45dd..283512a29494da41cb24db69ee2170cb213e53f1 100644 (file)
--- a/src/Linear/QR.hs
+++ b/src/Linear/QR.hs
@@ -12,7 +12,6 @@ import qualified Algebra.Ring as Ring ( C )
 import qualified Algebra.Algebraic as Algebraic ( C )
 import Data.Vector.Fixed ( ifoldl )
 import Data.Vector.Fixed.Cont ( Arity )
-import Debug.Trace
 import NumericPrelude hiding ( (*) )
 
 import Linear.Matrix (
@@ -98,6 +97,9 @@ givens_rotator i j xi xj =
 --   factorization. We keep the pair updated by multiplying @q@ and
 --   @r@ by the new rotator (or its transpose).
 --
+--   We do not require that the diagonal elements of R are positive,
+--   so our factorization is a little less unique than usual.
+--
 --   Examples:
 --
 --   >>> import Linear.Matrix

diff --git a/src/Linear/System.hs b/src/Linear/System.hs
index 85a1dd4b4a619affd6401a5d0e890e19ac007efc..2d75f611de1dc85825677ce59e72fe008bdbd21d 100644 (file)
--- a/src/Linear/System.hs
+++ b/src/Linear/System.hs
@@ -2,16 +2,17 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies #-}
 
-module Linear.System
+module Linear.System (
+  backward_substitute,
+  forward_substitute )
 where
 
-import Data.Vector.Fixed (Arity, N1)
+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 NumericPrelude hiding ((*), abs)
-import qualified NumericPrelude as NP ((*))
-import qualified Algebra.Field as Field
+import Linear.Matrix ( Mat(..), (!!!), construct, transpose )
 
 
 -- | Solve the system m' * x = b', where m' is upper-triangular. Will
@@ -19,6 +20,8 @@ import qualified Algebra.Field as Field
 --
 --   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::Double)
 --   >>> forward_substitute identity b
@@ -69,6 +72,8 @@ 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::Double)
 --   >>> backward_substitute identity b

diff --git a/src/Misc.hs b/src/Misc.hs
index bf8414d8e859d671e5c5c8794e63ea31680f4b0a..c81d3594fad218bd6d76d224e3aa942071c0a1cf 100644 (file)
--- a/src/Misc.hs
+++ b/src/Misc.hs
@@ -6,9 +6,9 @@ module Misc
 where
 
 import NumericPrelude
-import Algebra.Field
-import Algebra.RealRing
-import Algebra.ToInteger
+import Algebra.Field ( C )
+import Algebra.RealRing ( C )
+import Algebra.ToInteger ( C )
 
 -- | Partition the interval [@a@, @b@] into @n@ subintervals, which we
 --   then return as a list of pairs.

diff --git a/src/Normed.hs b/src/Normed.hs
index 6f34a8dca406c13393896179b6b08c023874e9a3..21c275fc8ecdecadcc849c65b45f6fe02e0c3d0d 100644 (file)
--- a/src/Normed.hs
+++ b/src/Normed.hs
@@ -10,11 +10,11 @@ import BigFloat
 
 import NumericPrelude hiding ( abs )
 import Algebra.Absolute ( abs )
-import qualified Algebra.Absolute as Absolute
-import qualified Algebra.Algebraic as Algebraic
+import qualified Algebra.Absolute as Absolute ( C )
+import qualified Algebra.Algebraic as Algebraic ( C )
 import Algebra.Algebraic ( root )
-import qualified Algebra.RealField as RealField
-import qualified Algebra.ToInteger as ToInteger
+import qualified Algebra.RealField as RealField ( C )
+import qualified Algebra.ToInteger as ToInteger ( C )
 import qualified Algebra.ToRational as ToRational ( C )
 import Data.Vector.Fixed ( S, Z )
 import qualified Data.Vector.Fixed as V (
@@ -25,11 +25,15 @@ import Data.Vector.Fixed.Boxed ( Vec )
 
 import Linear.Vector ( element_sum )
 
+
+-- | Instances of the 'Normed' class know how to compute their own
+--   p-norms for p=1,2,...,infinity.
+--
 class Normed a where
   norm_p :: (ToInteger.C c, Algebraic.C b, Absolute.C b) => c -> a -> b
   norm_infty :: (RealField.C b) => a -> b
 
-  -- | The "usual" norm. Defaults to the Euclidean norm.
+  -- | The \"usual\" norm. Defaults to the 2-norm.
   norm :: (Algebraic.C b, Absolute.C b) => a -> b
   norm = norm_p (2 :: Integer)
 

diff --git a/src/ODE/IVP.hs b/src/ODE/IVP.hs
index 615c668367bd6a26e22567ed0f70a0f90da6e7c0..6f798f46846a44ef4006145a440f87837cf0a2cc 100644 (file)
--- a/src/ODE/IVP.hs
+++ b/src/ODE/IVP.hs
@@ -9,15 +9,18 @@
 --   for x in [x0, xN].
 --
 
-module ODE.IVP
+module ODE.IVP (
+  eulers_method,
+  eulers_method1,
+  eulers_methodH )
 where
 
-import Misc (partition)
-import NumericPrelude hiding (abs)
-import qualified Algebra.Field as Field
-import qualified Algebra.ToInteger as ToInteger
-import qualified Algebra.ToRational as ToRational
-import qualified Algebra.RealField as RealField
+import Misc ( partition )
+import NumericPrelude hiding ( abs )
+import qualified Algebra.Field as Field ( C )
+import qualified Algebra.ToInteger as ToInteger ( C )
+import qualified Algebra.ToRational as ToRational ( C )
+import qualified Algebra.RealField as RealField ( C )
 
 -- | A single iteration of Euler's method over the interval
 --   [$x0$, $x0$+$h$].

diff --git a/src/Polynomials/Orthogonal.hs b/src/Polynomials/Orthogonal.hs
index 28cf41d15ce8de056d2e51895d9906b06fc6c67f..4ea0b68191d1b4bc8b717e2aa156c10e2d77cb5e 100644 (file)
--- a/src/Polynomials/Orthogonal.hs
+++ b/src/Polynomials/Orthogonal.hs
@@ -21,11 +21,12 @@
 --
 --   where w(x) is some non-negative (or non-positive) weight function.
 --
-module Polynomials.Orthogonal
+module Polynomials.Orthogonal (
+  legendre )
 where
 
 import NumericPrelude
-import qualified Algebra.RealField as RealField
+import qualified Algebra.RealField as RealField ( C )
 import qualified Prelude as P
 
 

diff --git a/src/Roots/Fast.hs b/src/Roots/Fast.hs
index 8b69786379218b12448b114d4183ca9c3ef64c5d..e5321c9fa82142c55b487104b5df1ec5d1fb9b70 100644 (file)
--- a/src/Roots/Fast.hs
+++ b/src/Roots/Fast.hs
@@ -5,20 +5,26 @@
 --   values to the next iteration of a function rather than passing
 --   the function and the points at which to (re)evaluate it.
 
-module Roots.Fast
+module Roots.Fast (
+  bisect,
+  fixed_point_iterations,
+  fixed_point_with_iterations,
+  has_root,
+  trisect )
 where
 
-import Data.List (find)
-import Data.Maybe (fromMaybe)
+import Data.List ( find )
+import Data.Maybe ( fromMaybe )
 
-import Normed
+import Normed ( Normed(..) )
+
+import NumericPrelude hiding ( abs )
+import qualified Algebra.Absolute as Absolute ( C )
+import qualified Algebra.Additive as Additive ( C )
+import qualified Algebra.Algebraic as Algebraic ( C )
+import qualified Algebra.RealRing as RealRing ( C )
+import qualified Algebra.RealField as RealField ( C )
 
-import NumericPrelude hiding (abs)
-import qualified Algebra.Absolute as Absolute
-import qualified Algebra.Additive as Additive
-import qualified Algebra.Algebraic as Algebraic
-import qualified Algebra.RealRing as RealRing
-import qualified Algebra.RealField as RealField
 
 has_root :: (RealField.C a,
              RealRing.C b,

diff --git a/src/Roots/Simple.hs b/src/Roots/Simple.hs
index 03b39aeb643de47ed6546693c26346851b80b0fc..a5924f4658d5c6ca8d15fbba6b10c24ed446566b 100644 (file)
--- a/src/Roots/Simple.hs
+++ b/src/Roots/Simple.hs
@@ -8,22 +8,34 @@
 --   where f is assumed to be continuous on the interval of interest.
 --
 
-module Roots.Simple
+module Roots.Simple (
+  bisect,
+  fixed_point,
+  fixed_point_error_ratios,
+  fixed_point_iteration_count,
+  has_root,
+  newtons_method,
+  secant_method,
+  trisect )
 where
 
 import Data.List (find)
+import NumericPrelude hiding ( abs )
+import Algebra.Absolute ( abs )
+import qualified Algebra.Additive as Additive ( C )
+import qualified Algebra.Algebraic as Algebraic ( C )
+import qualified Algebra.Field as Field ( C )
+import qualified Algebra.RealField as RealField ( C )
+import qualified Algebra.RealRing as RealRing ( C )
 
-import Normed
+import Normed ( Normed(..) )
+import qualified Roots.Fast as F (
+  bisect,
+  fixed_point_iterations,
+  fixed_point_with_iterations,
+  has_root,
+  trisect )
 
-import qualified Roots.Fast as F
-
-import NumericPrelude hiding (abs)
-import Algebra.Absolute (abs)
-import qualified Algebra.Additive as Additive
-import qualified Algebra.Algebraic as Algebraic
-import qualified Algebra.Field as Field
-import qualified Algebra.RealField as RealField
-import qualified Algebra.RealRing as RealRing
 
 -- | Does the (continuous) function @f@ have a root on the interval
 --   [a,b]? If f(a) <] 0 and f(b) ]> 0, we know that there's a root in