4 novembre 2021

Calculatrice Python : Intégration numérique

L’intégrale de f(x) sur l’intervalle [a, b] est la somme algébrique (aire signée) des aires délimitées par le graphe de f et de l’axe (Ox). Les parties au-dessus de l’axe (Ox) sont comptées positivement, celles en-dessous seront comptées négativement. De nombreuses méthodes numériques existent pour fournir une valeur approchée d’une intégrale qui ont toutes en commun de subdiviser [a,b] en n intervalles de largeur égale et d’approximer f(x) par une fonction (souvent un polynôme) donc le calcul de l’aire est plus simple. Parlons d’intégration numérique, de méthodes et de fonctions.

La méthode des rectangles

Explication

Dans cette méthode on approchera f(x) sur l’intervalle [a,b] par un segment de droite parallèle à l’axe (Ox) créant ainsi un rectangle : dont le calcul de l’aire est simple. Le choix du segment est un élément important qui influera sur l’algorithme et sa rapidité de convergence.

Rectangles à gauche

Dans cette méthode on approchera f(x) sur l’intervalle [an, bn] par le segment définit par l’équation :

 y=f(an)

Dans le cas présent, si h=(b-a)/n, nous aurons une valeur approchée de l’intégrale In :

Pour nous faciliter l’écriture, nous allons combiner des fonctions facilitatrices :

  • sum( vec )
    calcule la somme des éléments de l’itérable vec. Sur une version PC nous lui préférerions la fonction math.fsum. Par itérable on entend une séquence que l’on peut parcourir comme une liste.
  • map( f, vec )
    retourne f(x) pour chaque x de vec

Voici le code Python permettant de calculer l’aire de ces rectangles :

from math import *
def rectangle_a_gauche( f, a, b, n ):
	h = ( b - a ) / n
s = sum( map( f, ( a + h * i for i in range( n ) ) ) )
return s * h
print( rectangle_a_gauche( sin, 0., tau, 100 ) )

Rectangles à droite

Dans cette méthode on approchera f(x) sur l’intervalle [an, bn] par le segment définit par l’équation :

y=f(bn)

Dans le cas présent, si h=(b-a)/n, nous aurons une valeur approchée de l’intégrale In :

Pour nous faciliter l’écriture, nous allons combiner les mêmes fonctions facilitatrices que pour la méthode des rectangles à gauche. Pour générer les entiers de 1 à n inclus, nous utiliserons l’appel suivant : range(1, n+1).

Voici le code Python permettant de calculer l’aire de ces rectangles :

from math import *
def rectangle_a_droite( f, a, b, n ):
	h = ( b - a ) / n
s = sum( map( f, ( a + h * i for i in range( 1, n+1 ) ) ) )
return s * h
print( rectangle_a_droite( sin, 0., tau, 100 ) )

Rectangles aux points milieux

Dans cette méthode on approchera f(x) sur l’intervalle [an, bn] par le segment définit par l’équation :

y=f( (an+bn)/2)

Dans le cas présent, si h=(b-a)/n, nous aurons une valeur approchée de l’intégrale In :

Voici le code Python permettant de calculer l’aire de ces rectangles :

from math import *
def rectangle_point_milieu( f, a, b, n ):
	h = ( b - a ) / n
h2 = 0.5 * h
s = sum( map( f, ( a + h2 + h * i for i in range( n ) ) ) )
return s * h
print( rectangle_ point_milieu( sin, 0., tau, 100 ) )

La méthode des trapèzes

Dans cette méthode on approchera f(x) sur l’intervalle [a,b] par un segment de droite reliant le point de coordonnées (a, f(a)) au point de coordonnées (b, f(b)) créant ainsi un trapèze dont le calcul de l’aire est simple : ( f(a) + f(b) ) * ( b – a ) / 2

On peut donc approcher l’intégrale In de f sur [a, b] par :

Ce qui se traduit en Python par :

def trapeze( f, a, b, n ):
    h = ( b - a ) / n
    s = 0.5 * ( f( a ) + f( b ) ) + \
        sum( map( f, ( a + h * i for i in range( 1, n ) ) ) )
    return s * h

La méthode de Simpson

On interpole f sur l’intervalle [a, b] par un polynôme de degré 2 passant par les 2 points extrémités et par le point milieu (m, f(m)). Ce polynôme est construit à l’aide des polynômes de Lagrange (voir https://fr.wikipedia.org/wiki/Interpolation_lagrangienne). L’équation de ce polynôme est :

On en déduit que l’intégrale de f est :

En découpant l’intervalle [a, b] en n sous-intervalles de la même taille h=(b-a)/n :

En calculant cette suite In, on se rend compte que certains termes sont répétés :

Nous pouvons simplifier cette formule en :

Que nous pouvons traduire en Python par :

def simpson2( f, a, b, n ):
    n *= 2
    h  = ( b - a ) / n
    s  = f( a ) + f( b )
    s += 2 * sum( ( 1 + ( i % 2 ) ) * f( a + i * h ) for i in range( 1, n ) )
    return s * h / 3

Merci d’avoir lu cet article sur l’intégration numérique en Python. Si vous voulez en savoir plus à ce sujet rendez-vous sur notre blog où plusieurs articles sur la programmation en Python sont disponibles, comme par exemple “Algorithme Python : jouons avec les entiers”.

Expertise Design & Code

$

Python, Java, C++, C# et Front-End

Découvrez nos formations

$

Parcourir le catalogue

Boostez votre carrière !

$

Nos offres pour Développeurs

Tous les mois recevez nos derniers articles !

Try X4B now !

Découvrez gratuitement XComponent for Business. Notre solution logicielle BizDevOps !

Écrit par Philippe Boulanger

0 Comments

Submit a Comment

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *