Make numbers == 3000.1.* required.

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

diff --git a/src/Roots/Simple.hs b/src/Roots/Simple.hs
index 2689163dbbe263ab0bb291958c652576a5797279..79750e8d15b9aa2f0091e903b94a17accea9b7b8 100644 (file)
--- a/src/Roots/Simple.hs
+++ b/src/Roots/Simple.hs
@@ -77,6 +77,15 @@ bisect f a b epsilon =
 
 -- | The sequence x_{n} of values obtained by applying Newton's method
 --   on the function @f@ and initial guess @x0@.
+--
+--   Examples:
+--
+--   Atkinson, p. 60.
+--   >>> let f x = x^6 - x - 1
+--   >>> let f' x = 6*x^5 - 1
+--   >>> tail $ take 4 $ newton_iterations f f' 2
+--   [1.6806282722513088,1.4307389882390624,1.2549709561094362]
+--
 newton_iterations :: (Fractional a, Ord a)
                     => (a -> a) -- ^ The function @f@ whose root we seek
                     -> (a -> a) -- ^ The derivative of @f@
@@ -92,6 +101,27 @@ newton_iterations f f' x0 =
 
 -- | Use Newton's method to find a root of @f@ near the initial guess
 --   @x0@. If your guess is bad, this will recurse forever!
+--
+--   Examples:
+--
+--   Atkinson, p. 60.
+--
+--   >>> let f x = x^6 - x - 1
+--   >>> let f' x = 6*x^5 - 1
+--   >>> let Just root = newtons_method f f' (1/1000000) 2
+--   >>> root
+--   1.1347241385002211
+--   >>> abs (f root) < 1/100000
+--   True
+--
+--   >>> import Data.Number.BigFloat
+--   >>> let eps = 1/(10^20) :: BigFloat Prec50
+--   >>> let Just root = newtons_method f f' eps 2
+--   >>> root
+--   1.13472413840151949260544605450647284028100785303643e0
+--   >>> abs (f root) < eps
+--   True
+--
 newtons_method :: (Fractional a, Ord a)
                  => (a -> a) -- ^ The function @f@ whose root we seek
                  -> (a -> a) -- ^ The derivative of @f@
@@ -180,3 +210,44 @@ secant_method f epsilon x0 x1
   = find (\x -> abs (f x) < epsilon) x_n
   where
     x_n = secant_iterations f x0 x1
+
+
+
+fixed_point_iterations :: (a -> a) -- ^ The function @f@ to iterate.
+                       -> a       -- ^ The initial value @x0@.
+                       -> [a]     -- ^ The resulting sequence of x_{n}.
+fixed_point_iterations f x0 =
+  iterate f x0
+
+
+-- | Find a fixed point of the function @f@ with the search starting
+--   at x0. This will find the first element in the chain f(x0),
+--   f(f(x0)),... such that the magnitude of the difference between it
+--   and the next element is less than epsilon.
+--
+fixed_point :: (Num a, Ord a)
+            => (a -> a) -- ^ The function @f@ to iterate.
+            -> a       -- ^ The tolerance, @epsilon@.
+            -> a       -- ^ The initial value @x0@.
+            -> a       -- ^ The fixed point.
+fixed_point f epsilon x0 =
+  fst winning_pair
+  where
+    xn = fixed_point_iterations f x0
+    xn_plus_one = tail $ fixed_point_iterations f x0
+
+    abs_diff v w =
+      abs (v - w)
+
+    -- The nth entry in this list is the absolute value of x_{n} -
+    -- x_{n+1}.
+    differences = zipWith abs_diff xn xn_plus_one
+
+    -- A list of pairs, (xn, |x_{n} - x_{n+1}|).
+    pairs = zip xn differences
+
+    -- The pair (xn, |x_{n} - x_{n+1}|) with
+    -- |x_{n} - x_{n+1}| < epsilon. The pattern match on 'Just' is
+    -- "safe" since the list is infinite. We'll succeed or loop
+    -- forever.
+    Just winning_pair = find (\(_, diff) -> diff < epsilon) pairs