In [14]:
import numpy as np
import matplotlib.pyplot as plt
In [15]:
%matplotlib inline

Approximation de l'intégrale d'une courbe par la méthode des rectangles

Fichier Geogebra : somme des rectangles pour la parabole $y=x^2$sur [0;1]

Exemple de la fonction sommeRectangle(a, b, n) du cours

Que représentent les variables u et v dans la fonction ci-dessous ?

In [5]:
def f(x):
    return x ** 2

def sommeRectangle(a, b, n):
    h = (b - a) / n
    x = a 
    u = 0
    v = 0
    for k in range(0, n - 1): #n subdivisions => n tours
        u = u + h * f(x)  
        x = x + h
        v = v + h * f(x)
    return (u, v)
In [6]:
sommeRectangle(0, 1, 10)
Out[6]:
(0.20399999999999996, 0.2849999999999999)

Exemple 3

Compléter les fonctions Python ci-dessous pour qu'elles retournent une approximation de $\int_{a}^{b}f(x) \mathrm{dx}$ par la somme de rectangles à gauche construits sur $n$ subdivisions régulières de l'intervalle $[a;b]$.

In [7]:
def  rectangleGauche(f, a, b, n):
    s = 0
    pas = (b - a)/n
    x = a
    for k in range(n):
        s = '..............'
        x = '..............'
    return s


def rectangleGauche2(f, a, b, n):
    s = 0
    pas = (b - a) / n
    for k in range(n):
        s = '..............'
    return s

def rectangleGaucheDessin(f, a, b, n):
    s = 0
    pas = (b - a)/n
    x = a
    for k in range(n):
        s = s + f(x) * pas
        plt.fill([x, x + pas, x + pas, x, x], [0] * 2 + [f(x)] * 2 + [0], hatch='/',edgecolor='black', facecolor='none')
        x = x + pas        
    lesx = np.linspace(a, b, 1000)  
    fvect = np.vectorize(f)
    ax = plt.gca()
    ax.spines['top'].set_color('none')
    ax.spines['right'].set_color('none')
    ax.spines['bottom'].set_position(('data',0))
    ax.spines['left'].set_position(('data',a))
    plt.plot(lesx, fvect(lesx), color='black')
    plt.title(r"Rectangles à gauche $\int_{%d}^{%d}f(x)dx\approx$%1.3f"%(a,b,s))
    plt.savefig('methodeRectangleGauche-{}-{}-{}-{}subdivisions.eps'.format(f.__name__,a,b,n))
    plt.show()
    return s

Écrire une fonction rectangleDroite(f, a, b, n) qui retourne une approximation de $\int_{a}^{b}f(x) \mathrm{dx}$ par la somme de rectangles à droite construits sur $n$ subdivisions régulières de l'intervalle $[a;b]$.

In [8]:
def rectangleDroite(f, a, b, n):
    s = 0
    pas = (b - a)/n
    x = a + pas
    for k in range(n):
        s = '..............'
        x = '..............'
    return s

def rectangleDroite2(f, a, b, n):
    s = 0
    pas = (b - a) / n
    for k in range(1, n + 1):
        s = '..............'
    return s

def rectangleDroiteDessin(f, a, b, n):
    s = 0
    pas = (b - a)/n
    x = a
    for k in range(n):
        s = s + f(x + pas) * pas
        plt.fill([x, x + pas, x + pas, x, x], [0] * 2 + [f(x+pas)] * 2 + [0], hatch='/',edgecolor='black', facecolor='none')
        x = x + pas        
    lesx = np.linspace(a, b, 1000)  
    fvect = np.vectorize(f)
    ax = plt.gca()
    ax.spines['top'].set_color('none')
    ax.spines['right'].set_color('none')
    ax.spines['bottom'].set_position(('data',0))
    ax.spines['left'].set_position(('data',a))
    plt.plot(lesx, fvect(lesx), color='black')
    plt.title(r"Rectangles à droite $\int_{%d}^{%d}f(x)dx\approx$%1.3f"%(a,b,s))
    plt.savefig('methodeRectangleDroite-{}-{}-{}-{}subdivisions.eps'.format(f.__name__,a,b,n))
    plt.show()
    return s
In [9]:
def inverse(x):
    return 1 / x
In [10]:
inverse.__name__
Out[10]:
'inverse'
In [11]:
rectangleGauche(inverse, 1, 2, 10)
Out[11]:
'..............'
In [12]:
rectangleGauche2(inverse, 1, 2, 10)
Out[12]:
'..............'
In [16]:
rectangleGaucheDessin(inverse,1,2,10)
Out[16]:
0.7187714031754279
In [17]:
def carre(x):
    return x ** 2
In [18]:
rectangleGaucheDessin(carre,0,1,10)
Out[18]:
0.2849999999999999
In [105]:
rectangleDroiteDessin(carre, 0, 1, 10)
Out[105]:
0.3849999999999999