2016

PC*

Ingnierie numrique et simulation

I.

Intgration numrique . . . . . . . . . . . . . . . . . .
I.1
Principe gnral . . . . . . . . . . . . . . . . .
I.2
La mthode des rectangles . . . . . . . . . . . .
I.3
La mthode des trapzes . . . . . . . . . . . . .
I.4
Utiliser scipy.integrate . . . . . . . . . . . .
II. Recherche des zros dune fonction . . . . . . . . . . .
II.1
Recherche dun zro de fonction par dichotomie
II.2
Mthode de Newton . . . . . . . . . . . . . . .
II.3
Mthode du point xe . . . . . . . . . . . . . .
II.4
Utiliser scipy.optimize . . . . . . . . . . . . .
III. Rsolution approche dune quation direntielle . . .
III.1 Principe de la mthode . . . . . . . . . . . . .
III.2 Mise en oeuvre . . . . . . . . . . . . . . . . . .
III.3 Utilisation de la bibliothque scipy . . . . . .
IV. Rsolution dun systme linaire : Pivot de Gauss . . .
IV.1 Oprations lmentaires . . . . . . . . . . . . .
IV.2 Le pivot sur un exemple . . . . . . . . . . . . .
IV.3 Utilisation de numpy . . . . . . . . . . . . . . .

2014-2015

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

2
2
2
3
4
4
4
6
7
7
8
9
10
12
12
12
13
14

1/14

2016

PC*

I.

Python 5 Ingnierie numrique et simulation

Intgration numrique
tant donns deux rels a et b tels que a < b et une fonction f continue sur le segment [a, b], on
souhaite, laide de suites, obtenir une valeur approche de lintgrale de f sur [a, b].
On note I(f ) =

f (t)dt =
a

f lintgrale approcher.

Les valeurs de f peuvent provenir de la connaissance de la fonction, ou alors de la connaissance de

valeurs de la fonction pour certaines valeurs de t (dans le cas, par exemple, de mesures rgulires).

I.1

Principe gnral
Pour tout n N , on va partager le segment [a, b] laide dune subdivision (ai )06i6n pas constant
gal ba
n en posant
ba
i J0, nK, ai = a + i
n
Sur chaque segment [ai1 , ai ], on remplace f par une fonction dont on sait calculer lintgrale.
Nous prsentons deux mthodes.
La mthode des rectangles o les fonctions utilises pour approcher f sont constantes.
La mthode des trapzes o les fonctions utilises pour approcher f sont anes.

I.2
I.2.a

La mthode des rectangles

Dnition de la suite associe cette mthode
Sur chaque intervalle [ai1 , ai ], on remplace f par la fonction constante de valeur f (ai1 ).
Lintgrale de f est alors approche par la somme Rn (f ) des aires algbriques des rectangles de
sommets (ai1 , 0), (ai , 0), (ai , f (ai1 )) et (ai1 , f (ai1 )).
f (t)
n=8

Chaque rectangle a un ct de mesure (positive) ai ai1 =

f (ai1 ) de telle sorte que
n N , Rn (f ) =
I.2.b

ba
n

et un autre ct de mesure (algbrique)

X
b a n1
f (xi ).
n i=0

Convergence de cette suite

Si f est de classe C 1 sur lintervalle dintgration [a, b], alors on peut dmontrer que
|I(f ) Rn (f )| = O

1
.
n

Ainsi la suite (Rn (f ))nN converge vers I(f ).

2/14

2014-2015

2016

PC*

I.2.c

Python 5 Ingnierie numrique et simulation

Ordre de la mthode
Comme il existe un nombre M tel que |I(f ) Rn (f )| 6

M
, on dit que la mthode est dordre 1.
n

Des mathmatiques. Montrer laide de la fonction f : x 7 x a que la majoration en O

est atteinte et quainsi elle ne peut pas tre amliore en gnral.
I.2.d

1
n

Algorithme et complexit
def rectangles(f, a, b, n):
""" valeur approche de l'integrale de f sur [a,b]
application de la methode des rectangles"""
int_rect = 0
h = (b-a)/n
t = a
for k in range(n):
# t est ak = a + kh
Ra
# int_rect approxime a k f (t) dt
int_rect += h*f(t)
t += h
return int_rect


Exo. Estimer la complexit de lalgorithme prcdent.

I.3
I.3.a

La mthode des trapzes

Dnition de la suite associe cette mthode
Sur chaque segment [ai1 , ai ], on remplace f par la fonction ane qui concide avec f en ai1 et en ai .
Lintgrale de f est alors approche par la somme Tn (f ) des aires algbriques des trapzes de sommets
(ai1 , 0), (ai , 0), (ai , f (ai )) et (ai1 , f (ai1 )).

f (t)
n=8

Chaque trapze a une aire algbrique qui vaut

n N , Tn (f ) =

(b a) (f (ai ) + f (ai1 ))
de telle sorte que
n
2

n
baX
(f (ai ) + f (ai1 ))
2n i=1

ba
=
n
2014-2015

X
f (a) + f (b) n1
+
f (ai )
2
i=1

3/14

2016

PC*

I.3.b

Python 5 Ingnierie numrique et simulation

Convergence de cette suite

Si f est de classe C 2 sur lintervalle dintgration [a, b] alors on peut dmontrer que
1
|I(f ) Tn (f )| = O
.
n2
Ainsi la suite (Tn (f ))nN converge vers I(f ).
Sa convergence vers I(f ) est plus rapide que celle de la suite (Rn (f )).

I.3.c

Ordre de la mthode
Comme il existe un nombre M tel que |I(f ) Tn (f )| 6

M
,
n2

on dit que la mthode est dordre 2.

Des mathmatiques. Montrer laide de la fonction f : x 7 (x a)2 que la majoration en

O n12 est atteinte et quainsi elle ne peut pas tre amliore en gnral.
I.3.d

Algorithme et complexit
def trapezes(f,a,b,n):
""" valeur approche de l'integrale de f sur [a,b]
application de la methode des trapzes"""
h = (b-a)/n
int_trapeze = 0.
t = a
for k in range(n):
# t est ak
Ra
# int_trapeze approxime a k f (t) dt
int_trapeze += h * (f(t) + f(t+h)) / 2
t += h
return int_trapeze


I.4

Exercice. Estimer la complexit de lalgorithme prcdent.

Peut-elle tre simplement amliore ?

Utiliser scipy.integrate

La fonction scipy.integrate.trapz permet de mettre en uvre la mthode des trapzes sans la

programmer.
Si on peut/doit utiliser une fonction de bibliothque, on privilgiera scipy.integrate.quad, plus
rapide et performante que les mthodes au programme de notre classe.

II.

Recherche des zros dune fonction

Dans ce paragraphe, nous allons voir comment valuer numriquement une solution dquation de la
forme f (x) = 0.

II.1
II.1.a

Recherche dun zro de fonction par dichotomie

Principe
Si f (a) et f (b) sont de signe contraire, f tant continue, un zro de f se trouve entre a et b par le
thorme des valeurs intermdiaires. On peut le localiser dans lune des moitis du segment [a, b] en
tudiant le signe de f au milieu de [a, b].
4/14

2014-2015

2016

PC*

Python 5 Ingnierie numrique et simulation

Cf

a
b

II.1.b

Programme python

def dicho1(f, a, b, epsilon = 1e-6):

""" donne une valeur approche d'un zro de f epsilon prs par dfaut
On suppose a < b et f(a)*f(b)<= 0 """
assert f(a) * f(b) <=0, "Il n'y a peut-tre pas de zro entre {} et {}".format(a,b)
g = a
d = b
while d-g > epsilon:
# Invariant : un zro est entre g et d, et d-g > epsilon
m = (g + d)/2
if f(g)*f(m) <= 0: # attention au cas f(g) == 0
d = m # zro entre g et m
else:
g = m # zro entre m et d
return g

Cet algorithme se termine, et sa complexit est trs rapide (cf ci-dessous).

II.1.c

Remarque. On peut aussi proposer une version rcursive de cet algorithme.

Terminaison de lalgorithme
On veut ici justier que lalgorithme se terminera toujours. Cela revient justier que la condition d g > epsilon du while ne
restera pas toujours vraie (ce qui mnerait une boucle innie).
La longueur d g est initialise b a.
A chaque tour de boucle la longueur d g > 0 est divise par 2. Au bout de n tours de boucles on a donc 0 6 d g =
On en dduit quil existera un entier n tel que d g 6 epsilon et donc que la boucle while se terminera.

II.1.d

ba
.
2n

Correction de lalgorithme : utilisation dun invariant de boucle

On veut ici justier que lalgorithme fournit bien le rsultat que lon souhaite.
On a linvariant de boucle
f (g) et f (d) sont de signes contraires
En eet cet invariant est suppos vrai linitialisation et est conserv chaque tour de boucle.
On en dduit ainsi mathmatiquement ( laide du thorme des valeurs intermdiaires) lautre invariant de boucle
un zro de f est compris entre g et d
Par suite, en sortie de boucle, la condition d-g <= epsilon , garantit que g et d encadrent un zro de f epsilon prs ce
qui est ce quon voulait.

2014-2015

5/14

2016

PC*

II.1.e

Python 5 Ingnierie numrique et simulation

Complexit de lalgorithme

Ltude de la terminaison a permis de voir, quau bout de n tours de boucles, on avait lgalit
dg =

ba
2n

Le nombre n de tours de boucles eectus avant sortie de boucle vrie donc :

ba
ba
6 < n1
2n
2

| {z }

au tour n 1
on a d g >

Ce qui donne

2n1

Ainsi n = O ln

<

ba

ba

2n

puis n 1 <

ln ba

6 n.

ln(2)

Que lon comptabilise les comparaisons, les appels f ou les aectations, la complexit c vrie

 

c(a, b, ) = O ln

ba



Remarque. Supposons donne une fonction vriant les hypothses requises sur un intervalle [a, b].
Pour = 10p , le nombre doprations sera de lordre de

ln(b a) ln() = ln(b a) +p ln(10) .

| {z }
| {z }
cte

cte

Autrement dit, pour obtenir une prcision de lordre de 10p , le nombre doprations sera de lordre de p, pour p
grand.

II.2

Mthode de Newton
Lorsque f (que lon suppose sannuler une unique fois) est de classe C 2 et que sa drive ne sannule
pas, on peut sapprocher de son zro en prenant la tangente .
Cf

u1

u0

Cela revient dnir la suite donne par la relation de rcurrence :

un+1 = un

f (un )
f 0 (un )

qui converge, sous certaines hypothses, vers le zro de f .

6/14

2014-2015

2016

PC*

Python 5 Ingnierie numrique et simulation

def newton(f, fprime, u0, eps = 1e-6):

""" zro approche de f, x0 valeur initiale """
u = u0
v = u - f(u)/fprime(u)
k = 0
while abs(v - u) > eps and k < 50:
u = v # u = uk
v = v - f(v)/fprime(v) # v = uk+1
k += 1
return v

Le test de sortie est empirique, et ne mesure pas une vritable erreur entre uk et la valeur du zro
de f . En toute gnralit, il nest absolument pas able.
Pour plus de prcautions, on pourra une fois obtenue notre valeur approche, utiliser le test

f un

f un +
<0
2
2

On peut montrer le rsultat suivant :

Rsultat. (1)
Soit f de classe C 2 sur un intervalle I, qui sannule en et drive non nulle sur I. En notant
M2 = Sup|f 00 (t)| et m1 = Inf|f 0 (t)|, on a :
tI

tI

|xn+1 | 6

M2
2m1

2n 1

|u0 |2

ce qui assure la convergence de lalgorithme prcdent si

M2
2m1 |u0

| < 1.

Remarque. La mthode de Newton peut-elle sappliquer pour la recherche du zro dune fonction connue
par un chantillonnage ?

II.3

Mthode du point xe
En posant g(x) = f (x) + x, chercher un zro de f revient chercher un point xe de g. En tudiant
la suite dnie par la relation de rcurrence :
xn+1 = f (xn ) + xn
on peut avoir la convergence de cette suite vers un zro de f , par exemple lorsque g est contractante.
On peut aussi poser g(x) = f (x)+x avec susamment petit pour que cette condition soit satisfaite.

II.4

Utiliser scipy.optimize
>>> help("scipy.optimize.newton")
scipy.optimize.newton = newton(func, x0, fprime=None, args=(), tol=1.48e-08, maxiter=50, fprime2=None)
Find a zero using the Newton-Raphson or secant method.
Find a zero of the function `func` given a nearby starting point `x0`.
The Newton-Raphson method is used if the derivative `fprime` of `func`
is provided, otherwise the secant method is used. If the second order
derivate `fprime2` of `func` is provided, parabolic Halley's method
is used.
Parameters
----------

2014-2015

7/14

2016

PC*

Python 5 Ingnierie numrique et simulation

func : function
The function whose zero is wanted. It must be a function of a
single variable of the form f(x,a,b,c...), where a,b,c... are extra
arguments that can be passed in the `args` parameter.
x0 : float
An initial estimate of the zero that should be somewhere near the
actual zero.
fprime : function, optional
The derivative of the function when available and convenient. If it
is None (default), then the secant method is used.
args : tuple, optional
Extra arguments to be used in the function call.
tol : float, optional
The allowable error of the zero value.
maxiter : int, optional
Maximum number of iterations.
fprime2 : function, optional
The second order derivative of the function when available and
convenient. If it is None (default), then the normal Newton-Raphson
or the secant method is used. If it is given, parabolic Halley's
method is used.
Returns
------zero : float
Estimated location where function is zero.
See Also
-------brentq, brenth, ridder, bisect
fsolve : find zeroes in n dimensions.

III.

Notes
----The convergence rate of the Newton-Raphson method is quadratic,
the Halley method is cubic, and the secant method is
sub-quadratic. ... couic... where the function changes
sign. The brentq algorithm is recommended for general use in one
dimensional problems when such an interval has been found.

Rsolution approche dune quation direntielle

En mathmatiques, nous tudions les quations direntielles linaires du premier ordre (EDL1).
1
Par exemple, nous savons montrer que les solutions sur R+ de lquation y 0 (t) y(t) = tet sont les fonctions t 7 t + tet o
t
R.
2
Pour lquation
y 0 (t) + 3y(t) = et sur R, on a aussi une formule exacte pour lexpression des solutions mais qui fait apparaitre
Z
lintgrale

e3t et dt que lon ne sait pas calculer. La situation se complique.

De manire gnrale, pour une EDL1 :

y 0 (t) + (t)y(t) = (t) o , continues sur un intervalle I
on a des solutions analytiques (cest--dire quon a des formules explicites), mais qui font intervenir deux intgrales, quon ne sait
pas toujours calculer.
Pire encore, beaucoup de phnomnes physiques et biologiques (pendule amorti, cintique chimique, thermodynamique, balistique,
dynamique des populations ...) conduisent des quations direntielles non linaires pour lesquelles il ny a pas de solution
analytique. Par exemple, des quations du type :
00 (t) = 2 sin((t))
ou alors y 0 (t) = cos t + cos (y(t))

8/14

2014-2015

2016

PC*

Python 5 Ingnierie numrique et simulation

Pour pouvoir traiter tous ces exemples (en particulier ceux non linaires), on considre ici une quation direntielle dordre 1 crite
sous la forme :
y 0 (t) = F (y(t), t)
Par exemple, si lquation est :
y 0 (t) y(t) = 0 alors F : (y, t) 7 y
y 0 (t) + ty(t) 2 = 0 alors F : (y, t) 7 2 ty
y 0 (t) = cos t + cos(y(t)) alors F : (y, t) 7 cos t + cos y
00 (t) = 2 sin (t) alors F : (Y, t) 7 (Y [1](t), 2 sin(Y [0](t)) o Y = (Y [0], Y [1]) = (, 0 )
Il existe des conditions sur F pour que tout problme de Cauchy :

y 0 (t) = F (y(t), t)
y(t0 ) = y0

ait une unique solution.

Dans la suite, nous allons tudier la mthode dEuler, mthode numrique permettant dobtenir une approximation de la solution
dun tel problme de Cauchy.

III.1

Principe de la mthode
(

y 0 (t) = F y(t), t)
avec t0 , y0 xs.
y(t0 ) = y0
On souhaite obtenir une approximation de la fonction y sur lintervalle [a, b].
Soit y lunique solution de

Soit n N . On subdivise lintervalle [a, b] en n petits segments de mme longueur h =

On pose alors :
t0 = a

t1 = t 0 + h

t2 = t0 + 2h

...

tk = t0 + kh

...

ba
.
n

tn = t0 + nh = b

On part de t0 .
On approche le petit morceau de courbe entre t0 et t1 par la tangente la courbe au point dabscisse t0 .
solution exacte

y2

M2

y1
y0

M0

M1

t0

solution approche

t1 =t0 +h t2 =t0 +2h

On alors :
y(t1 ) y(t0 )
y 0 (t0 )
h
F (y(t0 ), t0 )
y(t1 ) y0 + hF (y0 , t0 )
2014-2015

9/14

2016

PC*

Python 5 Ingnierie numrique et simulation

On pose : y1 = y0 + hF (y0 , t0 ). Le nombre y1 est une approximation de la valeur exacte y(t1 ).

On recommence le procd partir du point M1 (t1 , y1 )...
De manire gnrale, on pose :
k {0, . . . , n 1},

yk+1 = yk + hF (yk , tk )

Ce qui amne construire successivement les points Mk (tk , yk ). La ligne polygonale reliant ces points
est alors une approximation de la courbe reprsentative de la solution.
Cette mthode de rsolution approche, la seule notre programme, sappelle la mthode dEuler
(explicite). Il existe de nombreuses autres mthodes qui peuvent tre proposes dans le cadre dun
problme.

III.2
III.2.a

Mise en oeuvre
Equations scalaires dordre 1
Dans ce programme, on donne la valeur du pas h et on en dduit la valeur de n tel que a + nh 6 b < a + (n + 1)h, de sorte
que en gnral a + nh = tn 6= b, mais ce nest pas grave puisque a + nh = tn b.

def euler(F, a, b, Y0, h=1e-2):

"""Fournit une solution approche l'quation Y'=F(Y,t), Y(a)=Y0
sur l'intervalle [a,b] par la mthode d'Euler
le pas utilis est h, par dfaut 0.01
La solution renvoye est une liste de valeurs pour les_t,
et une liste de valeurs pour les_Y"""
Y = Y0
t = a
les_Y = [Y]
les_t = [t]
n = int((b-a)/h)
for k in range(n):
# Y contient yk et t contient tk
Y = Y + h * F(Y, t)
les_Y.append(Y)
t += h
les_t.append(t)
# la fin de la boucle, t contient a + nh b
return les_t, les_Y


III.2.b

Systmes de deux quations scalaires dordre 1

La mthode dEuler sapplique aussi des systmes dquations direntielles dordre 1 :
(

x0 (t) = F1 (x(t), y(t), t)

y 0 (t) = F2 (x(t), y(t), t)

Il y a deux fonctions inconnues x et y, drivables sur un intervalle I.

Exemple. Systme proie-prdateur de Lotka-Voltera :
(

x0 (t) = 2x(t) x(t)y(t)

y 0 (t) = x(t)y(t) 2y(t)

10/14

2014-2015

2016

PC*

Python 5 Ingnierie numrique et simulation

Ici t dsigne toujours le temps, mais x(t) est le nombre de proies linstant t, et y(t) est le nombre
des prdateurs linstant t. Les drives x0 et y 0 reprsentent donc les variations des populations
de proies et de prdateurs au cours du temps.
La mthode dEuler sadapte : on part des donnes initiales x0 et y0 et on dnit :
(

xk+1 = xk + hF1 (xk , yk , tk )

yk+1 = yk + hF2 (xk , yk , tk )

k {0, . . . , n 1},

On a alors plusieurs choix pour la reprsentation graphique des rsultats :

On peut tracer deux courbes, x en fonction de t et y en fonction de t.
On peut aussi tracer la trajectoire de la solution, cest--dire lensemble des points de coordonnes
(x(t), y(t)), avec t variant dans I((t nest quun paramtre).
x = x(t)
Cest la courbe paramtre par
.
y = y(t)
III.2.c

Equations scalaires dordre 2 ou plus

Une quation direntielle scalaire dordre 2 ou plus doit dabord tre vectorise pour tre rsolue par
la mthode dEuler. Ainsi, lquation direntielle :
y (p) = G(y (p1) , . . . , y 0 , y, t)

est quivalente au systme :

Y =

y0

y 00

..

= y0
= y 00

y (p1)

y (p)

y
y0
..
.

y (p1)

soit encore Y 0 = F (Y, t) o on a pos :

= y (p1)
= G(y (p1) , . . . , y 0 , y, t)

x1
x2
..
.

, t 7
et F :

xp1

xp

x2
x3
..
.

xp
G(xp , xp1 , . . . , x2 , x1 , t)

Il faut alors adapter lgrement la dnition de la fonction euler pour le cas vectoriel.
def euler(F, a, b, Y0, h=1e-2):
"""Fournit une solution approche l'quation Y'=F(Y,t), Y(a)=Y0
sur l'intervalle [a,b] par la mthode d'Euler
le pas utilis est h, par dfaut 0.01
La solution renvoye est un np.array pour les t,
et un np.array pour les Y"""
n = int((b-a)/h)
Y0 = np.array(Y0)
p, = Y0.shape
T = np.linspace(a,b,n+1) # cf aide fonction linspace, n + 1 valeurs de t quirparties,
# en partant de a = T [0], la dernire tant T [n] = b ici
Y = np.zeros((p, n+1))
Y[:,0] = Y0
for k in range(n):
Y[:,k+1] = Y[:,k] + h * F(Y[:,k], T[k])
return T, Y


2014-2015

11/14

2016

PC*

III.3

Python 5 Ingnierie numrique et simulation

Utilisation de la bibliothque scipy

Pour rsoudre une quation direntielle dordre 1 (scalaire ou vectorielle) avec scipy, on commence
par charger la fonction odeint qui permet de rsoudre numriquement des quations direntielles :
from scipy.integrate import odeint


La syntaxe est la suivante :

odeint(F, y0, t)
Expliquons les dirents lments qui interviennent :
lquation direntielle est crite sous la forme : y 0 (t) = F (y(t), t) sur un segment [a, b].
t est un tableau de temps entre a et b de la forme : t = [t0=a,t1,...,tn=b].
La condition initiale est alors y(a) = y0.
Remarque. Contrairement lusage mathmatique, la fonction F prend le temps comme deuxime
argument et non comme premier.

Exemple. Considrons lquation direntielle :

y0 = y
y(0) = 1

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt
def F(y,t):
return y
les_t = np.linspace(0, 5, 50)
sol = odeint(F, 1, les_t)
plt.plot(les_t, sol)
plt.show()


IV.

Rsolution dun systme linaire : Pivot de Gauss

Lalgorithme de Gauss permet de rsoudre un systme linaire de n quations p inconnues AX = B.
Numriquement, on travaille dans le cas o A est carre inversible, cest--dire que ce systme admet
une unique solution.

IV.1

Oprations lmentaires
Les trois oprations lmentaires sur les lignes Li dune matrice sont
les dilatations Li Li , o est un rel non nul,
les transvections Lj Lj + Li , o est un rel quelconque,
les permutations ou transpositions Li Lj .
On donne les algorithmes des transvections, dilatations, permutations en python ci-dessous. Les indices
utiliss sont ceux de python. Ils commencent zro.
12/14

2014-2015

2016

PC*

IV.1.a

Python 5 Ingnierie numrique et simulation

Transvection
La fonction transvection prend en paramtres une matrice A, un indice de ligne j, un indice de ligne
i et un rel .
Elle modie sur place la matrice A en eectuant Lj Lj + Li .
def transvection_np (A, i, j, mu):
"""transforme sur place le np.array A via la transvection """ # Li Li + Lj
A[i, :] += mu * A[j, :]
return None


IV.1.b

Permutation ou transposition
La fonction permutation prend en paramtres une matrice A, un indice de ligne i et un indice de
ligne j.
Elle modie sur place la matrice A en eectuant Li Lj .
def permutation_np (A, i, j):
""" transforme sur place le np.array A via la permutation""" # Li Lj
A[[j,i], :] = A[[i,j], :]
return None


IV.1.c

IV.2

Dilatation

def dilatation_np (A, i, alpha):

""" transforme sur place le np.array A via la dilatation""" # Li Li
A[i, :] *= alpha
return None

Le pivot sur un exemple

A = np.array([[1,3,4],
[3,5,-4],
[4,7,-2]])
B = np.array([50,2,31])
n,p = A.shape
# les calculs doivent tre mens en flottants (divisions non entires)
A, B = A.astype(float), B.astype(float)
# On cre la matrice augmente C=(A|B) pour effectuer simultanment les
# oprations sur A et B.
B.shape=(n,1)
C = np.concatenate((A,B),axis=1)
# On chelonne la matrice
for k in range(n):
# on choisit le pivot de valeur absolue maximale
# dans le bas de la colonne k
piv_candidats = C[k:,k]
k_piv = k + np.argmax(np.abs(piv_candidats))
piv = C[k_piv,k]
assert piv != 0, 'Systme non inversible'

2014-2015

13/14

2016

PC*

Python 5 Ingnierie numrique et simulation

# change des lignes k et k_piv:

C[[k,k_piv], :] = C[[k_piv,k], :]
# Annulation des termes sous le pivot
for i in range(k+1,n):
mu = C[i,k] / piv
C[i,:] -= mu * C[k,:]
# On annule les termes au dessus de chaque pivot
for k in range(n-1,-1,-1):
piv = C[k,k]
for i in range(k):
mu = C[i,k] / piv
C[i,:] -= mu * C[k,:]
# On dilate chaque ligne pour rendre les termes diagonaux gaux 1
for k in range(n):
piv = C[k,k]
C[k,:] /= piv
# La solution est la dernire colonne de la matrice C
sol = C[:,-1]
print(sol)
# [ 3. 5. 8.]
print(A.dot(sol))
# [ 50. 2. 31.] pour vrification


IV.3

On peut montrer que lalgorithme du pivot de Gauss a une complexit temporelle en O(n3 ). Lors du
calcul, il faut se mer des oprations termes termes sur les tableaux numpy.

Utilisation de numpy

La fonction numpy.linalg.solve permet de rsoudre les systmes linaires AX = B.

14/14

2014-2015