ISC_421_Controle_4_Saroukhanian_Iliya.py

@@ -156,28 +156,28 @@ print(f"valeur de la fonction en a et b:  {SD.f(SD.a), SD.f(SD.b)}")
 ###########################################################################
 
 
-def taylor_err_max(plot_range, eval_pt):
+def errmax_taylor(plot_range, eval_pt):
     return (SD.Maximal_derivatives_values[len(SD.Maximal_derivatives_values) - 1] /
             math.factorial(len(SD.Maximal_derivatives_values) + 1)) * \
         (plot_range - eval_pt)**(len(SD.Maximal_derivatives_values) + 1)
 
 
-def ex2_taylor_poly():
+def plot_taylor_poly():
     t = np.linspace(SD.a, SD.b, Nmbre_pts)
     y0 = compute_taylor_series(
         t, SD.Taylor_points[0], SD.Taylor_derivatives_values[SD.Taylor_points[0]])
 
-    err_y0 = taylor_err_max(t, SD.Taylor_points[0])
+    err_y0 = errmax_taylor(t, SD.Taylor_points[0])
 
     y1 = compute_taylor_series(
         t, SD.Taylor_points[1], SD.Taylor_derivatives_values[SD.Taylor_points[1]])
 
-    err_y1 = taylor_err_max(t, SD.Taylor_points[1])
+    err_y1 = errmax_taylor(t, SD.Taylor_points[1])
 
     y2 = compute_taylor_series(
         t, SD.Taylor_points[2], SD.Taylor_derivatives_values[SD.Taylor_points[2]])
 
-    err_y2 = taylor_err_max(t, SD.Taylor_points[2])
+    err_y2 = errmax_taylor(t, SD.Taylor_points[2])
 
     fig, axs = plt.subplots(2, 2, figsize=(18, 12))
 
@@ -225,7 +225,7 @@ def ex2_taylor_poly():
     plt.show()
 
 
-def polerr(nb_points, interpolation_pts, plot_range):
+def errmax_poly_interpolation(nb_points, interpolation_pts, plot_range):
     errs_range = []
 
     for pt in plot_range:
@@ -247,7 +247,7 @@ def chebyshev_pts(start, stop, nb_points):
             np.cos(((2 * np.arange(nb_points) + 1) * np.pi) / (2 * (nb_points))))
 
 
-def ex3_lagrange_interpolation_poly():
+def plot_lagrange_poly():
     nb_points = np.linspace(1, 12, 6, dtype=np.uint8)
     fig, axes = plt.subplots(2, 3, figsize=(20, 12))
 
@@ -262,33 +262,67 @@ def ex3_lagrange_interpolation_poly():
         l_poly_chebyshev_pts = lagrange(
             cheb_pts, SD.f(cheb_pts))
 
-        uniform_err = polerr(nb_points[i], interpolate_pts, t)
-        chebyshev_err = polerr(nb_points[i], cheb_pts, t)
-
         ax.plot(t, SD.f(t), color='black', label='f')
         ax.plot(t, l_poly_uniform(t), color='red',
                 label='$L_{f}$, intervalle équidistants')
         # ax.plot(t, np.abs(SD.f(t) - l_poly_uniform(t)), '--', color='red',
         #         label='$L_{f}$, intervalle équidistants, erreur')
-        ax.plot(t, uniform_err, '--', color='red',
-                label='ErrMax de $L_{f}$, intervalle équidistants')
         ax.plot(t, l_poly_chebyshev_pts(t), color='blue',
                 label='$L_{f}$, points de Chebyshev')
         # ax.plot(t, np.abs(SD.f(t) - l_poly_chebyshev_pts(t)), '--', color='blue',
         #         label='$L_{f}$, points de Chebyshev, erreur')
+        ax.plot(interpolate_pts, SD.f(interpolate_pts), 'o', color='red',
+                label='Points équidistants')
+        ax.plot(cheb_pts, SD.f(cheb_pts), 'o', color='blue',
+                label='Points de Chebyshev')
+        ax.set_title(f'n = {nb_points[i]}')
+        ax.set_ylim([-1.2, 1.2])
+
+        ax.legend()
+
+    fig.suptitle(f'Polynômes d\'interpolation de Lagrange de $f$ avec 2 subdivisions différentes d\'intervalle: Équidistantes (rouge) / Points de Chebyshev (bleu)')
+
+    fig.tight_layout()
+    plt.show()
+
+
+def plot_errmax_interpolation():
+    nb_points = np.linspace(1, 12, 6, dtype=np.uint8)
+    fig, axes = plt.subplots(2, 3, figsize=(20, 12))
+
+    t = np.linspace(SD.a, SD.b, Nmbre_pts)
+
+    for i, ax in enumerate(axes.flat):
+        cheb_pts = chebyshev_pts(SD.a, SD.b, nb_points[i])
+
+        interpolate_pts = np.linspace(SD.a, SD.b, nb_points[i])
+
+        l_poly_uniform = lagrange(interpolate_pts, SD.f(interpolate_pts))
+        l_poly_chebyshev_pts = lagrange(
+            cheb_pts, SD.f(cheb_pts))
+
+        uniform_err = errmax_poly_interpolation(
+            nb_points[i], interpolate_pts, t)
+        chebyshev_err = errmax_poly_interpolation(nb_points[i], cheb_pts, t)
+
+        ax.plot(t, SD.f(t), color='black', label='f')
+        ax.plot(t, l_poly_uniform(t), color='red',
+                label='$L_{f}$, intervalle équidistants')
+        ax.plot(t, uniform_err, '--', color='red',
+                label='ErrMax de $L_{f}$, intervalle équidistants')
+        ax.plot(t, l_poly_chebyshev_pts(t), color='blue',
+                label='$L_{f}$, points de Chebyshev')
         ax.plot(t, chebyshev_err, '--', color='blue',
                 label='ErrMax de $L_{f}$, points de Chebyshev')
         ax.plot(interpolate_pts, SD.f(interpolate_pts), 'o', color='red',
                 label='Points équidistants')
-        ax.plot(cheb_pts[::-1],
-                SD.f(cheb_pts[::-1]), 'o', color='blue',
+        ax.plot(cheb_pts, SD.f(cheb_pts), 'o', color='blue',
                 label='Points de Chebyshev')
         ax.set_title(f'n = {nb_points[i]}')
-        # ax.set_ylim([-1.2, 1.2])
 
         ax.legend()
 
-    fig.suptitle(f'Polynôme d\'interpolation de Lagrange de $f$ avec 2 subdivisions différentes d\'intervalle: Équidistantes (rouge) / Points de Chebyshev (bleu)')
+    fig.suptitle(f'Erreur maximale théorique lors de l\'interpolation de $f$ avec 2 subdivisions différentes d\'intervalle: Équidistantes (rouge) / Points de Chebyshev (bleu)')
 
     fig.tight_layout()
     plt.show()
@@ -299,7 +333,9 @@ def ex3_lagrange_interpolation_poly():
 
 
 # ex2_taylor_poly()
-ex3_lagrange_interpolation_poly()
+# plot_taylor_poly()
+plot_lagrange_poly()
+# plot_errmax_interpolation()
 
 
 # def ex3_newton_interpolation_poly():

report.qmd

@@ -32,7 +32,7 @@ R_{f, n, a}(x) = \lvert f(x) - T_{f, n, a}(x) \rvert
 $$
 
 Par conséquent, nous savons donc que l'erreur $R_{f, n, a}$ est bornée par la
-plus grande valeur du $(n + 1)$-ème terme de la série de Taylor évaluée au un
+plus grande valeur du $(n + 1)$ème terme de la série de Taylor évaluée au un
 point $\xi$ de l'intervalle $I$.
 
 $$
@@ -53,27 +53,45 @@ de précision" du polynôme, la valeur de l'erreur explose vers l'infini.
 # Polynômes d'interpolation
 
 Dans cette partie, nous allons présenter les graphiques de divers polynômes
-d'interpolation. Ceux-ci ont été calculées grâce a la fonction `lagrange`
+d'interpolation. Ceux-ci ont été calculés grâce à la fonction `lagrange`
 proposée dans le module `scipy.interpolate`.
 
 Il était aussi demandé d'effectuer ces interpolations en subdivisant
 l'intervalle $I = [a, b]$ (où $a = 1$ et $b = 4$ dans mon cas) de deux manières
 différentes. Les points rouges réprensentent donc le découpage uniforme/équidistant.
-Quant au bleus, ceux-ci sont les points de Chebyshev (comme vous avez pu le
+Quant aux bleus, ceux-ci sont les points de Chebyshev (comme vous avez pu le
 deviner, ceux-ci ne sont pas équidistants).
 
-Les graphiques ci-dessous mettent en avant les divers polynômes d'interpolation avec
-la valeur de l'erreur commise en chaque point. 
+Les graphiques ci-dessous mettent en avant les divers polynômes d'interpolation
+jusqu'à 12 points d'interpolation.
 
 ![Polynôme d'interpolation avec 2 subdivisions d'intervalle différentes](./figs/lagrange_interpolate.png){#fig-interpolate}
 
+La raison pour laquelle nous avons choisi 12 points est due au fait que nous
+allons par la suite calculer l'erreur maximale théorique commise lors de
+l'interpolation. Afin de déterminer celle-ci, nous sommes à nouveau borné par
+la quantité de dérivées que nous possédons de la fonction $f$. Dans notre cas vu
+que nous avons accès aux 13 premières dérivées, nous pouvons donc calculer
+l'erreur que pour 12 points d'interpolation.
+
+## Erreur maximale théorique
+
+Ci-dessous, nous pouvons visualiser l'erreur maximale théorique commise lors
+de l'interpolation avec une quantité de points diverses.
+
 ![Erreur théorique maximale lors de l'interpolation](./figs/lagrange_interpolate_errmax.png){#fig-interpolate-errmax}
 
-Nous pouvons donc remarquer que plus le degré du polynôme d'interpolation
-augmente, plus l'erreur commise lors de l'interpolation semble diminuer,
-notamment en ce qui concerne la partie centrale de chaque graphique. Les divers
-polynômes d'interpolation présentés ci-dessus ont d'ailleurs l'air de très bien
-approximer la fonction $f$.
+Les graphiques ci-dessus, nous permettent d'observer le fait que dans le cas
+de la stratégie de points équidistants (traitillé rouge), l'erreur maximale
+théorique est très faible au niveau du centre des graphiques. Cependant, plus on
+s'éloigne du centre du graphique, plus l'erreur maximale croît jusqu'à devenir
+très grande aux extrémités du graphe. Ceci reflète notamment l'effet de Runge
+produit lors de l'interpolation à travers des points équidistants. En revanche, 
+lors de l'interpolation à travers les points de Chebyshev (traitillé bleu), on
+remarque que le "comportement" de l'erreur maximale théorique sera toujours le
+même, peu importe où nous nous situons sur le graphique. Cette observation nous
+permet donc de conclure le fait que l'interpolation à travers les points de
+Chebyshev permettent de palier au phénomène de Runge.
 
 ## Phénomène de Runge
 
@@ -83,10 +101,9 @@ et avec un nombre de points croissants, on peut apercevoir un comportement
 le polynôme a tendance à osciller fortement vers les extrémités de l'intervalle.
 
 Sur la @fig-interpolate, il est possible de remarquer que les extrémités de
-l'intervalle $I$ sont grandement affectées par le phénomène de Runge, notamment
-la méthode d'interpolation avec une subdivision équidistante des points. On
-remarque cela par le fait que la valeur de l'erreur commise (traitillé rouge,
-pour le découpage équidistant) croît très violemment.
+l'intervalle $I$ sont grandement affectées par le phénomène de Runge lors de
+l'interpolation avec une subdivision équidistante des points suite aux fortes
+d'oscillations affichées.
 
 # Stratégie d'approximation polynomiale