CPGE Informatique MPSI / 1TSI /PCSI

Lydex – Ben guerir Programmation Mr L. BOUHOU

Chap XI
Ingénierie Numérique

11 .1. Généralités
Recherche classique d’un Elément dans une liste d’éléments
Question 1 :
Etablir une fonction Recherche1 (L, el) qui laisse passer, comme paramètre, une liste d’éléments (paramètre L) et un
élément(paramètre el) afin de retourner True si el est un élément de L ou False dans le cas contraire.
def recherche1(L , x):
for elm in L:
if elm==x: return True
return False
Méthode Dichotomique
Principe : inspirer de la recherche d’un mot dans un dictionnaire papier par exemple de 1024 pages:
 On l’ouvre au milieu: le mot ne s'y trouve pas, mais il est avant (il est donc dans les 512 premières pages).
 On ouvre la moitié de la 1ère moitié: le mot ne s'y trouve pas, mais il est après (il est donc dans les pages 257 à 512).
Vous ouvrez la moitié de la 2ème moitié, etc…
 A chaque fois que vous progressez, le nombre de pages qui reste à examiner est divisé par 2.
 Ainsi, dans un dictionnaire de 1024 pages, vous êtes certain de trouver votre page en 10 recherches seulement, puisque
1024/(2**10)=1.
Algorithme de la Méthode Dichotomique
 1- Diviser l’intervalle de recherche de recherche en 2 parties;
 2- Vérifier, dans le milieu, votre recherche, si objectif atteint retourner ce milieu;
 3- dans le cas contraire, choisir le sous-intervalle où continuer la recherche
 4-repetez les étapes 1, 2 et 3 jusqu’à ce qu’on repère ou non, d’une façon définitive, la valeur de recherche.
Question 2 :
On suppose avoir une liste triée, Réaliser une fonction Itérative Recherche2(L, el) qui laisse passer, comme paramètre une
liste d’éléments triés (paramètre L) et un élément(paramètre el) afin d’appliquer le principe de la méthode dichotomie pour
déterminer si cet élément figure ou non dans cette liste.
def rechercheIter(L, x):
while len(L) > 1:
m=len(L) //2
if L[m]==x: return True
if x<L[m]: L=L[:m]
else: L=L[m+1:]
return L[0]==x

1
CPGE Informatique MPSI / 1TSI /PCSI
Lydex – Ben guerir Programmation Mr L. BOUHOU

Tracer du graphe d’une fonction

from numpy import * #ou import numpy as np
from pylab import * # ou from matplotlib.pyplot import *
def f(x) :
return (x**(1/2))*cos(x)
def Tracer(g, X0, Xmax, NbrPts,fmin, fmax):
Vx = linspace(X0,Xmax,30) #ou X=np.linspace(
Vy = g(Vx)
axis([X0,Xmax,fmin,fmax])
axhline(color='r')
plot(Vx, Vy)
show ()
a ,b=0,5
N=50
ymin , ymax= -4 , 4
Tracer(f,a,b,ymin,ymax

11.2. Zéro d'une fonction

11.2.1. Application de la Méthode dichotomique à la détermination du zéro d’une fonction:
Pour la recherche du zéro d’une fonction sur un intervalle [a,b], par la méthode dichotomique, on procède
successivement en calculant f(a), f(b) et f((a+b)/2) et en regardant le signe de ces trois expressions afin de déduire :
- Si f(a) * f((a+b)/2) <0 , alors il y a un zéro dans l'intervalle [a , (a+b)/2]
- sinon si f((a+b)/2) * f(b) < 0 alors il y a un zéro dans l'intervalle [(a+b)/2, b]
-Si f(a+b) /2 = 0 alors (a+b) / 2 est zéro de f
Le plus souvent on ne pourra pas trouver une valeur exacte seulement une valeur approchée.
Dans l'algorithme par dichotomie on s'arrête au bout de n étapes afin d'obtenir une précision ε telle que (b-a)/2n <= ε
Soit n>= (log(b-a) – log(ε))/ log(2)
Application
def dichotomie(a, b, f, eps):
if(fabs(a - b) <= eps): return a ou b ou (a+b)/2.0
m = (a+b)/2
if f(m)==0: return m
if f(a) * f(m) <= 0: return dichotomie(a, m, f, eps)
elif f(m) * f(b) <= 0:return dichotomie(m,b, f, eps)
vérification : pour déterminer le zéro de g(x) = x**(1/2) * cos(x)
from math import *
def g(x):
return x**(1/2) * cos(x)
x,y = 1,2
R=dichotomie(x, y, g ,0.000000000&)
print("Valeur du zéro de la fonction f sur [%s,%s] :%s" %(x, y, R))

2
CPGE Informatique MPSI / 1TSI /PCSI
Lydex – Ben guerir Programmation Mr L. BOUHOU

11.2.2. Méthode de Newton

La méthode de Newton appelée également méthode de Newton-Raphson a pour but de réaliser l'approximation d'une
fonction affine g d'une fonction f différentiable en un point a.
Principe : approximation d'une fonction en se basant sur le développement de Taylor au premier ordre.
- On choisit un point de départ x0 proche de la solution recherchée.
- On fait alors une approximation grossière en la considérant égale à sa tangente f(x) ~ f(x0) + f ’ (x0) * (x-x0).
- On détermine alors le point d'intersection avec l'axe des abscisses en résolvant l'équation :f(x0) + f ’ (x0) * (x-x0)=0
- On obtient alors le point x1. Et on réitère le processus à partir de ce point.
- On construit par récurrence la suite : xn+1= xn - (f(xn)/f’(xn))

Méthode de Newton
Itérativement Récursivement
def f(x): def newton(f, df, xi, n):
return exp if(n == 0): return xi
def df(x): else:
return exp return newton(f, df, xi - f(xi)/df(xi), n-1)
def newton(f, df, xi, n):
for i in range(n):
xi= xi - f(xi)/df(xi)
return xi

Ou encore:
def newton(f, df, xi, eps):
xj=xi-f(xi)/df(xi)
while abs(xi – xj)>eps:
xi=xj
xj= xi - f(xi)/df(x)
return xj

3
CPGE Informatique MPSI / 1TSI /PCSI
Lydex – Ben guerir Programmation Mr L. BOUHOU

Ou encore

def f(x):
return exp
def df(f,x,h):
return (f(x+h)-f(x-h)) / (2*h)
def newton(f, xi ,h ):
xj=xi-f(xi)/df(f,xi,h)
while abs(xi – xj)>h:
xi=xj
xj= xi - f(xi)/df(f,x,h)
return xj

Application : calcule d’une approximation du zero de g(x) = x- log(x) – 3 au voisinage de 2

From math import * def verifier() :
def g(x): x0 = 2
return x- log(x)-3 h=0.0001
print("Abcisse du zéro (méthode Newton) :", newton(g, x0, h))
def dg (f,x, h):
return (f(x+h)-f(x-h)) / (2*h) verifier()  Abcisse du zéro (méthode Newton) : 4.505241495792883

11.3. Méthode d’Intégration

Soit une fonction f à valeurs réelles, continue par morceaux sur un intervalle [ a , b ]. On souhaite calculer une valeur
approchée de l’intégrale ∫ ( )
11.3.1. Méthode des rectangles

4
CPGE Informatique MPSI / 1TSI /PCSI
Lydex – Ben guerir Programmation Mr L. BOUHOU
La méthode des rectangles consiste à approximer la fonction f par une fonction en escalier. On considère un entier n
et un pas de subdivision . Pour tout entier k de [0,n], on pose ak=a+k* . Sur l’intervalle [ak , ak+1], on
approxime f par la fonction constante égale à f( ) (voir figure 9.1)
On prend, comme valeur approchée de l’intégrale de f sur [a,b], l’intégrale de la fonction en escalier ainsi construite,
c'est-à-dire la somme des aires des rectangles(les rectangles ont tous une base de longueur ).

Une implémentation de la méthode des rectangles pour calculer ∫ ( ) en subdivisant l’intervalle [a,b] en n
intervalles est proposée ci-après. En voici le code Python.
def rectangles (f,a,b,n) : #Méthode des rectangles
S=0
for i in range (0,n):
xi=a+(b-a)*i/n
xj=a+(b-a)*(i+1)/n
S+=f((xi+xj)/2.0)*(xj-xi)
return S

on peut montrer que :

( ) ( ) ( )
∫ ( ) ∑ ( )
par conséquence, notre fonction rectangles() peut s’écrire de la façon suivante :
def rectangles (f,a,b,n) : #Methode des rectangles
S=0
for i in range (0,n):
xi=a+(b-a)/2*n + i * (b-a)/n
S+=f(xi)
return((b-a)/n) * S
11.3.2. Méthode des trapèzes
La méthode des trapèzes consiste à approximer la fonction f par une fonction continue affine par morceaux. Ceux-ci
coïncident avec la fonction f au point de la subdivision (voir figure 9.2). En notant ak = a+k* les points de la

5
CPGE Informatique MPSI / 1TSI /PCSI
Lydex – Ben guerir Programmation Mr L. BOUHOU
( ) ( ( ) ( ))
subdivision du segment [a,b], l’aire de chaque trapèze est égale à , c'est-à-dire, en
sommant,
( ) ( )
∫ ( ) ( ∑ ( ))

Voici une implémentation de la méthode des trapèzes en Python:

def trapezes(f,a,b,n):#Methode des trapezes
S=0
for i in range (0,n):
xi=a+(b-a)*i/float(n)
xj=a+(b-a)*(i+1)/float(n)
S+=(f(xi)+f(xj))/2.0*(xj-xi)
return S