Root gestion

Author: nicob-dev

FindRoots/Falsi_felix.py

@@ -0,0 +1,24 @@
+#Falsi - Félix
+
+def falsi(f, a, b, err):
+    if f(a) == 0:
+        return a
+    if f(b) == 0:
+        return b
+    if (f(a) > 0 and f(b) > 0) or (f(a) < 0 and f(b) < 0):
+        # print("coucou")
+        return None
+    new = b - f(b) * (b - a)/(f(b) - f(a))
+    while f(new) >= err:
+        if (f(new) > 0 and f(a) > 0 ) or (f(new) < 0 and f(a) < 0):
+            a = new
+        else:
+            b = new
+        new = b - f(b) * (b - a)/(f(b) - f(a))
+
+    return new
+
+if __name__ == "__main__":
+    f = lambda x : 3*x -2
+    print(falsi(f, -5, 5, 0.0000001))
+    print(falsi(lambda x : 1, -5, 5, 0.001))

FindRoots/bisection_felix.py

@@ -0,0 +1,24 @@
+#bisection - Felix
+def bisection(f, a, b, err):
+    if f(a) == 0:
+        return a
+    if f(b) == 0:
+        return b
+    mid = (b + a)/2
+    f_mid = abs(f(mid))
+    while abs(f(mid)) >= err:
+        mid = (b + a)/2
+        if (f(a) > 0 and f(b) > 0) or (f(a) < 0 and f(b) < 0):
+            return None
+        if f(mid) == 0:
+            return mid
+        if (f(mid) > 0 and f(a) > 0) or (f(mid) < 0 and f(a) < 0):
+            a = mid
+        else :
+            b = mid
+    return (a, b)
+
+if __name__ == "__main__":
+    f = lambda x : 3*x -3
+    print(bisection(f, -5, 5, 0.0000001))
+    print(bisection(lambda x : 1, -5, 5, 0.001))

FindRoots/newton_raphson_felix.py

@@ -0,0 +1,20 @@
+#newton raphson - Felix
+import numpy as np
+import bisection
+def nr(f,a, b, err):
+    bracket = bisection.bisection(f, a, b, 1)
+    if type(bracket) != tuple:
+        return bracket
+    x = (bracket[0] + bracket[1])/2
+    df = lambda x : (f(x + err) - f(x - err))/err*2
+    # print(df(x))
+    if df(x) == 0:
+        return None
+    while f(x) >= err:
+        x = x - f(x)/df(x)
+    return x
+
+if __name__ == "__main__":
+    f = lambda x : 3*x - 2
+    print(nr(f, -5, 5, 0.0000001))
+    print(nr(lambda x : 1, -5, 5, 0.001))

FindRoots/rider_felix.py

@@ -0,0 +1,30 @@
+#rider - Felix
+from math import sqrt
+def rider(f, a, b, err):
+    if f(a) == 0:
+        return a
+    if f(b) == 0:
+        return b
+    if (f(a) > 0 and f(b) > 0) or (f(a) < 0 and f(b) < 0):
+        return None
+    mid = (a + b)/2
+    if (f(a) - f(b)) > 0:
+        new = mid + (mid - a) * f(mid)/sqrt((f(mid)**2) - f(a)*f(b))
+    else :
+        new = mid - (mid - a) * f(mid)/sqrt((f(mid)**2) - f(a)*f(b))
+    while f(new) >= err:
+        if (f(new) > 0 and f(a) > 0 ) or (f(new) < 0 and f(a) < 0):
+            a = new
+        else:
+            b = new
+        if (f(a) - f(b)) > 0:
+            new = mid + (mid - a) * f(mid)/sqrt((f(mid)**2) - f(a)*f(b))
+        else :
+            new = mid - (mid - a) * f(mid)/sqrt((f(mid)**2) - f(a)*f(b))
+    return new
+
+
+if __name__ == "__main__":
+    f = lambda x : 3*x - 2
+    print(rider(f, -5, 5, 0.0000001))
+    print(rider(lambda x : 1, -5, 5, 0.001))

FindRoots/rootsearch_felix.py

@@ -0,0 +1,26 @@
+# root search - Felix
+def root(f, a, b, h):
+    """
+        f = funct
+        a = first born
+        b = last born
+        h = number of steps
+    """
+    parser = a
+    step = (b - a)/h
+    while parser <= b:
+        f_parser = f(parser)
+        f_parser_step = f(parser + step)
+        if f_parser == 0:
+            return parser
+        if f_parser_step == 0:
+            return parser + step
+        if (f_parser < 0 and f_parser_step > 0) or (f_parser > 0 and f_parser_step < 0):
+            return (parser, parser + step)
+        parser += step
+    return None
+
+if __name__ == "__main__":
+    f = lambda x : 3*x -3
+    print(root(f, -5, 5, 1000))
+    print(root(lambda x : 1, -5, 5, 1000))

FindRoots/secant_felix.py

@@ -0,0 +1,19 @@
+#secant - Felix
+def secant(f, a, b, err):
+    if f(a) == 0:
+        return a
+    if f(b) == 0:
+        return b
+    if (f(a) > 0 and f(b) > 0) or (f(a) < 0 and f(b) < 0):
+        return None
+    new = b - f(b) * (b - a)/(f(b) - f(a))
+    while f(new) >= err:
+        a = b
+        b = new
+        new = b - f(b) * (b - a)/(f(b) - f(a))
+    return new
+
+if __name__ == "__main__":
+    f = lambda x : 3*x -2
+    print(secant(f, -5, 5, 0.0000001))
+    print(secant(lambda x : 1, -5, 5, 0.001))