Added 'Muller' method

cfgnunes · cfgnunes · commit ed335f9f31d4 · 2023-03-24T22:46:08.000-03:00
diff --git a/README.md b/README.md
@@ -43,8 +43,9 @@ python3 main.py
 
 - Bisection method
 - Secant method
-- Regula Falsi (False Position)
-- Pegasus
+- Regula Falsi method (False Position)
+- Pegasus method
+- Muller method
 - Newton method
 
 ### Interpolation
diff --git a/main.py b/main.py
@@ -154,6 +154,32 @@ def f(x):
     print(f"\tconverged = {converged}")
 
 
+@print_docstring
+def run_example_muller():
+    """Run an example 'Solutions: Muller'."""
+
+    def f(x):
+        return 2 * x ** 3 - math.cos(x + 1) - 3
+
+    a = -1.0
+    b = 2.0
+    toler = 0.01
+    iter_max = 100
+
+    print("Input:")
+    print(f"\ta = {a}")
+    print(f"\tb = {b}")
+    print(f"\ttoler = {toler}")
+    print(f"\titer_max = {iter_max}")
+
+    [root, i, converged] = solutions.muller(f, a, b, toler, iter_max)
+
+    print("Output:")
+    print(f"\troot = {root:.5f}")
+    print(f"\ti = {i}")
+    print(f"\tconverged = {converged}")
+
+
 @print_docstring
 def run_example_newton():
     """Run an example 'Solutions: Newton'."""
@@ -626,6 +652,7 @@ def main():
     run_example_secant()
     run_example_regula_falsi()
     run_example_pegasus()
+    run_example_muller()
     run_example_newton()
     run_example_lagrange()
     run_example_neville()
diff --git a/solutions.py b/solutions.py
@@ -202,6 +202,69 @@ def pegasus(f, a, b, toler, iter_max):
     return [root, i, converged]
 
 
+def muller(f, a, c, toler, iter_max):
+    """Calculate the root of an equation by the Muller method.
+
+    Args:
+        f: function f(x).
+        a: lower limit.
+        c: upper limit.
+        toler: tolerance (stopping criterion).
+        iter_max: maximum number of iterations (stopping criterion).
+
+    Returns:
+        root: root value.
+        iter: number of iterations used by the method.
+        converged: flag to indicate if the root was found.
+    """
+    b = (a + c) / 2
+    fa = f(a)
+    fb = f(b)
+    fc = f(c)
+    x = b
+    fx = fb
+    delta_x = c - a
+
+    converged = False
+    for i in range(0, iter_max + 1):
+        h1 = c - b
+        h2 = b - a
+        r = h1 / h2
+        t = x
+
+        aa = (fc - (r + 1) * fb + r * fa) / (h1 * (h1 + h2))
+        bb = (fc - fb) / h1 - aa * h1
+        cc = fb
+
+        signal_bb = int(math.copysign(1, bb))
+
+        z = (-bb + signal_bb * math.sqrt(bb ** 2 - 4 * aa * cc)) / (2 * aa)
+        x = b + z
+
+        delta_x = x - t
+        fx = f(x)
+
+        print(f"i = {i:03d},\tx = {x:+.4f},\t", end="")
+        print(f"fx = {fx:+.4f},\tdx = {delta_x:+.4f}")
+
+        if math.fabs(delta_x) <= toler and math.fabs(fx) <= toler:
+            converged = True
+            break
+
+        if x > b:
+            a = b
+            fa = fb
+        else:
+            c = b
+            fc = fb
+
+        b = x
+        fb = fx
+
+    root = x
+    return [root, i, converged]
+
+
 def newton(f, df, x0, toler, iter_max):
     """Calculate the root of an equation by the Newton method.
 
