Split Roots into Roots.Simple and Roots.Fast.

[numerical-analysis.git] / src / Roots / Simple.hs

diff --git a/src/Roots.hs b/src/Roots/Simple.hs
similarity index 61%
rename from src/Roots.hs
rename to src/Roots/Simple.hs
index a8c3c76bdb470e82e291aa2a916fbf632521ef5f..64124a876bfc24d3ff55b15eca29cc9d76dfe613 100644 (file)
--- a/src/Roots.hs
+++ b/src/Roots/Simple.hs
@@ -1,14 +1,16 @@
--- | The Roots module contains root-finding algorithms. That is,
---   procedures to (numerically) find solutions to the equation,
+-- | The Roots.Simple module contains root-finding algorithms. That
+--   is, procedures to (numerically) find solutions to the equation,
 --
 --   > f(x) = 0
 --
 --   where f is assumed to be continuous on the interval of interest.
 --
 
-module Roots
+module Roots.Simple
 where
 
+import qualified Roots.Fast as F
+
 
 -- | 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
@@ -37,23 +39,8 @@ has_root :: (Fractional a, Ord a, Ord b, Num b)
                    --   we'll examine, @epsilon@
          -> Bool
 has_root f a b epsilon =
-  if not ((signum (f a)) * (signum (f b)) == 1) then
-    -- We don't care about epsilon here, there's definitely a root!
-    True
-  else
-    if (b - a) <= epsilon' then
-      -- Give up, return false.
-      False
-    else
-      -- If either [a,c] or [c,b] have roots, we do too.
-      (has_root f a c (Just epsilon')) || (has_root f c b (Just epsilon'))
-  where
-    -- If the size of the smallest subinterval is not specified,
-    -- assume we just want to check once on all of [a,b].
-    epsilon' = case epsilon of
-                 Nothing -> (b-a)
-                 Just eps -> eps
-    c = (a + b)/2
+  F.has_root f a b epsilon Nothing Nothing
+
 
 
 
@@ -82,16 +69,5 @@ bisect :: (Fractional a, Ord a, Num b, Ord b)
        -> a       -- ^ The \"right\" endpoint of the interval, @b@
        -> a       -- ^ The tolerance, @epsilon@
        -> Maybe a
-bisect f a b epsilon
-  -- We pass @epsilon@ to the 'has_root' function because if we want a
-  -- result within epsilon of the true root, we need to know that
-  -- there *is* a root within an interval of length epsilon.
-  | not (has_root f a b (Just epsilon)) = Nothing
-  | f a == 0 = Just a
-  | f b == 0 = Just b
-  | (b - c) < epsilon = Just c
-  | otherwise =
-      if (has_root f a c (Just epsilon)) then bisect f a c epsilon
-      else bisect f c b epsilon
-  where
-    c = (a + b) / 2
+bisect f a b epsilon =
+  F.bisect f a b epsilon Nothing Nothing