feat: dual numbers and finding roots of functions

.gitignore

+__pycache__/

Dual_Numbers.py

+import numpy as np
+
+
+# Classe de nombres duaux, AVEC DES TROUS.
+
+# S'initialise en écrivant par exemple:
+# u = Dual_Number( real = 2 , dual = 3) pour u = 2 + 3epsilon, ou plus simplement
+# u = Dual_Number( 2 , 3 )
+# Si u est un Dual_Number, u.r est sa partie réelle et u.d sa partie duale.
+# L'addition et la multiplication peuvent combiner des int/float avec des Dual_Numbers.
+# La soustraction et la division sont définies avec la négation simple et l'inverse multiplicatif
+# en utilisant l'addition et la multiplication. Elles peuvent donc également combiner des
+# int/floats avec des Dual_Numbers.
+
+
+class Dual_Number:
+
+    # Fonction d'initialisation de la classe.
+    def __init__(self, real=1, dual=0):
+        self.r = real
+        self.d = dual
+
+    # Fonction qui définit le string d'un nombre dual lorsqu'on le print.
+    def __str__(self):
+        if self.r == 0:
+            if self.d == 0:
+                return "0"
+            else:
+                return str(self.d) + "\u03B5"
+        elif self.d == 0:
+            return str(self.r)
+        else:
+            if self.d > 0:
+                sym = "+"
+            else:
+                sym = "-"
+            return str(self.r) + sym + str(abs(self.d)) + "\u03B5"
+
+    ############### Surcharge des opérateurs ###################
+
+    # Addition a.__add__(b)
+    def __add__(a, b):
+        # Cette partie assure que si l'on a un float ou un int, on le transforme en Dual_Number avant de faire l'opération,
+        # que l'on doit alors faire avec les nombres duaux a et b2.
+        if type(b) in [int, float]:
+            b2 = Dual_Number(real=b)
+        else:
+            b2 = b
+        # Fin de la partie pour assurer la compatibilité entre int/float et Dual_Numbers
+
+        return Dual_Number(real=a.r + b2.r, dual=a.d + b2.d)
+
+    # Addition a.__radd__(b)
+    __radd__ = __add__
+
+    # négation simple
+
+    def __neg__(a):
+        if type(a) in [int, float]:
+            return -a
+        else:
+            return Dual_Number(real=-a.r, dual=-a.d)
+
+    # soustraction a.__sub__(b)
+    def __sub__(a, b):
+        return a + b.__neg__()
+
+    # soustraction a.__rsub__(b)
+    def __rsub__(a, b):
+        return b + a.__neg__()
+
+    # multiplication a.__mul__(b)
+    def __mul__(a, b):
+        # Cette partie assure que si l'on a un float ou un int, on le transforme en Dual_Number avant de faire l'opération,
+        # que l'on doit alors faire avec les nombres duaux a et b2.
+        if type(b) in [int, float]:
+            b2 = Dual_Number(real=b, dual=0)
+        else:
+            b2 = b
+        # Fin de la partie pour assurer la compatibilité entre int/float et Dual_Numbers
+
+        return Dual_Number(real=a.r * b.r, dual=a.r * b.d + a.d * b.r)
+
+    # multiplication a.__rmul__(b)
+    __rmul__ = __mul__
+
+    # definition de 1/a
+    def mult_inverse(a):
+        if type(a) in [int, float]:
+            return 1/a
+        elif a.r == 0:
+            raise TypeError(
+                "Division par un élément non-inversible :{}".format(a))
+        else:
+            return Dual_Number(real=1/a.r, dual=-a.d / (a.r * a.r))
+
+    # division a/b : a.__truediv__(b)
+    def __truediv__(a, b):
+        return a * Dual_Number.mult_inverse(b)
+
+    # division b/a : a.__rtruediv__(b)
+    def __rtruediv__(a, b):
+        return Dual_Number.mult_inverse(a) * b
+
+    def exp(a):
+        return Dual_Number(np.exp(a.r), np.exp(a.r) * a.d)
+
+    def sin(a):
+        return Dual_Number(np.sin(a.r), np.cos(a.r) * a.d)
+
+    def cos(a):
+        return Dual_Number(np.cos(a.r), -np.sin(a.r) * a.d)
+
+
+def Exercice1_a():
+    a = Dual_Number(2, 3)
+    b = Dual_Number(7, -2)
+
+    print(f"{a} * {b}= {a * b}")
+
+
+def Exercice1_b():
+    a = Dual_Number(5, -2)
+    b = Dual_Number(0, 3)
+    c = Dual_Number(1, 1)
+
+    print(f"{a} + {b} * {c} = {a + b * c}")
+
+
+def Exercice1_c():
+    a = Dual_Number(5, -2)
+    b = Dual_Number(3, 1)
+
+    print(f"{a} / {b}= {a / b}")
+
+
+def Exercice1_d():
+    a = Dual_Number(1, 1)
+    b = Dual_Number(1, -1)
+    c = Dual_Number(-1, 1)
+
+    print(f"{a} / {b} * {c} = {a / b * c}")
+
+
+def Test_exp_sin():
+    a = Dual_Number(2, 1)
+
+    print(f"exp(sin({a})) = {Dual_Number.exp(Dual_Number.sin(a))}")
+
+
+def sigmoid_exo():
+    def sigmoid(x): return 1 / (1 + Dual_Number.exp((-1) * x))
+
+    [print(f"Sigmoid de {i} = {sigmoid(i)}") for i in range(10)]
+
+
+if __name__ == "__main__":
+    Exercice1_a()
+    Exercice1_b()
+    Exercice1_c()
+    Exercice1_d()
+    Test_exp_sin()
+    sigmoid_exo()

derive_and_min-max.py

+from zeroes_func import bissect_method, regula_falsi
+from Dual_Numbers import Dual_Number
+
+
+def f(x: Dual_Number):
+    return ((x * x - 1) * Dual_Number.exp(x - 1)).d
+
+
+def dfdx(x: float):
+    return f(Dual_Number(x, 1))
+
+
+if __name__ == "__main__":
+    print(f"Bissect method = {bissect_method(-6, -1, dfdx)}")
+    print(f"Regula false = {regula_falsi(-6, -1, dfdx)}")

serie_taylor/exp.py

+import math
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def exp(x: float) -> float:
+    return pow(x, i) / math.factorial(i)
+
+
+def sin(x: int) -> float:
+    return (pow(-1, i) / math.factorial(2 * i + 1)) * pow(x, 2 * i + 1)
+
+
+if __name__ == "__main__":
+    iter = 10
+    x_axis = np.arange(0, iter, 1)
+    y_axis = []
+
+    for i in range(iter):
+        y_axis.append(exp(i))
+
+    plt.plot(x_axis, y_axis)
+    plt.show()
+    # print(f"For a = {point} and n_iter = {iter} exp({point}) = {exp_taylor(point, iter)}")

zeroes_func.py

+import numpy as np
+
+
+def f(x: float) -> float:
+    return x ** 4 + x ** 3 + x ** 2 - 1
+
+
+def g(x: float) -> float:
+    return x ** 2 - x - 1
+
+
+def h(x: float) -> float:
+    return x ** 2 - 25
+
+
+def z(x: float) -> float:
+    return x ** 3 - x ** 2 - 1
+
+
+def regula_falsi(start: float, stop: float, func) -> float:
+    cN = (start * func(stop) - stop * func(start)) / (func(stop) - func(start))
+
+    if np.sign(func(cN)) != np.sign(func(start)):
+        stop = cN
+    elif np.sign(func(cN)) != np.sign(func(stop)):
+        start = cN
+
+    if np.abs(func(stop) - func(start)) > 1e-9:
+        print(f"Intermediate value of Cn = {cN}\tf(Cn) = {func(cN)}")
+        # Testing the y-axis
+        if np.abs(func(cN)) < 1e-9:
+            return cN
+        return regula_falsi(start, stop, func)
+    else:
+        return cN
+
+
+def bissect_method(start: float, stop: float, func) -> float:
+    cN = (stop + start) / 2
+
+    if np.sign(func(cN)) != np.sign(func(start)):
+        stop = cN
+    elif np.sign(func(cN)) != np.sign(func(stop)):
+        start = cN
+
+    if np.abs(stop - start) > 1e-9:
+        print(f"Intermediate value of Cn = {cN}\tf(Cn) = {func(cN)}")
+        return bissect_method(start, stop, func)
+    else:
+        return cN
+
+
+if __name__ == "__main__":
+    # print(f"Bissection = {bissect_method(0.5, 2, g)}")
+    # print(f"Regula falsi = {regula_falsi(-3, 7, h)}")
+    # print(f"Bissection = {bissect_method(-3, 7, h)}")
+    print(f"Regula falsi = {regula_falsi(0, 3, z)}")