Intégrales impropres et intégration numérique

Une intégrale impropre utilise une limite à l’infini ou à une singularité non bornée. Une fonction bornée avec un nombre fini de sauts peut avoir une intégrale de Riemann ordinaire : une discontinuité ne suffit pas à rendre l’intégrale impropre. Chaque intégrale tronquée doit exister, et chaque limite requise doit être finie pour avoir convergence. Voir le cours de Paul Dawkins.

Le critère des puissances à l’infini suppose $a>0$. Près de zéro, le critère change : $\int_0^1x^{-p}\,dx$ converge exactement pour $p<1$. Pour $p\ne1$, intégrer en $x^{1-p}/(1-p)$ puis prendre la limite à l’extrémité concernée ; pour $p=1$, utiliser $\ln x$. Ainsi,

$$\int_1^\infty x^{-2}\,dx=\lim_{R\to\infty}(1-1/R)=1, \qquad \int_0^1x^{-1/2}\,dx=\lim_{\varepsilon\to0^+}(2-2\sqrt\varepsilon)=2.$$

Mais $\int_0^1x^{-2}\,dx$ diverge. Autre exemple : $0\le1/(1+x^2)\le1/x^2$ pour $x\ge1$, donc l’intégrale de $1/(1+x^2)$ sur $[1,\infty)$ converge par comparaison. Les fonctions comparées doivent être intégrables sur les intervalles tronqués finis.

Ne pas annuler des infinis de part et d’autre d’une singularité. Pour $1/x$ sur $[-1,1]$, les intégrales gauche et droite divergent. Des coupures symétriques donnent zéro, mais c’est une valeur principale de Cauchy, non une intégrale impropre convergente.

Intégrales impropres

Les intégrales impropres sont des intégrales ayant soit des bornes infinies, soit des singularités non bornées. Elles permettent d'étendre le concept d'intégration au-delà des bornes traditionnelles. Voici comment elles sont définies et évaluées :

Bornes infinies

• Intégrale de a à l'infini :

  $\int_{a}^{\infty} f(x) \, dx = \lim_{{t \to \infty}} \int_{a}^{t} f(x) \, dx$

• Intégrale de moins l'infini à b :

  $\int_{-\infty}^{b} f(x) \, dx = \lim_{{t \to -\infty}} \int_{t}^{b} f(x) \, dx$

• Intégrale de moins l'infini à l'infini :

  $\int_{-\infty}^{\infty} f(x) \, dx = \int_{-\infty}^{c} f(x) \, dx + \int_{c}^{\infty} f(x) \, dx \quad \text{(si les deux intégrales convergent)}$

Intégrande discontinu

• Discontinuité en a :

  $\int_{a}^{b} f(x) \, dx = \lim_{{t \to a^{+}}} \int_{t}^{b} f(x) \, dx$

• Discontinuité en b :

  $\int_{a}^{b} f(x) \, dx = \lim_{{t \to b^{-}}} \int_{a}^{t} f(x) \, dx$

• Discontinuité dans l'intervalle (a < c < b) :

  $\int_{a}^{b} f(x) \, dx = \int_{a}^{c} f(x) \, dx + \int_{c}^{b} f(x) \, dx \quad \text{(si les deux convergent)}$

Test de comparaison pour les intégrales impropres

Pour les fonctions non négatives sur $[a,\infty)$ :

• Si $0 \leq f(x) \leq g(x)$ et $\int_a^\infty g(x)\,dx$ converge, alors $\int_a^\infty f(x)\,dx$ converge également.
• Si $0 \leq g(x) \leq f(x)$ et $\int_a^\infty g(x)\,dx$ diverge, alors $\int_a^\infty f(x)\,dx$ diverge également.

Fait utile

Pour $p > 0$, l'intégrale $\int_{a}^{\infty} \frac{1}{x^p} \, dx$ converge si $p > 1$ et diverge pour $p \leq 1$.

Méthodes d'intégration numérique

Les méthodes d'intégration numérique sont utilisées pour approcher la valeur d'une intégrale définie lorsqu'il est difficile ou impossible de la calculer analytiquement. Les règles d'intégration numérique usuelles sont les suivantes :

Règle du point milieu

La règle du point milieu estime l'intégrale d'une fonction en sommant la valeur de la fonction au milieu de chaque intervalle, multipliée par la largeur des intervalles.

Pour $n$ sous-intervalles, l'approximation est :

$$\int_{a}^{b} f(x) dx \approx \Delta x \left[ f\left(x_1^*\right) + f\left(x_2^*\right) + \ldots + f\left(x_n^*\right) \right]$$

où $\Delta x = \frac{b - a}{n}$ et $x_i^*$ est le milieu du $i$-ème sous-intervalle.

Règle des trapèzes

La règle des trapèzes calcule l'intégrale en faisant la moyenne des valeurs de la fonction aux extrémités de chaque intervalle, ce qui revient à estimer l'aire sous la courbe à l'aide de trapèzes.

La formule est :

$$\int_{a}^{b} f(x) dx \approx \frac{\Delta x}{2} \left[ f(x_0) + 2f(x_1) + 2f(x_2) + \ldots + 2f(x_{n-1}) + f(x_n) \right]$$

Règle de Simpson

La règle de Simpson utilise un polynôme quadratique passant par trois points consécutifs pour chaque paire de sous-intervalles ; son ordre de convergence est supérieur pour les fonctions suffisamment régulières. Elle nécessite que le nombre de sous-intervalles $n$ soit pair.

L'approximation donnée par la règle de Simpson est :

$$\int_{a}^{b} f(x) dx \approx \frac{\Delta x}{3} \left[ f(x_0) + 4f(x_1) + 2f(x_2) + \ldots + 4f(x_{n-1}) + f(x_n) \right]$$

Voir l’image en grand

À gauche, une parabole passe par trois points et couvre deux sous-intervalles. À droite, une seconde prolonge l’approximation sur la paire suivante. Ce regroupement explique le nombre pair de sous-intervalles requis. Comparez ces bords courbes aux sommets horizontaux des rectangles et aux segments des trapèzes.

Gilbert Strang & Edwin Herman, OpenStax, Calculus Volume 2, Figure 3.16. · CC BY-NC-SA 4.0

Utilisation pratique

Ces règles sont particulièrement utiles en informatique pour résoudre des problèmes qui nécessitent des solutions numériques, comme dans les simulations, les problèmes d'optimisation et les domaines où la fonction ne peut pas être intégrée symboliquement.

Implémentation

Voici des fonctions Python qui implémentent chacune de ces règles :

import numpy as np

def midpoint_rule(f, a, b, n):
    if isinstance(n, bool) or not isinstance(n, int) or n <= 0:
        raise ValueError("n must be a positive integer")
    dx = (b - a) / n
    x_mid = np.linspace(a + dx/2, b - dx/2, n)
    return np.sum(f(x_mid)) * dx

def trapezoid_rule(f, a, b, n):
    if isinstance(n, bool) or not isinstance(n, int) or n <= 0:
        raise ValueError("n must be a positive integer")
    dx = (b - a) / n
    x = np.linspace(a, b, n + 1)
    return dx/2 * np.sum(f(x[:-1]) + f(x[1:]))

def simpsons_rule(f, a, b, n):
    if isinstance(n, bool) or not isinstance(n, int) or n <= 0:
        raise ValueError("n must be a positive integer")
    if n % 2 == 1:
        raise ValueError("n must be even for Simpson's Rule")
    dx = (b - a) / n
    x = np.linspace(a, b, n + 1)
    y = f(x)
    return dx/3 * np.sum(y[0:-1:2] + 4*y[1::2] + y[2::2])

Notes :

• f est la fonction intégrande.
• a et b sont les bornes d'intégration.
• n est le nombre de sous-intervalles.
• dx est la largeur de chaque sous-intervalle.
• Pour simpsons_rule, un nombre pair de sous-intervalles est nécessaire.

Bornes d’erreur et vérification reproductible

Pour $a<b$, poser $I=\int_a^b f(x)\,dx$. Les bornes d’erreur des règles composites sont

$$|I-M_n|\le\frac{K_2(b-a)^3}{24n^2},\qquad |I-T_n|\le\frac{K_2(b-a)^3}{12n^2},\qquad |I-S_n|\le\frac{K_4(b-a)^5}{180n^4}.$$

Les deux premières exigent une dérivée seconde continue, bornée en valeur absolue par $K_2$ ; Simpson exige une dérivée quatrième continue bornée par $K_4$ et un $n$ pair. Ces bornes concernent la discrétisation, non l’arrondi flottant. Diviser le pas par deux divise les bornes par 4 ou 16. Simpson est exact pour les polynômes cubiques en arithmétique exacte, mais n’est pas toujours plus précis pour une fonction peu régulière.

Pour $f(x)=x^2$ sur $[0,1]$ avec $n=2$, on obtient $M_2=5/16$, $T_2=3/8$, $S_2=1/3$, tandis que $I=1/3$. Les erreurs absolues sont $1/48$, $1/24$ et zéro, conformément aux bornes avec $K_2=2$, $K_4=0$. Pour garantir ici une erreur des trapèzes au plus égale à $10^{-4}$, choisir $n\ge\lceil\sqrt{1/(6\cdot10^{-4})}\rceil=41$.

L’implémentation exige NumPy installé, des bornes finies et une fonction acceptant un tableau et renvoyant un tableau de même forme. Pour une constante, utiliser lambda x: np.ones_like(x), non lambda x: 1. Ce sont des routines pédagogiques à grille fixe, non des solveurs adaptatifs d’intégrales singulières.

f = lambda x: x**2
assert np.isclose(midpoint_rule(f, 0, 1, 2), 5/16)
assert np.isclose(trapezoid_rule(f, 0, 1, 2), 3/8)
assert np.isclose(simpsons_rule(f, 0, 1, 2), 1/3)

Comparer les résultats pour $n,2n,4n$ permet d’observer la convergence, mais leur accord ne certifie pas l’erreur : une grille peut manquer un pic étroit. Ne pas évaluer une extrémité singulière avec les trapèzes ou Simpson ; découper ou transformer d’abord l’intégrale. Tronquer un intervalle infini ajoute une erreur de queue distincte : remplacer $\int_1^\infty x^{-2}\,dx$ par $\int_1^R x^{-2}\,dx$ perd exactement $1/R$, quelle que soit la finesse de la grille.

Mes lectures · Les notes ouvertes sont mémorisées dans ce navigateur.