COMMANDE OPTIMALE DES PROCESSUS

Prof. Dr. Techn. Olivier BARAKA MUSHAGE

Notes de cours
Cover
 Table des matières

1 Introduction 1

1.1 Objet de la commande optimale .............. 2

1.2 Formulation du problème de commande optimale
............................................................... 3
1.2.1 Détermination du modèle mathématique du système ....... 3
1.2.2 Formulation de l’indice de performance et des contraintes physiques
............................................................. 4

1.3 Initiation aux calculs des solutions analytiques

symboliques avec Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.1 Calcul des solutions analytiques des intégrales . . . . . . . . . . . . 8
1.3.2 Calculs des solutions analytiques des Dérivées . . . . . . . . . . . . 9
1.3.3 Résolution des systèmes d’équation linéaires . . . . . . . . . . . 10
1.3.4 Substitution des valeurs dans une fonction . . . . . . . . . . . . . . 11
1.3.5 Solution analytique des équations différentielles . . . . . . . . . 13

1.4 Initiation aux calculs matriciels avec Python 17

1.4.1 Initiation aux solutions numériques des équations différentielles
ordinaires non-linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2 Conception des contrôleurs à re-

tour d’état 21

i
 ii TABLE DES MATIÈRES

2.1 La représentations d’état . . . . . . . . . . . . . . . . . . . . . . 22

2.1.1 Le concept d’état . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.1.2 L’équation différentielle du vecteur d’état . . . . . . . . . . . . . . . . 23
2.1.3 Les équations d’état dérivées des fonctions de transfert . . . 28

2.2 Solution de l’équation différentielle d’état 30

2.3 Contrôle des systèmes multi-variables . . . . 40
2.3.1 Contrôlabilité et observabilité . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.3.2 Conception du contrôleur à retour d’état . . . . . . . . . . . . . . . . 43
2.3.3 Conception des observateurs d’état . . . . . . . . . . . . . . . . . . . . . 51
2.3.4 Effet d’un observateur d’état complet sur un système en boucle
fermée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
2.3.5 Cas de poursuite d’une de référence non nulle . . . . . . . . . . . 64

2.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

3 Linéarisation des systèmes non

linéaires et Éléments de calculs variationnels
73

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.2 Proposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.3 Conditions d’optimalité . . . . . . . . . . . . . . . . . . . . . . . . 75
3.4 Quelques cas particuliers ou contraintes . 78
3.4.1 Cas 1 : Temps final t1 spécifié . . . . . . . . . . . . . . . . . . . . . . . . . 79
3.4.2 Cas 2 : Temps final t1 non-spécifié . . . . . . . . . . . . . . . . . . . . . 85
TABLE DES MATIÈRES iii

3.4.3 Cas 3 : État final devant se trouver sur une surface . . . . . . 85

3.5 Principe de Pontryagin . . . . . . . . . . . . . . . . . . . . . . . . 89

3.5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
3.5.2 Énoncé du principe du minimum de Pontryagin . . . . . . . . . . 90

3.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

4 Régulateurs Linéaires avec Coût

Quadratique 95

4.1 Indices de performance quadratiques . . . . . . 96

4.2 Le régulateur quadratique linéaire . . . . . . . . . 98
4.3 Régulateur quadratique linéaire avec un état
final non nul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
4.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
iv TABLE DES MATIÈRES
1.1 Courbe de la fonction f (x) = x 7 + 6x 3 + 10x 2 + 21x + 10 pour
x variant entre 0 et 10 . . . . . . . . . . .√. . . . . . . . √. . . . . . . . 12
1.2 Courbe de la fonction y(t) = (−2 sin( 2 2 ) − 4 cos( 2 2t ) +
t

5) exp(t) pour t variant entre 0 et 10 . . . . . . . . . . . . . . . . . . 14

1.3 Courbe de y1 (t), y2 (t) et y3 (t) pour t variant entre 0 et 1 . . . . . 16
1.4 Portraits de phase (a) z(t) en fonction de x(t) et (b) z(t) en
fonction de y(t) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2.1 Système ressort-masse-amortisseur et le diagramme de corps

libre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.2 Circuit RLC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.3 Système à deux masses et le diagramme de corps libres . . . . . 27
2.4 Réponse temporelle du système masse-amortisseur-ressort
avec une entrée nulle u(t) = 0 . . . . . . . . . . . . . . . . . . . . . . 37
2.5 Réponse temporelle du système masse-amortisseur-ressort
avec une entrée échelon unité u(t) = 1 . . . . . . . . . . . . . . . . 40
2.6 Contrôle avec retour d’état . . . . . . . . . . . . . . . . . . . . . . . . 44
2.7 Réponse temporelle et signal de contrôle u(t) pour l’exemple
2.10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.8 Un simple observateur d’état d’ordre complet . . . . . . . . . . . . . 52
2.9 Un observateur d’état de Luenberger d’ordre complet . . . . . . . . 53
2.10 Système contrôlé en boucle fermée avec un observateur complet 60
2.11 Les états du système avec leurs estimations données par l’ob-
servateur d’état . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
2.12 Sortie du système forcée à suivre la référence r = 4 . . . . . . . . 67
2.13 Moteur DC avec contrôle statorique . . . . . . . . . . . . . . . . . . 69
2.14 Schéma bloc d’un servomécanisme de positionnement . . . . . . . 70
2.15 Système en boucle fermée . . . . . . . . . . . . . . . . . . . . . . . . 70
2.16 Système cruse control d’un véhicule . . . . . . . . . . . . . . . . . . 71
2.17 Le système de stabilisation du roulis d’un bateau . . . . . . . . . . 72

3.1 Trajectoire optimale x(t) et la commande optimale u(t) pour

l’exemple 3.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
3.2 Trajectoire optimale x(t) et la commande optimale u(t) pour
l’exemple ?? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

v
vi TABLE DES FIGURES

3.3 Trajectoire optimale x(t) et la commande optimale u(t) pour

l’exemple 3.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

4.1 Régulateur optimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

4.2 La trajectoire optimale du système et sa commande optimale . . . 104
4.3 Les états du système ia (t)etω(t) . . . . . . . . . . . . . . . . . . . . . 109
4.4 La commande optimale u(t) . . . . . . . . . . . . . . . . . . . . . . . . 109
1
 2 CHAPITRE 1. INTRODUCTION

1. Introduction

1.1 Objet de la commande optimale

Dans le monde réel on trouve plusieurs types de systèmes dont les ori-
gines sont très diverses : mécanique, électricité, électronique, biologie, chi-
mie, économie... Afin d’amener chacun de ces systèmes d’un état initial donné
à un certain état final, en respectant éventuellement certains critères, la
théorie du contrôle donne les moyens pour appliquer sur ces systèmes une
commande (ou contrôle). L’objectif peut être de stabiliser le système pour
le rendre insensible à certaines perturbations (stabilisation), ou encore de
déterminer des solutions optimales pour un certain critère d’optimisation
(contrôle optimal).
Dans les industries modernes où la notion de rendement est prépondé-
rante, le rôle de l’automaticien est de concevoir, de réaliser et d’optimiser,
tout au moins d’améliorer les méthodes de contrôle existantes. Ainsi, les do-
maines d’application du contrôle optimal sont multiples lorsqu’il s’agit de
faire passer un système d’un état initial à un état final en minimisant un
certain critère : aérospatiale, automobile, robotique, aéronautique, internet
et les communications en général, mais aussi le secteur médical, chimique,
génie des procédés, etc.
Pour introduire la notion de commande optimale, considérons l’exemple
suivant : Pour arrêter la rotation d’un rotor tournant à une vitesse constante,
on peut lui appliquer une charge extérieure u(t) perpendiculaire à son axe
de rotation. Il s’agit de déterminer la commande u(t) qui permet d’amener
la vitesse de rotation du système de v = v0 à v = 0. Cette détermination
répond souvent à un objectif tel que l’arrêt du système en un temps minimum.
Trouver u(t) qui répond à cet objectif est l’objet de la théorie de la commande
optimale.
1.2. FORMULATION DU PROBLÈME DE COMMANDE OPTIMALE3

On considère que la théorie moderne du contrôle optimal a commencé

dans les années 50, avec la formulation du principe du maximum de Pontrya-
gin, qui généralise les équations d’Euler-Lagrange du calcul des variations.
Dès lors, la théorie a connu un essor spectaculaire, ainsi que de nombreuses
applications.
De nos jours, les systèmes automatisés font complètement partie de notre
quotidien (nous en sommes souvent inconscients), ayant pour but d’amélio-
rer notre qualité de vie et de faciliter certaines tâches : système de freinage
ABS, assistance à la conduite, servomoteurs, thermostats, circuits frigori-
fiques, contrôle des flux routiers, ferroviaires, aériens, boursiers, fluviaux, bar-
rages hydroélectriques, photographie numérique, filtrage et reconstruction
d’images, lecteurs CD et DVD, réseaux informatiques, moteurs de recherche
sur internet, circuits électriques, électroniques, télécommunications en géné-
ral, contrôle des procédés chimiques, raffinage pétrolier, chaînes industrielles
de montage, peacemakers et autres systèmes médicaux automatisés, opé-
rations au laser, robotique, satellites, guidages aérospatiaux, bioréacteurs,
distillation, ... La liste est infinie, les applications concernent tout système
sur lequel on peut avoir une action, avec une notion de rendement optimal.
Ce cours va se limiter principalement à la présentation de la théorie du
contrôle optimal pour des systèmes de contrôle linéaires, ainsi que la théorie
dite linéaire-quadratique et ses applications : régulation, stabilisation.

1.2 Formulation du problème de commande opti-

male

Chaque problème de commande optimale nécessite une description des

propriétés dynamiques du processus à commander. Cette description est sou-
vent donnée sous forme d’un modèle mathématique.

1.2.1 Détermination du modèle mathématique du système

Les systèmes commandés sont décrits par des variables d’état. Par exemple :

(a) Systèmes linéaires continus commandés

 4 CHAPITRE 1. INTRODUCTION

Ẋ = A(t)X + B(t)u où X ∈ Rn et u ∈ Rm .
Dans le cas où les matrices A et B sont constantes, on dit que le
système est stationnaire (invariant linéaire dans le temps ou LTI :
Linear Time Independent).
(b) Systèmes non linéaires continus commandés
Ẋ = f (X , U, t)
où f (X , U, t) est une fonction vectorielle non linéaire.
(c) Systèmes discrets linéaires
Xk+1 = Ak Xk + Bk uk
(d) Systèmes discrets non linéaires
Xk+1 = f (Xk , uk , k)
Outre ce modèle, il faut formuler, pour un problème de commande optimale,
le critère de performance à optimiser et les contraintes physiques.

1.2.2 Formulation de l’indice de performance et des contraintes

physiques

Il s’agit d’une grandeur mathématique désignée dans la littérature tech-

nique, selon le domaine, par : critère (en automatique), fonction coût (en
économie), fonctionnelle (en mathématique). Dans ce cours, on utilise le mot
"critère" pour désigner l’indice de performance.

Remarque 1.1. Sur le plan pratique il n’est pas facile de déterminer un

critère ; toutefois, on peut toujours le ranger dans l’une des catégories sui-
vantes :
– minimiser un temps (ex. minimiser le temps de freinage ou de dépla-
cement) ;
– optimiser une amplitude (ex. maximiser une force ou minimiser une
tension) ;
– minimiser une erreur (ex. réduire l’écart entre une trajectoire et sa
référence) ;
– minimiser une consommation (minimiser la quantité d’énergie utile à
la réalisation d’un travail).
1.2. FORMULATION DU PROBLÈME DE COMMANDE OPTIMALE5

Considérons un système à contrôler (linéaire ou non-linéaire) décrit par

ẋ = F(t, x, u), x(t0 ) = x0 ∈ Rm (1.1)

   
x1 (t) u1 (t)
   
où x(t) =  ...  est le vecteur d’état, u(t) =  ...  est le vecteur de
xm (t) ul (t)
m
contrôle et F ∈ R est un vecteur défini comme suit
Fi → Fi (t, x1 (t), x2 (t), · · · , xm (t), u1 (t), · · · , ul (t)), i = 1, 2, · · · , m
Remarque 1.2. Nous allons supposer que les fonctions Fi sont continues et
satisfont les conditions standards, telles que avoir des dérivées partielles du
premier ordre continues (de sorte que leur solution existe et est unique pour
la condition initiale donnée). Dans ce cas on dit que F est continuellement
différentiable (ou de classe C 1 ).

Le Problème de Contrôle Optimal (PCO)

Le problème de contrôle optimal général concerne la minimisation d’une
certaine fonction J = J[u], appelée indice de performance ou critère ; ou,
si on veut maximiser une fonction J cela revient à minimiser un critère −J.
L’indice de performance J fournit une mesure par laquelle la performance
d’un système est jugée.
Voici plusieurs exemples d’indices de performance :
1. Problèmes à temps minimal
Dans ce cas, le contrôle u(t) doit être choisi de sorte à faire passer
le système d’un état initial donné x0 vers un état final spécifié x(t1 )
en un délais le plus petit possible. Ceci équivaut à minimiser l’indice
de performance donné comme suit
Z t1
J := t1 − t0 = dt (1.2)
t0

où t1 est le premier instant auquel l’état désiré est atteint.

2. Contrôle Terminal
Dans ce cas l’état final xf = x(t1 ) doit être amené le plus prêt possible
de l’état désiré x̄(t1 ). Il convient dans ce cas de minimiser l’indice de
performance suivant :
J := eT (t1 )Me(t1 ) (1.3)
6 CHAPITRE 1. INTRODUCTION

où e(t) := x(t) − x̄(t) et M est une matrice symétrique définie positive

(c’est-à-dire M T = M > 0, detM > 0).
Un cas spécial est celui où M est une matrice unité, alors :
J = xf (t1 ) − x̄(t1 )2
Remarque 1.3. De manière plus générale, si M = diag(λ1 , λ2 , · · · , λm ),
alors les éléments λi sont choisies de sorte à pondérer l’importance
relative des différences (xi (t1 ) − x̄i (t1 ). Si certaines variables xi (t1 ) ne
sont pas spécifiées alors les éléments correspondants de M seront
nuls et M sera seulement semi-défini positif (M T = M ≥ 0).
3. Effort Minimum
L’état final désiré doit dans ce cas être atteint avec dépense mini-
male d’effort de contrôle. Les indices des performances devant être
minimisés dans ce cas sont :
Z t1 l
X
J := βi |ui |dt (1.4)
t0 i=1

ou Z t1
J := uT Rudt (1.5)
t0

où R = [rij ] est une matrice symétrique défini-positive (R T = R > 0)

et βi et rij sont des facteurs de pondération.
4. Problème de poursuite
L’objectif dans ce cas est de suivre ou "poursuivre" de plus prêt possible
un état désiré donné x̄(·) pendant un intervalle de temps [t0 , t1 ]. Dans
ce cas, l’indice de performance est :
Z t1
J := eT Qedt (1.6)
t0

avec Q une matrice symétrique définie positive (Q T = Q > 0).

Remarque 1.4. Ces genres de systèmes sont appelés servoméca-
nismes ; pour le cas spécial lorsque x̄(·) est constant ou nul on parle
de régulateur. Si les éléments ui (·) sont non bornés, alors le problème
de minimisation peut mener à des vecteurs de contrôle avec des com-
posantes infinies. Ceci n’est pas acceptable pour des problèmes du
1.2. FORMULATION DU PROBLÈME DE COMMANDE OPTIMALE7

monde réel ; ainsi, pour restreindre l’effort de contrôle total, l’indice

de performance suivant peut être utilisé :
Z t1


J := eT Qe + uT Ru dt (1.7)
t0

Les expressions de la forme de (1.5), (1.6) et (1.7) sont appelées indices

de performance quadratiques.
Exemple 1.1. Une navette d’atterrissage se sépare d’un vaisseau spa-
tial au temps t0 = 0 à une altitude h de la surface de la terre, avec
une vitesse initiale v⃗ (vecteur de direction vers le bas). Pour raison de
simplicité, on considère que les forces gravitationnelles sont négligées
et que la masse du véhicule est constante. Considérons seulement le
mouvement vertical, avec le haut considéré comme la direction posi-
tive. Considérons que x1 représente l’altitude, x2 la vitesse et u(·) la
poussée exercée par le moteur de propulsion, soumise à la contrainte
|u(t)| < 1 avec une mise à l’échelle convenable. Les équations du
mouvement sont

ẋ1 = x2
ẋ2 = u
et les conditions initiales sont
x1 (0) = h, x2 (0) = −v
Pour un atterrissage en douceur à un instant T on exige
x1 (T ) = 0, x2 (T ) = 0
Un indice de performance convenable serait
RT
J := 0 (|u| + k)dt
Cette expression représente la somme du total du carburant consommé
et le temps d’atterrissage, k étant un facteur qui pondère l’importance
de ces deux quantités.
Pour la formulation des contraintes physiques, il faut noter leur diversité
lors de la commande d’un processus ; ces contraintes peuvent être imposées
soit sur le temps final, soit sur la valeur de la commande, soit sur l’état du
système, etc.
On peut citer quelques exemples de contraintes physiques :
– temps final fixe : T est donné ;
 8 CHAPITRE 1. INTRODUCTION

– temps final libre ;

– état initial fixe ;
– contrainte sur l’état final X (T ), Ψ(X (T )) = 0 ;
– contrainte sur la commande u. Par exemple −1 ≤ u(t) ≤ 1
Remarque 1.5. La résolution des problèmes de commande optimale peut
exiger la détermination des solutions analytiques des certaines fonctions,
qui peut s’avérer longue et fastidieuse, avec des risques d’erreur, si faite
uniquement à la main. C’est pour cela que, pour permettre aux ingénieurs
de se focaliser sur d’autres aspects que mathématiques, il leur est recom-
mandé de recourir aux outils de calcul assisté par ordinateur, comme les
bibliothèques de calculs symboliques disponibles dans Matlab et Python
que nous présentons dans ce chapitre.

1.3 Initiation aux calculs des solutions analytiques

symboliques avec Python
La détermination des solutions analytiques des intégrales, des dérivées,
des équations différentielles ordinaires, des systèmes d’équations linéaires,
etc. peut être réalisée avec Python à l’aide de la boîte à outils donnée par
la bibliothèque Sympy.

1.3.1 Calcul des solutions analytiques des intégrales

Calcul des intégrales sans bornes d’intégration
Soit à déterminer la solution de l’intégration de la fonction f (x) par
rapport x. Pour cela, nous devons utiliser la méthode integrate(f (x), x) de
la bibliothèque Sympy. Par exemple, pour déterminer l’intégrale de f (x) =
x 2 + sin(x) on peut procéder comme suit dans Python :
1 from sympy import *
2
3 x = symbols ( ’x ’)
4 f = x **2 + sin ( x )
5 integrate (f , x )
R 3
Et on trouve que (x 2 + sin(x))dx = x3 − cos(x).
Ainsi, pour intégrer n’importe quelle fonction, nous pouvons juste rempla-
cer x 2 + sin(x) par la fonction à intégrer.
 1.3. INITIATION AUX CALCULS DES SOLUTIONS ANALYTIQUES
SYMBOLIQUES AVEC PYTHON 9
Calcul des intégrales avec bornes d’intégration
On peut aussi calculer une solution analytique d’un intégral avec Python
en tenant compte des bornes d’intégration. On peut utiliser la méthode
integrate de la bibliothèque Sympy en lui spécifiant les bornes d’intégration.
Voici un exemple de calcul de l’intégrale de x 2 + sin(x) entre les bornes 0 et
1:
1 from sympy import *
2

3 x = symbols ( ’x ’)
4 f = x **2 + sin ( x )
5 integrate (f ,( x ,0 ,1) )
4
Cette intégration donne comme résultat 3
− cos(1).

Intégration par rapport à plusieurs variables

Pour trouver la solution analytique d’une intégrale par rapport à plu-
sieurs variables en utilisant Python, on peut utiliser la bibliothèque Sympy
et utiliser la méthode integrate en spécifiant les variables d’intégration.
Par exemple, calculons l’intégral
R1R2 2
0 0
(x ∗ y + x ∗ y3 )dxdy
8
La solution à cette intégration est 3
et elle est obtenue grâce au code Python
suivant :
1 from sympy import *
2
3 x , y = symbols ( ’ x y ’)
4 f = x **2 * y + x * y **3
5 integrate (f ,( x ,0 ,1) ,(y ,0 ,2) )

1.3.2 Calculs des solutions analytiques des Dérivées

Calcul de la n-ième dérivée d’une fonction à une variable
Pour calculer la solution analytique d’une dérivée d’ordre donné n d’une
fonction f (x) dans Python, vous pouvez utiliser la bibliothèque Sympy avec
la fonction dif f (f , x, n) où vous précisez la fonction à dériver f , la variable
symbolique x par rapport à laquelle la dérivée doit être calculée, et le nombre
de fois que la dérivation doit être appliquée n. Par exemple, pour trouver les
 10 CHAPITRE 1. INTRODUCTION

dérivées première, seconde et troisième de la fonction f (x) = x 2 + sin(x) par

rapport à x dans Python on procède comme suit :
1 from sympy import *
2

3 x = symbols ( ’x ’)
4 f = x **2 + sin ( x )
5 diff (f ,x ,1)

et on trouve que
df (x)
dx
= 2x + cos(x)
d2 f (x)
dx 2
= 2 − sin(x)
d3 f (x)
dx 3
= −cos(x)

Calcul des dérivées partielles

Afin de réaliser une différenciation d’une fonction à plusieurs variables
par rapport à une variable spécifique, on peut utiliser la fonction dif f comme
ci-dessus. Par exemple, pour trouver la dérivée de la fonction f (x, y) = x 2 ∗
y + x ∗ y3 par rapport à y ou par rapport à x et y dans Python, on procède
comme suit :
1 from sympy import *
2
3 x , y = symbols ( ’ x y ’)
4 f = x **2 * y + x * y **3
5 diff (f , y )
6 diff (f ,x , y )
∂f (x,y) ∂f (x,y)
Ce qui donne ∂y
= x 2 + 3xy2 et ∂x∂y
= 2x + 3y2

1.3.3 Résolution des systèmes d’équation linéaires

La bibliothèque sympy de Python permet aussi de résoudre des sys-
tèmes d’équations linéaires, à l’aide de la fonction solve. Par exemple, pour
le résoudre le système suivant à 3 équations et 3 inconnues

3x + 10y − 2z = 7

x +y+z =2


20x + 3y + 7z = 0
 1.3. INITIATION AUX CALCULS DES SOLUTIONS ANALYTIQUES
SYMBOLIQUES AVEC PYTHON 11
avec le code suivant :
1 from sympy import *
2
3 x , y , z = symbols ( ’ x y z ’)
4 eq1 = Eq (3* x +10* y -2* z ,7)
5 eq2 = Eq ( x + y +y ,2)
6 eq3 = Eq (20* x +3* y +7* z ,0)
7 sol = solve (( eq1 , eq2 , eq3 ) ,(x ,y , z ) )
8 # Afficher les solutions
9 for var , val in sol . items () :
10 print ( f "{ var } = { val }")

1.3.4 Substitution des valeurs dans une fonction

Substitution d’une variable par un scalaire
Pour réaliser une substitution dans une fonction avec SymPy, on peut
utiliser la méthode subs(f onction, variable, valeur) fonction où on précise
la fonction, la variable concernée par la substitution et la valeur à utiliser.
Par exemple, si on veut évaluer la fonction f (x) = x 7 + 6x 3 + 10x 2 + 21x + 10
pour x = −6, le code à utiliser est le suivant :
1 from sympy import *
2
3 x = Symbol ( ’x ’)
4 y = x **7 + 6* x **3+10* x **2+21* x +10
5 # Afficher la fonction initiale
6 print ( f " y = { y }")
7 # Effectuer une substitution dans la fonction
8 z = y . subs (x , -6)
9 print ( f " z = { z }")

et on détermine que f (−6) = −280988

Substitution d’une variable par un vecteur et traçage de la fonction

Pour réaliser une substitution d’une variable dans une fonction par un
vecteur de valeurs avec SymPy et tracer la courbe de la fonction, on peut
utiliser la bibliothèque NumPy et la fonction "lambdify" de SymPy comme
illustré dans l’exemple du code suivant où dans la fonction f (x) = x 7 + 6x 3 +
10x 2 + 21x + 10 on évalue x pour des valeurs entre 0 et 10 :
 12 CHAPITRE 1. INTRODUCTION

1 from sympy import *

2 from matplotlib . pyplot import *
3 from numpy import *
4
5 x = Symbol ( ’x ’)
6 y = x **7 + 6* x **3+10* x **2+21* x +10
7
8 x1 = arange (0 , 10 , 0.1)
9 # Utiliser la fonction " lambdify " pour transformer la
fonction SymPy en une fonction NumPy
10 y1 = lambdify (x , y , ’ numpy ’)
11 # Effectuer la substitution de x par le vecteur de valeurs
12 z = y1 ( x1 )
13
14 # Tracer la courbe de la fonction
15 plot ( x1 , z )
16 xlabel ( ’x ’)
17 ylabel ( ’y ’)
18 title ( ’ Fonction y ( x ) ’)

et la courbe correspondante est donnée sur la figure ci-dessous :

Figure 1.1 – Courbe de la fonction f (x) = x 7 + 6x 3 + 10x 2 + 21x + 10 pour x

variant entre 0 et 10
 1.3. INITIATION AUX CALCULS DES SOLUTIONS ANALYTIQUES
SYMBOLIQUES AVEC PYTHON 13
1.3.5 Solution analytique des équations différentielles
Solution d’une équation différentielle d’ordre n sans conditions initiales
Toujours avec la bibliothèque sympy de Python, il est possible de déter-
miner la solution analytique d’une équation différentielle d’ordre quelconque.
Par exemple, pour déterminer la solution y(t) de l’équation différentielle :
2
2 ddty2 − 4 dy
dt
+ 3y = 5 · exp(t)
on utilise le code suivant :
1 from sympy import *
2
3 t = symbols ( ’t ’)
4 y = Function ( ’y ’) ( t )
5 eq = Eq (2* y . diff (t , t ) -4* y . diff ( t ) +3* y , 5* exp ( t ) )
6 sol = dsolve ( eq , y )
7 print ( sol )
√ √
et on trouve que la solution est y(t) = (C1 sin( 2 2t ) + C2 cos( 2 2t ) + 5) exp(t)

Solution d’une équation différentielle d’ordre n avec conditions initiales et

traçage de la solution
Pour tenir compte des n conditions initiales dans la solution d’une équa-
tion différentielle du n-ième ordre avec SymPy, on peut utiliser la méthode
"subs" pour remplacer les constantes arbitraires dans la solution par les
valeurs correspondantes des conditions initiales. Voici comment cela peut
être fait pour l’exemple précédent où on considère que les deux conditions
initiales sont y(0) = 1 et dy(0
dt
=0:
1 from sympy import *
2 from matplotlib . pyplot import *
3
4 close (" all ")
5 t = symbols ( ’t ’)
6 y = Function ( ’y ’) ( t )
7
8 eq = Eq (2* y . diff (t , t ) -4* y . diff ( t ) +3* y , 5* exp ( t ) )
9 CI = { y . subs (t , 0) : 1 , y . diff ( t ) . subs (t , 0) : 0}
10 sol = dsolve ( eq , ics = CI )
11 print ( sol )
12 from numpy import *
13 t1 = linspace (0 , 10 , 1000)
 14 CHAPITRE 1. INTRODUCTION

14 sol1 = lambdify (t , sol . rhs , ’ numpy ’)

15 z = sol1 ( t1 )
16 plot ( t1 , z )
17 xlabel ( ’ temps ’)
18 ylabel ( ’y ’)
19 title ( ’ Fonction y ( t ) ’)

√ √
et on trouve que la solution est y(t) = (−2 sin( 2 2t ) − 4 cos( 2 2t ) + 5) exp(t)
et la courbe de cette solution pour des valeurs de t variant entre 0 et 10 est
la suivante :

√ √
Figure 1.2 – Courbe de la fonction y(t) = (−2 sin( 2 2t )−4 cos( 2 2t )+5) exp(t)
pour t variant entre 0 et 10

Solution analytique d’un système d’équations différentielles linéaires du

premier ordre

Pour déterminer la solution analytique d’un système de n équations dif-

férentielles linéaires du premier ordre et la tracer dans Python, on peut
utiliser les bibliothèques sympy et matplotlib. Par exemple, pour trouvez la
 1.3. INITIATION AUX CALCULS DES SOLUTIONS ANALYTIQUES
SYMBOLIQUES AVEC PYTHON 15
solution du système d’équations différentielles suivant :
 dy
 dt = −2y1 + y2 − 2y3
1

dy2
dt
= y1 − 2y2 + 2y3

 dy2
dt
= 3y1 − 3y2 + 5y3

on peut utiliser le code suivant, pour les conditions initiales y1(0) = 1,

y2(0) = −1 et y3(0) = 0 :
1 from sympy import *
2 from matplotlib . pyplot import *
3 from numpy import *
4 # definir les variables symboliques
5 t = symbols ( ’t ’)
6 # definir les equations differentielles sous forme symbolique
7 y1 = Function ( ’ y1 ’) ( t )
8 y2 = Function ( ’ y2 ’) ( t )
9 y3 = Function ( ’ y3 ’) ( t )
10 eq1 = Eq ( y1 . diff ( t ) , -2* y1 + y2 -2* y3 )
11 eq2 = Eq ( y2 . diff ( t ) ,y1 -2* y2 +2* y3 )
12 eq3 = Eq ( y3 . diff ( t ) ,3* y1 -3* y2 +5* y3 )
13
14 # Definir les conditions initiales y1 (0) = 1 , y2 (0) = -1 , and
y3 (0) = 0:
15 y1_0 =1
16 y2_0 = -1
17 y3_0 =0
18 c o n d i t i o n s _ i n i t i al e s = { y1 . subs (t , 0) : y1_0 , y2 . subs (t , 0) :
y2_0 , y3 . subs (t , 0) : y3_0 }
19 # resourdre les equations differentielles
20 sol = dsolve ([ eq1 , eq2 , eq3 ] , ics = co ndi ti on s_ ini ti al es )
21 # Afficher les solutions
22 print ( sol )
23 # Obtenir les expressions de y1 ( t ) , y2 ( t ) et y3 ( t )
24
25 y1_sol = sol [0]. rhs
26 y2_sol = sol [1]. rhs
27 y3_sol = sol [2]. rhs
28 print ( y1_sol )
29 print ( y2_sol )
30 print ( y3_sol )
31 # Conevrtir les fonctions symbliques en fonction utilisable
par numpy
32 y1_func = lambdify (t , y1_sol , ’ numpy ’)
33 y2_func = lambdify (t , y2_sol , ’ numpy ’)
 16 CHAPITRE 1. INTRODUCTION

34 y3_func = lambdify (t , y3_sol , ’ numpy ’)

35 # plage de temps pour tracer la solution
36 t_vals = linspace (0 ,1 ,1000)
37
38 # Calcul de y1 , y2 et y3 pour chaque instant
39 y1_vals = y1_func ( t_vals )
40 y2_vals = y2_func ( t_vals )
41 y3_vals = y3_func ( t_vals )
42 # tracer les courbes
43 plot ( t_vals , y1_vals , label = ’ y1 ( t ) ’)
44 plot ( t_vals , y2_vals , label = ’ y2 ( t ) ’)
45 plot ( t_vals , y3_vals , label = ’ y3 ( t ) ’)
46 legend ()

et on trouve la solution
y1 (t) = − exp(3t)
2
+ 3 exp(−t)
2

exp(3t)
y2 (t) = 2
− 3 exp(−t)
2

y3 (t) = 3 exp(3t)
2
− 3 exp(−t)
2

représentée sur la figure suivante :

Figure 1.3 – Courbe de y1 (t), y2 (t) et y3 (t) pour t variant entre 0 et 1

 1.4. INITIATION AUX CALCULS MATRICIELS AVEC PYTHON 17

1.4 Initiation aux calculs matriciels avec Python

Dans Python, on peut réaliser des calculs matriciels en utilisant la biblio-
thèque NumPy comme le montre le code suivant où on réalise des opérations
telles que l’inversion, la multiplication, l’addition et le calcul des déterminant
d’une matrice
 
1 1 3
A =  1 2 1
10 2 4

1 from numpy import *

2
3 A = array ([[1 , 1 , 3] ,[1 , 2 , 1] ,[10 , 2 , 4]])
4 print ( A )
5 Ca lc ul _d et er minant = linalg . det ( A )
6 print (" Determinant = " , Calcu l_det ermi nant )
7 Calcul_inverse =1/ A
8 print (" Inverse = " , Calcul_inverse )
9 # Addition de deux matrices
10 C = A + Calcul_inverse
11 print ( C )
12 # Multiplication de deux matrices
13 D = A * Calcul_inverse
14 print ( D )

Avec cette approche, on peut résoudre les systèmes d’équations algébriques.

Par exemple, pour le résoudre le système suivant à 3 équations et 3 incon-
nues 
3x + 10y − 2z = 7

x +y+z =2


20x + 3y + 7z = 0
on peut
 écrire le système
 sous
  sa forme matricielle AX = B où X = [x, y, z]T ,
3 10 −2 7
A =  1 1 1  et B = 2. La solution à ce système est X = A−1 B et
20 3 7 0
peut être obtenue avec le code Python suivant :
1 from numpy import *
2
3 # Solution systeme d ’ equations
4 A = array ([[3 ,10 , -2] ,[1 ,1 ,1] ,[20 ,3 ,7]])
 18 CHAPITRE 1. INTRODUCTION

5 B = array ([[7] ,[2] ,[0]])

6 determin = linalg . det ( A )
7 print ( determin ) # veirifier si la solution est possible
8 X = linalg . inv ( A ) @ B
9 print (" Solution " , X )

On peut aussi calculer la transposée d’une matrice en procédant comme

suit :
1 from numpy import *
2

3 A = array ( [[0 , 1] , [ -2 , -3]])

4 A_tr = A . T

1.4.1 Initiation aux solutions numériques des équations dif-

férentielles ordinaires non-linéaires
Les solutions analytiques obtenues dans la section précédente ne peuvent
pas être déterminées par Python particulièrement pour les systèmes non-
linéaires. Pour ces derniers, la seule possibilité disponible est l’obtention
des solutions approximatives en utilisant l’une des méthodes d’intégration
numériques. Python en implémente dans sa bibliothèque scipy qui est une
bibliothèque qui inclut des modules pour la statistique, l’optimisation, l’inté-
gration, l’algèbre linéaire, les transformées de Fourier, traitement des signaux
et d’images, les calculateurs d’équations différentielles ordinaires, etc..
Ici nous nous intéressons à l’utilisation de sa fonction odeint(EDO, V aleurI nitiale, T emps
qui prend comme paramètres la fonction donnant le modèle du système à
simuler ou résoudre, les valeurs initiales des états du système et la durée
de la simulation. Cette fonction peut indifféremment utilisée aussi bien pour
les équations différentielles linéaires que non-linéaires.
Par exemple, soit à simuler le système de Lorenz, qui est un système
utilisé dans les systèmes de télécommunication pour le cryptage des infor-
mations. Le système de Lorenz est modélisé comme suit :

dx
 dt = σ (y − x)

dy
dt
= x(ρ − z) − y

 dz
dt
= xy − βz

Avec σ = 10, ρ = 28 et β = 8/3, ce système est dit chaotique vu sa forte

sensibilité aux conditions initiales et donc sa non prédictibilité. Il est impos-
 1.4. INITIATION AUX CALCULS MATRICIELS AVEC PYTHON 19

sible d’en déterminer la solution analytique exacte. Pour trouver sa solution

numérique avec Python, nous procédons comme suit :

1 from numpy import *

2 from matplotlib . pyplot import *
3 from scipy . integrate import odeint
4

5 start =0
6 stop =100
7 step = 0.01
8 t = arange ( start , stop , step )
9
10 def Lorenz_system (x , t ) :
11 sig = 10
12 rho = 28
13 beta =8/3
14 dxdt = sig *( x [1] - x [0])
15 dydt = x [0]*( rho - x [2]) -x [1]
16 dzdt = x [0]* x [1] - beta * x [2]
17 EDO =[ dxdt , dydt , dzdt ]
18 return EDO
19 x0 =[0 , 1 , -1]
20 sol = odeint ( Lorenz_system , x0 , t )
21 x = sol [: ,0]
22 y = sol [: ,1]
23 z = sol [: ,2]
24
25 close (" all ")
26 subplot (1 ,2 ,1)
27 plot (x ,z ," b ")
28 xlabel (" x ( t ) ")
29 ylabel (" z ( t ) ")
30 subplot (1 ,2 ,2)
31 plot (y ,z ," r ")
32 xlabel (" y ( t ) ")
33 ylabel (" z ( t ) ")
34

La figure ci-dessous donne les portraits de phase ou courbes de z(t) en

fonction de x(t) et z(t) en fonction de y(t).
 20 CHAPITRE 1. INTRODUCTION

50 50

40 40

z(t) 30 30

z(t)
20 20

10 10

0 0

−20 −10 0 10 20 −20 0 20

x(t) y(t)

Figure 1.4 – Portraits de phase (a) z(t) en fonction de x(t) et (b) z(t) en
fonction de y(t)