🎲Euler et Monte-Carlo

On veut approcher une fonction $y$ dont on connaît seulement la vitesse de variation $y'(t) = f(t, y)$ et un point de départ $y(t_0) = y_0$. La méthode d'Euler avance par petits pas de longueur $h$ :

$t_{n+1} = t_n + h, \qquad y_{n+1} = y_n + h \cdot f(t_n, y_n).$

On suit la tangente sur une petite distance $h$, puis on recommence. Plus $h$ est petit, plus l'approximation est précise (mais plus il faut d'étapes).

def euler(y0, h, n):
    y = y0
    t = 0
    for _ in range(n):
        y = y + h * y          # ici f(t, y) = y (donc y' = y)
        t = t + h
    return round(y, 4)

⭐ Pour les curieux — pourquoi ça marche ? La formule d'Euler n'est rien d'autre que l'équation de la tangente. Au point $t_n$, la tangente à la courbe de $y$ a pour équation $Y = y(t_n) + y'(t_n)\,(t - t_n)$. Or on connaît justement la pente : $y'(t_n) = f(t_n, y_n)$. En se déplaçant d'un petit pas $h$, donc en $t = t_n + h$, la tangente vaut $y_n + h\cdot f(t_n, y_n)$ : c'est exactement $y_{n+1}$ ! On remplace donc la vraie courbe par sa tangente sur une courte distance $h$, et plus $h$ est petit, moins la courbe a le temps de s'écarter de sa tangente.

Pour programmer Euler :

1. Initialise y = y0 et t = 0 (ou t = t0).
2. Boucle for _ in range(n): (nombre de pas imposé).
3. y = y + h * f(t, y) puis t = t + h (mets à jour y AVANT t, ou stocke l'ancien t si f dépend de t).
4. Renvoie round(y, k).

Pour $y' = y$, $y_0 = 1$, $h = 0{,}5$, n = 2 :

• $y_1 = 1 + 0{,}5 \times 1 = 1{,}5$
• $y_2 = 1{,}5 + 0{,}5 \times 1{,}5 = 2{,}25$

euler(1, 0.5, 2) renvoie round(2.25, 4) = 2.25.

Quand f dépend de t, fais bien le calcul de y avec l'ancien t, puis incrémente t après. Sinon tu décales tout d'un pas.

Si $y'(t) = f(t, y)$ dépend du temps $t$, il faut utiliser la bonne valeur de t dans le calcul. Exemple : $y' = t$, $y_0 = 0$, $h = 1$.

def euler_t(h, n):
    y = 0
    t = 0
    for _ in range(n):
        y = y + h * t      # f(t, y) = t : on utilise t AVANT de l'augmenter
        t = t + h
    return round(y, 4)

Avec $h = 1$ et n = 4 : on ajoute successivement $1 \times 0$, $1 \times 1$, $1 \times 2$, $1 \times 3$, soit $0+1+2+3 = 6$.

Ordre des instructions dans la boucle, quand f dépend de t :

1. D'abord y = y + h * f(t, y) (avec la valeur actuelle de t).
2. Ensuite t = t + h.

Si tu incrémentes t avant, tu utilises un t en avance et le résultat est faux.

euler_t(1, 4) : y passe par 0, puis 0, 1, 3, 6 (on ajoute successivement $1\times 0$, $1\times 1$, $1\times 2$, $1\times 3$). Résultat : 6.

Si tes valeurs de départ sont des entiers, round(6, 4) renvoie 6 (un entier reste un entier) ; avec un flottant, round(6.0, 4) renvoie 6.0. Garde ça en tête quand tu compares à un résultat attendu.

L'aire sous une courbe $y = g(x)$ entre $a$ et $b$ s'approche en découpant $[a, b]$ en n tranches de largeur $h = (b-a)/n$ et en additionnant l'aire de petits rectangles (méthode des rectangles à gauche) :

$\int_a^b g(x)\,dx \approx \sum_{k=0}^{n-1} h \cdot g(a + k h).$

def rectangles(a, b, n):
    h = (b - a) / n
    aire = 0
    for k in range(n):
        x = a + k * h
        aire = aire + h * (x * x)    # g(x) = x^2
    return round(aire, 4)

Plus n est grand, plus l'estimation est proche de la vraie intégrale (ici $\int_0^1 x^2\,dx = 1/3 \approx 0{,}333$).

⭐ Pour les curieux — pourquoi ça marche ? Si la fonction $g$ est croissante, le rectangle à gauche a pour hauteur la plus petite valeur de $g$ sur sa tranche (le bord gauche). Chaque rectangle se loge donc entièrement sous la courbe, et la somme de leurs aires est forcément inférieure à la vraie intégrale. C'est exactement ce qu'on observe pour $\int_0^1 x^2\,dx = \tfrac{1}{3} \approx 0{,}333$ : on trouve $0{,}125$ puis $0{,}2188$, toujours en dessous, et on remonte vers $0{,}333$ à mesure que les tranches rétrécissent.

Pour la méthode des rectangles à gauche :

1. Calcule le pas h = (b - a) / n.
2. Accumulateur aire = 0.
3. Pour k de 0 à n-1 : x = a + k*h, puis aire += h * g(x).
4. Renvoie round(aire, k).

Pour $g(x) = x^2$ sur $[0, 1]$ avec n = 2 : h = 0.5. k=0 : x=0, aire += 0.50 = 0. k=1 : x=0.5, aire += 0.50.25 = 0.125. Total = 0.125.

Avec les rectangles à gauche, on évalue g au bord gauche de chaque tranche (x = a + k*h, pour k de 0 à n-1). On n'évalue jamais en b lui-même.

La méthode de Monte-Carlo estime une aire en regardant quelle proportion de points tombe sous la courbe. Normalement les points sont tirés au hasard ; ici, comme on n'a pas le droit au hasard (random interdit), on te donne une liste de points (x, y) et tu comptes.

Pour estimer l'aire sous $y = g(x)$ dans le carré $[0,1] \times [0,1]$ : un point $(x, y)$ est « sous la courbe » si $y \le g(x)$. La proportion de tels points, multipliée par l'aire du carré (ici 1), estime l'aire.

def monte_carlo(points):
    dedans = 0
    for (x, y) in points:
        if y <= x * x:          # sous la courbe y = x^2
            dedans = dedans + 1
    return round(dedans / len(points), 4)

⭐ Pour les curieux — pourquoi ça marche ? Imagine qu'on saupoudre uniformément le carré de côté $1$ (d'aire $1$) avec des grains de sable. La part des grains qui tombe dans une zone donnée est tout simplement égale à l'aire de cette zone (puisque l'aire totale vaut $1$). En comptant la proportion de points sous la courbe $y = g(x)$, on mesure donc directement l'aire de la région située sous la courbe, c'est-à-dire l'intégrale. C'est la même idée que pour estimer $\pi$ en lançant des fléchettes dans un carré et en comptant celles qui tombent dans le cercle inscrit.

Pour un comptage de type Monte-Carlo :

1. Compteur dedans = 0.
2. Parcours la liste de points for (x, y) in points:.
3. Teste si le point est sous la courbe (if y <= g(x):) et incrémente.
4. Renvoie la proportion round(dedans / len(points), k).

Avec points = [(0.5, 0.1), (0.5, 0.5), (0.2, 0.5), (0.9, 0.2)] et $g(x) = x^2$ : sous la courbe si $y \le x^2$.

• (0.5, 0.1) : 0.1 ≤ 0.25 ✔
• (0.5, 0.5) : 0.5 ≤ 0.25 ✘
• (0.2, 0.5) : 0.5 ≤ 0.04 ✘
• (0.9, 0.2) : 0.2 ≤ 0.81 ✔

2 points sur 4 → round(2/4, 4) = 0.5.

for (x, y) in points: déballe directement chaque couple en deux variables x et y. Pratique pour traiter des listes de points.

Pour toutes ces méthodes, plus on en fait, mieux c'est :

• Euler : un pas h plus petit (donc plus d'étapes) → courbe mieux suivie.
• Rectangles : plus de tranches n → aire mieux approchée.
• Monte-Carlo : plus de points → proportion plus fiable.

Mais cela coûte plus de calculs. On cherche un compromis entre précision et temps de calcul. Dans nos exercices, on impose ces paramètres pour obtenir un résultat reproductible qu'on arrondit.

Comme pour Newton et la dichotomie : fais tous tes calculs sans arrondir, et applique round(..., k) uniquement sur la valeur renvoyée.

Pour $\int_0^1 x^2\,dx = 1/3$ : rectangles à gauche avec n = 4 donne 0.2188 ; avec n = 10 on s'approche de 0.285 ; il faut beaucoup de tranches pour approcher 0.3333.

Si un test attend une valeur arrondie, respecte exactement le nombre de décimales demandé (round(x, 4) ≠ round(x, 2)).