Doc

LIESSE - Initiation à Scilab
Version provisoire - V4
Liesse
Gérard Blanchet, Maurice Charbit
8 mai 2014
2 kernSCILAB.aux
Table des matières
Avant-propos 7
Notations and Abréviations 9
1 Introduction au langage 11
1.1 Variables et constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.1.1 Vecteurs et matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.1.2 Les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.1.3 Matrices prédéfinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.1.4 Constantes et initialisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.1.5 Tableaux multidimensionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.1.6 Cellules et structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.2 Opérations et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.2.1 Opérations matricielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.2.2 Opérations pointées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.2.3 Fonctions mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.2.4 Fonctions de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.2.5 Autres fonctions utiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.3 Structures de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.3.1 Opérateurs logiques et variables booléennes . . . . . . . . . . . . . . . . . . . . . . 26
1.3.2 Les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.3.3 Boucles implicites, min, max, find, etc. . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.4 Les affichages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.4.1 Affichage 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.4.2 Affichage 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
1.4.3 Remarque sur les tracés de courbes . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.4.4 Les animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
1.5 Conversion de nombres en chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . 36
1.6 Entrées/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.6.1 Entrées à partir du clavier ou de la souris . . . . . . . . . . . . . . . . . . . . . . . 38
1.6.2 Entrées/sorties dans des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.6.3 Entrées/sorties spécialisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
1.7 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
2 Ecriture des programmes et mise au point 47

2.1 Programmes et fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.2 Bibliothèques de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.3 Exécution de chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
2.4 Appel au système d’exploitation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.5 Mise au point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.5.1 Points d’arrêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.5.2 Mise au point directe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
2.5.3 Traitement local des erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.5.4 Extraction d’informations d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . 51
3
4 kernSCILAB.aux
3 Eléments sur les images 53

3.1 Utilisation des fonctions fournies par Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2 Quelques traitements appliqués aux images indexées . . . . . . . . . . . . . . . . . . . . . 55
3.3 Installation sur Mac OS des outils « Images » . . . . . . . . . . . . . . . . . . . . . . . . . 57
4 Construction d’interfaces 59
4.1 Les éléments de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.2 Pour aller plus loin... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2.1 Traitement de l’état des figures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2.2 Utilisation des callback . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2.3 Utilisation des uimenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
5 Simulation 67
5.1 Eléments de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5.2 Les super-blocs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.3 Passage des paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.3.1 Variables implicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.3.2 Appel de Xcos à partir de scripts Scilab . . . . . . . . . . . . . . . . . . . . . . . . 71
5.4 Les blocs définis par l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.4.1 Définition du bloc hors traitement . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.4.2 Définition du traitement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
6 Variables aléatoires 73
6.1 Lois usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.1.1 Loi uniforme sur (a, b) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.1.2 Variable aléatoire gaussienne réelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.1.3 Variable aléatoire gaussienne complexe . . . . . . . . . . . . . . . . . . . . . . . . . 76
6.1.4 Vecteurs aléatoires gaussiens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.2 Estimation de la densité de probabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
6.3 Génération de variables aléatoires dans Scilab . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.3.1 Générateurs de Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6.3.2 Chaîne de Markov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
6.3.3 Génération de variables aléatoires de loi quelconque . . . . . . . . . . . . . . . . . 83
6.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
7 Eléments d’automatique linéaire à temps continu 89

7.1 La transformée de Laplace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
7.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
7.1.2 Quelques propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
7.1.3 Notion de système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
7.2 Outils graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.2.1 Diagrammes de Bode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.2.2 Diagrammes de Nyquist . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
7.2.3 Exemples de diagrammes de Nyquist . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.2.4 Diagrammes de Black-Nichols . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.3 Le pourquoi du bouclage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
7.3.1 Schémas généraux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.3.2 Utilisation du diagramme de Nyquist . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.3.3 Autres critères de stabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
7.3.4 Critères de performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.3.5 Le compensateur PID . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
7.3.6 Exemple d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
7.3.7 Lieu d’Evans ou lieu des pôles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
7.4 Scilab pour l’automatique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
7.4.1 Réponses indicielles du second ordre . . . . . . . . . . . . . . . . . . . . . . . . . . 107
5
8 Résolution d’équations 111

8.1 Systèmes d’équations et recherches de zéros . . . . . . . . . . . . . . . . . . . . . . . . . . 111
8.1.1 Zéros d’une fonction par la méthode de Newton . . . . . . . . . . . . . . . . . . . . 111
8.1.2 Racines d’un polynôme par Newton-Raphson . . . . . . . . . . . . . . . . . . . . . 111
8.1.3 Systèmes d’équations non linéaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
8.2 Résolution d’équations différentielles ordinaires (ODE) . . . . . . . . . . . . . . . . . . . . 113
8.2.1 Résolution par passage du continu au discret . . . . . . . . . . . . . . . . . . . . . 113
8.2.2 Cas linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.2.3 Système différentiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
9 Les extensions 117

9.1 Appel à l’aide de la fonction call . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
9.2 Introduction à l’API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
9.2.1 Exemple d’utilisation de l’API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
9.2.2 Utilisation des fonctions de l’API . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
10 Exercices divers 127

10.1 Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
10.2 Communications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
10.3 Méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
10.3.1 La méthode de Monte-Carlo pour le calcul d’une intégrale . . . . . . . . . . . . . . 131
10.3.2 Evaluation d’une espérance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
10.4 Corde vibrante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
10.4.1 Solution en temps continu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
10.4.2 Simulation en temps discret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Annexes 137
A.1 Rappels élémentaires sur les variables aléatoires . . . . . . . . . . . . . . . . . . . . . . . . 137
A.1.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
A.1.2 Moments et fonction caractéristique . . . . . . . . . . . . . . . . . . . . . . . . . . 140
A.2 Quelques indications sur les exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
A.2.1 Exercices dans le corps du texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
A.2.2 Exercices divers avec indications . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
A.3 Exemples divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
A.3.1 Diagrammes de gain et réponses impulsionnelles . . . . . . . . . . . . . . . . . . . 167
A.3.2 Loi binomiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
A.3.3 Diagramme électrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Bibliographie 173
Index 175
6 kernSCILAB.aux
Avant-propos
Ce document a pour but d’apporter quelques éléments sur l’utilisation du langage Scilab (1) . Il com-
porte aussi des informations et exemples sur la construction d’interfaces graphiques et sur l’utilisation du
langage C pour écrire ses propres fonctions au cas où Scilab n’offrirait pas des performances suffisantes.
La documentation de Scilab est très riche et offre de nombreux documents [2, 3, 4, 5, 6] qui exposent la
façon de s’y prendre pour mettre en œuvre ces compléments.
Ce document inclue les éléments suivants :
1. un chapitre d’introduction au langage ;
2. un chapitre sur l’écriture des programmes et la mise au point ;

3. un chapitre expliquant comment afficher des images et faire quelques traitements sans utiliser l’outil
SIVP ;
4. un chapitre consacré aux interfaces graphiques utilisant les éléments de contrôle disponibles :
boutons-poussoirs, cases à cocher, menus déroulants, etc. ;
5. un chapitre aborde le problème de la simulation utilisant des « blocs » (Xcos).
6. un chapitre donne quelques éléments sur l’utilisation de Scilab dans le cadre des probabilités ;
7. un chapitre est consacré à l’automatique linéaire temps continu sous forme d’un cours avec exemple ;
8. un chapitre traite de la résolution d’équations, dont les équations différentielles ;
9. un chapitre est consacré à la construction de fonctions permettant à tout utilisateur d’enrichir Scilab
avec des fonctions écrites en C. Il introduit les concepts utilisés pour la construction de fonctions
accessibles sous forme de librairies dynamiques ;
10. un chapitre d’exercices est ensuite proposé ;
11. les annexes donnent quelques éléments sur les variables aléatoires, des indications sur les exercices
et quelques exemples qui complètent les exercices et exemples déjà donnés dans le corps du texte.
Ce document a été rédigé sous (TeXShop 2.47) avec :

− Scilab 5.4.0,
− et MATLAB⃝
R
7.12.0.635 (R2011a) 64-bit (maci64),
sur Macintosh MacBook Pro 13 pouces, processeur Intel i7, 2,7 GHz, Mac OS X 10.6.8.
Quelques liens et documents utiles :
1. http://wiki.scilab.org/Tutorials ;
2. http://www.scilab.org/resources/documentation ;
3. www-fourier.ujf-grenoble.fr/ decauwer/polyscilab.pdf.
(1). www.scilab.org
7
8 kernSCILAB.aux
Notations and Abbreviations
∅ ensemble vide
∑ ∑ ∑
k,n = k n
{
1 when |t| < T /2
rectT (t) =
0 otherwise
sin(πx)
sinc(x) =
{ πx
1 when x ∈ A
1(x ∈ A) = (indicatrice de A)
0 otherwise
(a, b]= {x : a < x ≤ b}
{
distribution de Dirac lorsque t ∈ R
δ(t)
symbole de Kronecker lorsque t ∈ Z
Re(z) partie réelle de z
Im(z) partie imaginaire de z
√
i or j = −1
x(t)
X(f ) transformée de Fourier
(x ⋆ y)(t) convolution à temps continu
∫
= x(u)y(t − u)du
R
(x ⋆ y)(t) convolution à temps discret
∑
= x(u)y(t − u)
u∈Z
x or x vecteur x
IN matrice identité (N × N )
A∗ complexe conjgué de A
AT transposé de A
AH transposé-conjugué de A
A−1 matrice inverse de A
E {X} valeur moyenne de X

ou espérance mathématique de X
Xc = X − E {X} variable aléatoire centrée
E {X|Y } espérance conditionnelle de X étant donnée Y
P {X ∈ A} probabilité que X ∈ A
2
var (X) = E {|Xc |} variance de X
9
10 Initiation à Scilab
AR Autoregressif
ARMA AR et MA
CAN Convertisseur Analogique-Numérique
CNA Convertisseur Numérique-Analogique
d.p./dp densité de probabilité
d.s.p./dsp densité spectrale de puissance
dse densité spectrale d’énergie
EDLCC équations différentielle linéaires à coefficients constants
FFT Fast Fourier Transform
FT Fonction de Transfert
i.i.d./iid indépendantes et identiquement distribuées
MA Moyenne Ajustée
MAC Multiplication ACcumulation
p.a./pa processus aléatoire
RIF Réponse Impulsionnelle Finie
RII Réponse Impulsionnelle Infinie
RSB Rapport Signal à Bruit
SLI Système Linéaire Invariant
SSL Stationnaire au Second ordre au sens Large
TCD Transformée en Cosinus Discrète
TF Transformée de Fourier à temps continu
TFCT Transformée de Fourier à Court Terme
TFD Transformée de Fourier Discrète
TFDI Transformée de Fourier Discrète Inverse
TFTD Transformée de Fourier à Temps Discret
TZ Transformée en z
TZC Transformée en z causale
v.a./va variable aléatoire
ZOH Zero-Order Hold
Chapitre 1
Introduction au langage
Quelques petites choses à retenir :

− les programmes ont l’extension .sce,
− les fonctions ont l’extension .sci,
− l’exécution d’un programme est lancée par exec(),
− le chargement des fonctions est fait avec getd().
Ce chapitre est inspiré du premier chapitre de Signal and Image Processing using Matlab⃝
R
, G. Blanchet,
M. Charbit, ISTE 2006 (http://www.iste.co.uk/index.php?f=a&ACTION =View&id=61).
Le terme Scilab pourra faire référence dans ce qui suit :
− au programme lancé dans un environnement tel que X11, Windows, Mac OS, etc.,
− ou le langage défini par un vocabulaire et des règles syntaxiques.
Scilab est un interpréteur. Une fois lancé, il affiche une fenêtre de commande (figure 1.1 ) dans laquelle
on peut taper des commandes qui sont alors interprétées.
Figure 1.1 – La fenêtre de commande de Scilab-5.4.0 dans Mac OS X
11
12 Chapitre 1 - Introduction au langage
Si les commandes sont syntaxiquement correctes, Scilab les exécute, cette exécution donnant, elle
aussi, lieu à des vérifications.
L’utilisation de Scilab peut se faire de deux façons :
− « comme avec une calculette » en tapant les commandes dans la fenêtre idoine. Par exemple, taper
a=2*log10(5) puis <return> dans la fenêtre de commande. Le résultat obtenu est donné figure
1.2 . clc() efface la fenêtre de commande et tohome renvoie le curseur « en haut, à gauche ».
Figure 1.2 – La fenêtre de commande de Scilab-5.3.3 avec le résultat de l’in-

terprétation de a=2*log10(5)
Les commandes exécutés peuvent être rappelées en tapant sur la flèche ↑ pour faire défiler toutes
les commandes précédemment tapées, ou une suite de lettres suivie par ↑. Toutes les commandes
commençant par ces lettres défilent alors ;
− ou « par exécution de programmes ». Un programme regroupe des commandes dans un fichier texte
appelé programme ou script. L’utilisateur lui donne un nom, avec l’extension sce. La documentation
Scilab explique comment utiliser l’éditeur « intégré » SciNotes ou un éditeur externe pour créer de
tels programmes. Ceci ne pose aucun problème particulier. Si un programme a pour nom prog1.sce
(voir exemple 1.1), l’utilisateur tape exec(’prog1.sce’) dans la fenêtre de commande pour en
lancer l’exécution. Scilab recherche le fichier dans le répertoire courant. La commande mtlb_type
prog1.sce permet de visualiser le contenu du fichier.
Le développement d’un projet nécessite la création de plusieurs programmes et fonctions. Cela
implique en principe la création d’un répertoire dans lequel tous ces éléments, et les fichiers de
données associés, seront rangés. On dira qu’il s’agit du répertoire de travail. Lors de chaque nouvelle
session on doit donc indiquer ce dernier à Scilab. On peut le faire en cliquant dans la colonne gauche
de la fenêtre de commande (figure 1.1 ). Une fois ceci fait, on peut taper pwd pour vérifier (figure
1.3 ).
Si des fonctions du répertoire courant doivent être utilisées, on doit pré-charger ces dernières en
tapant getd() dans la fenêtre de commande ou en insérant cette commande dans chaque programme
qui fait appel à celles-ci.
Pour éviter de refaire le choix du répertoire de travail chaque fois que l’on utilise Scilab, on peut,
entre autres méthodes (taper help startup pour avoir un panorama plus complet), créer un fichier
scilab.ini que l’on range dans un répertoire décrit dans la documentation. Ici, ce fichier contient :
//===== scilab.ini dans SCIHOME (Mac OS)

cd /Users/blanchet/ECOLE/REDACTIONS/SCILAB/Latex/progs
Telecom-ParisTech – GB 13
Figure 1.3 – Répertoire courant ou « de travail »
Figure 1.4 – « Mon » répertoire SCIHOME
et est rangé dans le répertoire SCIHOME (figure 1.4 ) comme la documentation l’indique.
Exemple 1.1 (Utilisation de l’éditeur intégré) L’éditeur intégré destiné à « saisir » les pro-
grammes peut être appelé en cliquant sur l’icône (figure 1.5 ) ou en tapant scinotes dans la
fenêtre de commande.
Figure 1.5 – Appel à l’éditeur intégré, en cliquant sur l’icône adéquat, et saisie
du programme
Une fois le programme tapé et sauvegardé sous le nom prog1.sce, les commandes mtlb_type et
exec donnent :
-->mtlb_type prog1.sce
!a = [1;2;3], b = a, !
! !
!c = [1;-1] !
-->exec(’prog1.sce’,0)
a =
1.
2.
3.
b =
1.
2.
3.
c =
1.
- 1.
Scilab n’est pas compatible avec Matlab. Le menu Applications comporte une option de conversion
de programmes Matlab vers Scilab. La fonction mtlb_type que l’on vient de voir fait partie des fonctions
– ici la fonction type de Matlab – émulées par Scilab.
1.1 Variables et constantes

1.1.1 Vecteurs et matrices
Le langage Scilab est orienté « manipulation de vecteurs et matrices » d’éléments complexes ou réels.
Un scalaire est une matrice 1 × 1, un vecteur colonne une matrice avec une seule colonne et un vecteur
ligne une matrice avec une seule ligne. La notation (ℓ × c) indique que la variable considérée possède ℓ
lignes et c colonnes, (ℓ × c × p) ℓ lignes, c colonnes, p plans, etc. (voir exemple 1.10)
Définition du contenu des matrices

Les valeurs sont affectées aux éléments d’une matrice en utilisant des crochets « [ » et « ] ». Un espace
(ou une virgule) est un séparateur entre colonnes, tandis que le point-virgule est un « passage à la ligne ».
Les éléments sont indexés à partir de 1. Le premier index est le numéro de ligne, le second le numéro de
colonne, etc.
Exemple 1.2 (Définition d’une matrice) Taper a=[1 2 3;4 5 6] dans la fenêtre de commande. La
réponse est donnée figure 1.6 .
définition de la matrice a
résultat
(2 lignes, 3 colonnes)
Figure 1.6 – Définition d’une matrice
Chaque élément peut être désigné par ses indices. Ainsi, taper a(1,1) donne 1 et a(2,1) donne 4.
L’affectation a=[1 2;3 4 5] conduit à un message d’erreur car le nombre de colonnes est différent sur
les deux lignes.
Quand les composantes d’un vecteur forment une suite de valeurs séparées par des intervalles réguliers,
il est préférable d’utiliser une « boucle implicite » telle que (indD:step:indF). Cette expression fournit
une suite partant de indD et allant jusqu’à indF par incréments de step. Les valeurs ne peuvent aller
au-delà de indF. La valeur de l’incrément step peut être omise si elle vaut 1.
Exemple 1.3 (Enumération implicite) Taper a=(0:1:10) ou a=(0:10). Scilab donne :

-->a=(0:10)
a =
0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.
Exemple 1.4 (Enumération implicite avec incrément) Taper a=(0:4:10). Scilab donne :
-->a=(0:4:10)
a =
0. 4. 8.
Le dernier élément d’un vecteur est indicé par « $ ». Dans l’exemple précédent, a($) donne la valeur
8.
Il est possible d’étendre la taille d’une matrice. L’interpréteur alloue dynamiquement de l’espace
mémoire lors de l’extension.
Exemple 1.5 (Extension d’une matrice) Taper :

-->a=[1 2 3; 4 5 6]
a =
1. 2. 3.
4. 5. 6.
-->a=[a a]
a =
1. 2. 3. 1. 2. 3.
4. 5. 6. 4. 5. 6.
-->a=[1 2 3; 4 5 6]; a=[a;a]
a =
1. 2. 3.
4. 5. 6.
1. 2. 3.
4. 5. 6.
La ligne de commande a=[1 2 3; 4 5 6]; a=[a;a] contient deux instructions. La première, a=[1 2
3; 4 5 6];, est terminée par le « séparateur d’instruction » point-virgule. Cela inhibe l’impression d’un
résultat à l’écran. Si l’on avait mis une virgule comme séparateur, on aurait eu :
-->a=[1 2 3; 4 5 6], a=[a;a]
a =
1. 2. 3.
4. 5. 6.
a =
1. 2. 3.
4. 5. 6.
1. 2. 3.
4. 5. 6.
Références aux éléments d’un tableau

Les références aux éléments d’un tableau à N dimensions par un seul indice k retourne le k-ème
élément du tableau lu colonne par colonne. Considérons l’exemple qui suit :
-->A=[(1:4);(5:8)], A(3)
Scilab retourne :
A =
1. 2. 3. 4.
5. 6. 7. 8.
ans =
2.
On peut aussi extraire les éléments d’un tableau à l’aide d’indices regroupés dans un vecteur. Exemple :
-->myind=[1,2,7]; A(myind)
ans =
1.
5.
4.
Scilab retourne toujours un vecteur colonne.
Lorsque A est une matrice (n × m), l’instruction B = zeros(A) retourne une matrice de zéros de
même dimension (n × m) que A. Cela peut être très pratique lorsque l’on est amené à modifier la taille
de matrices pendant une phase de mise au point.
Remarques :
− lorsqu’on définit des variables et autres objets, le langage est sensible aux majuscules et minuscules ;
− le format d’affichage peut être modifié en utilisant la commande format. Ainsi format(’e’) donne
un format flottant standard et format(’v’) un format variable. format(’e’,15) donne un format
flottant avec 15 caractères ;
− Scilab est un interpréteur. Il réserve de l’espace mémoire chaque fois qu’une variable est utilisée
pour la première fois. Les variables utilisées pendant une session restent rangées en mémoire, d’où
l’utilité – rare toutefois – de « nettoyer » cet espace mémoire de temps en temps. La fonction clear
(taper help clear) peut être utilisée dans ce but ;
− il est toujors plus efficace de « prédimensionner » une matrice – par exemple avec M=zeros(m,n) –
que de laisser Scilab la remplir dynamiquement au cours de son utilisation dans un programme.
Changement de taille
La fonction matrix est utilisée pour modifier la taille d’une matrice, par exemple pour passer d’une
matrice (2 × 6) à une matrice (3 × 4). Ce changement de taille peut être effectué directement :
-->a=[(1:6);(7:12)]
a =
1. 2. 3. 4. 5. 6.
7. 8. 9. 10. 11. 12.
-->c=zeros(3,4); c(:)=a
c =
1. 8. 4. 11.
7. 3. 10. 6.
2. 9. 5. 12.
-->matrix(a,3,4)
ans =
1. 8. 4. 11.
7. 3. 10. 6.
2. 9. 5. 12.
La commande zeros(3,4) initialise le choix de taille pour la matrice c. c(:)=a remplit c, colonne par
colonne, avec la suite des 12 valeurs prises dans a colonne par colonne. a et c doivent avoir exactement
le même nombre d’éléments.
Exemple 1.6 (Suite alternée) Taper :
-->x=[ones(1,5);-ones(1,5)];
-->y=zeros(1,10); y(:)=x
y =
1. - 1. 1. - 1. 1. - 1. 1. - 1. 1. - 1.
1.1.2 Les chaînes de caractères

Dans Scilab il faut retenir que les chaînes de caractères ne sont pas des vecteurs de caractères. Il existe
un type string.
Des chaînes de caractères peuvent être affectées aux éléments d’une matrice. Lorsqu’il y a incompa-
tibilité sur la longueur des chaînes, Scilab ajoute des « espaces ». Exemple :
-->N=[’paul’;"pierre"]
N =
!paul !
! !
!pierre !
-->size(N), length(N)
ans =
2. 1.
ans =
4.
6.
L’instruction size(N) retourne une taille de (2 × 1) (2 lignes de « une chaîne de caractères »). Taper
N(1,2) dans Scilab provoque une erreur. length(N) donne la longueur de chacune des entrées de N.
Si l’on veut récupérer les lettres d’une chaîne de caractères, on peut utiliser les fonctions strsplit ou
part. On notera l’utilisation du + à la place de la concaténation (strcat([’paul’,’ ’,’pierre’])) :
-->chc=’paul’+’ ’+’pierre’;
-->tabl=strsplit(chc,(1:length(chc)-1)) // ou tabl=strsplit(chc)
tabl =
!p !
! !
!a !
! !
!u !
! !
!l !
! !
! !
! !
!p !
! !
!i !
! !
!e !
! !
!r !
! !
!r !
! !
!e !
On aurait pu taper strsplit(chc) au lieu de strsplit(chc,(1:length(chc)-1)). Le résultat reste

un vecteur de chaînes de caractères et non pas de caractères.
-->tabl(1)+tabl(2)
ans =
pa
La concaténation des chaînes de tabl donne :

-->strcat(tabl)
ans =
paul pierre
Le paragraphe 1.5 donne quelques façons de passer des nombres à leur représentation textuelle.
1.1.3 Matrices prédéfinies

Les commandes qui suivent permettent d’obtenir des matrices particulières :
− ones(L,C) donne une matrice de L lignes et C colonnes ne contenant que des « 1 ». ones(1,N)
donne un vecteur ligne constitué de N « 1 » ;
− zeros(L,C) donne une matrice de L lignes et C colonnes ne contenant que des « 0 » ;
− eye(N,N) donne une matrice identité (N ×N ) (des « 1 » sur la diagonale, des « 0 » partout ailleurs) ;
− eye(L,C) donne une matrice (L × C) constituée d’une matrice identité I N , où N est égal à
min(L, C), complétée par une matrice de « 0 ». Ainsi, eye(1,N) donne un vecteur ligne avec un
« 1 » suivi de N − 1 « 0 » ;
− rand(L,C,"normal") donne une matrice (L × C) contenant un échantillon de variables aléatoires

gaussiennes centrées de variance égale à 1 ;
− rand(L,C,"uniform") ou rand(L,C) donne une matrice (L × C) contenant un échantillon de va-

riables aléatoires uniformément réparties sur l’intervalle [0, 1] ;
− outre les fonctions telles que hank ou toeplitz, Scilab dispose de la fonction testmatrix pour
engendrer quelques matrices particulières.
1.1.4 Constantes et initialisations

√
Un certain nombre de constantes sont prédéfinies : %pi, %i = −1, %eps, etc.
Exemple 1.7 (Constante prédéfinie et format d’affichage) Taper :
-->format(’e’,15); // 15 symboles
-->%eps
%eps =
2.22044605D-16
Il est conseillé de vérifier la valeur effective de %eps avant de l’utiliser. Il semble qu’il y ait quelque
divergence entre documentation et valeur effective.
%eps, mtlb_realmin (émulation de realmin de Matlab) et mtlb_realmax (émulation de realmax) sont

fournies en vue de réaliser des tests sur des limites. Leur valeur respective est : 2.220446049250313 1016 ,
2.225073858507201 10−308 et 1.797693134862316 10308 .
Les constantes %nan (not-a-number) et %inf (infini) peuvent être utilisées pour définir des matrices
et faire des traitements.
Exemple 1.8 Taper :

-->a=[0 %inf %nan 2]

a =
0. Inf Nan 2.
-->a+1
ans =
1. Inf Nan 3.
-->a ./ (a+1)
ans =
0. Nan Nan 0.6666667
Des opérations telles que 0/0 ou log(0) ne donnent pas %nan ou -%inf respectivement, mais un message
d’erreur.
Un certain nombre de fonctions permettent d’effectuer des traitements en éliminant les résultats qui
pourraient être égaux à %nan (nansum, thrownan, etc.).
Les constantes %s et %z sont les monômes s et z de type polynôme (équivalents à poly(0,’s’) et

poly(0,’z’), voir paragraphe 1.2.5 sur les polynômes).
Exemple 1.9 Taper :

-->typeof(%s)
ans =
polynomial
-->num=1+%s; den=%s^2+%s+1;
-->frac=num/den
frac =
1 + s
---------
2
1 + s + s
-->typeof(frac)
ans =
rational
Des variables sont réservées pour recevoir des informations telles que des chemins d’accès (taper SCI,
SCIHOME ou PWD).
1.1.5 Tableaux multidimensionnels

Les tableaux à plus de deux indices peuvent être définis directement ou à l’aide de la fonction hypermat.
Exemple 1.10 Taper :

-->B=zeros(2,2,2), C=[1:8]; B(:)=C
B =
(:,:,1)
0. 0.
0. 0.
(:,:,2)
0. 0.
0. 0.
B =
(:,:,1)
1. 3.
2. 4.
(:,:,2)
5. 7.
6. 8.
-->hypermat([2,2,2],[1:8]) // idem avec hypermat(dimensions,remplissage)
ans =
(:,:,1.0D+00)
1.0D+00 3.0D+00
2.0D+00 4.0D+00
(:,:,2.0D+00)
5.0D+00 7.0D+00
6.0D+00 8.0D+00
B=zeros(2,2,2) définit un tableau B (2 × 2 × 2) rempli de 0. L’instruction B(:)=C indique que l’on

« remplit » B avec les éléments de C.
Les fonctions repmat (construction par pavage) et cat (construction par concaténation) permettent
de construire des tableaux à partir d’autres tableaux.
1.1.6 Cellules et structures

Deux groupes de données sont plus élaborés que les tableaux de scalaires ou de chaînes de caractères :
le premier est appelé cellule (cell) et le second structure (struct).
Tableaux de cellules
Dans un tableau de cellules, les éléments peuvent être de toute nature, nombres, chaînes, tableaux,
etc. Taper :
-->langcell=cell(3,1); // definition
-->langcell(1).entries=’SCILAB’;
-->langcell(2).entries=[6 5;2 3];
-->langcell(3).entries=2013;
-->langcell(2)
ans =
{2x2 constant}
-->langcell(2).entries
ans =
6. 5.
2. 3.
-->langcell(2).entries(1,2)
ans =
5.
langcell est constitué de trois éléments : le premier est une chaîne de caractères, le second est
un tableau (2 × 2), et le troisième un scalaire. Les premières instructions peuvent être remplacées par
makecell([3,1],’SCILAB’,[6 5;2 3],2013) pour initialiser le tableau de cellules.
Ces objets peuvent être manipulés à l’aide d’un certain nombre de fonctions : makecell, iscell,
cell2mat, etc.
Exemple 1.11 (Conversion) Taper :
-->mycell=makecell([3,1],’SCILABxy’,[6 5;2 3],2013);
-->a=mycell(1), size(a), length(a)

a =
"SCILABxy"
ans =
1. 1.
ans =
3.
-->b=cell2mat(a), size(b), length(b)

b =
SCILABxy
ans =
1. 1.
ans =
8.
Dans la fonction makecell le paramètre [3,1] donne la dimension de la cellule comme dans
cell(3,1). b=cell2mat(a) convertit la cellule a en une chaîne de caractères.
Structures
Une structure est définie par la fonction struct. L’exemple qui suit définit une structure, appelée
langstruc, formée de trois champs : Language, Version et Year. L’instruction assigne la chaîne SCILAB
au premier champ, la chaîne 6.5 au second, et la valeur numérique 2013 au troisième :
-->langstruc=struct(’Language’,’SCILAB’,’Version’,’6.5’,’Year’,2013)
langstruc =
Language: "SCILAB"
Version: "6.5"
Year: 2013
-->langstruc.Year
ans =
2013
La deuxième instruction affiche le contenu de langstruc.Year. Une structure de dimension (1 × 1)

est organisée de la même façon qu’un tableau de dimension (n × 1) où n est le nombre de champs de la
structure. Les cellules peuvent ainsi être comparées à des structures avec des champs non nommés.
Ces objets peuvent être manipulés à l’aide d’un certain nombre de fonctions : isstruct, fieldnames,
setfield, etc.
1.2 Opérations et fonctions

1.2.1 Opérations matricielles
Les principales opérations matricielles sont les suivantes :
1. les opérations (+, ×), somme et multiplication de deux matrices :
Exemple 1.12 (Multiplication

[ ] [de] matrices)
1 2 5
On considère le produit × . Taper :
3 4 6
-->a=[1 2; 3 4] * [5;6]
a =
17.
39.
-->size(a)
ans =
2. 1.
La commande size(a) délivre « 2. 1. », soit les nombres de lignes et colonnes de a ;

2. le symbole \ – division matricielle à gauche – donne la solution du problème linéaire Ax = b sous
la forme x=A\b. Si A est une matrice carrée de rang plein, cela revient à multiplier sur la gauche le
vecteur b par l’inverse de A (inv(A)). Sinon, la solution est donnée au sens des moindres carrés.
Exemple 1.13 (Résolution de système linéaire) Taper :
-->A=[1 2;2 3]; b=[1;1];
-->A\b, inv(A)*b
ans =
- 1.
1.
ans =
- 1.
1.
3. l’opération A/B revient à exécuter l’opération (B’\A’)’ ;

4. l’opération ^ réalise une exponentiation de l’argument qui peut être scalaire, positif ou négatif, ou
une matrice ;
5. il faut faire attention avec les transpositions. L’opérateur « apostrophe » transpose et conjugue. La
transposition est donnée par « point, apostrophe ».
Exemple 1.14 (Transposition et transconjugaison) Taper :
-->x=[.5;.4;.2]+%i*[.6;-1;.9], x’, x.’

x =
0.5 + 0.6i
0.4 - i
0.2 + 0.9i
ans =
0.5 - 0.6i 0.4 + i 0.2 - 0.9i
ans =
0.5 + 0.6i 0.4 - i 0.2 + 0.9i
Exemple 1.15 (Quelques opérations) Taper les commandes suivantes :

-->a=[2 0;1 3]; a^2
ans =
4. 0.
5. 9.
-->a^.5
ans =
1.4142136 0
0.3178372 1.7320508
-->a=(0:3); b=(0:3); c=b*a’
c =
14.
-->d=b’*a
d =
0. 0. 0. 0.
0. 1. 2. 3.
0. 2. 4. 6.
0. 3. 6. 9.
Les vecteurs a et b sont des vecteurs lignes réels (4 × 1). Le scalaire c est égal au produit scalaire des
vecteurs a et b.
1.2.2 Opérations pointées

Les opérations pointées « .+ », « .− », « .× », « ./ » et « .^ » travaillent « terme à terme ». Ainsi, si
A = [aij ] et B = [bij ] sont deux matrices de même dimension, A .* B donne la matrice [aij bij ].
Exemple 1.16 (Opérations pointées) Taper les commandes suivantes et vérifier les résultats obte-
nus :
-->clear // libere l’espace données
-->a=(1:3)’ * (1:4); b=(5:7)’ * (1:2:7);
-->c = a.* b;
-->d=a ./ b;
-->e = a .^(.5);
-->a,b,c,d,e
Dans cette séquence d’instructions :
− a et b sont deux matrices (3 × 4). Elles sont obtenues par multiplication d’un vecteur colonne (3 × 1)
et d’un vecteur ligne (1 × 4) ;
− c est une matrice qui a ci,j = ai,j × bi,j comme élément générique ;
− d est une matrice d’élément di,j = ai,j /bi,j ;

√
− e est une matrice de composantes ei,j = ai,j .
Exemple 1.17 (Séquence alternée, autre construction)

(-1).^[0:9] donne un séquence alternée de 1 et −1.
1.2.3 Fonctions mathématiques

Certaines fonctions manipulent les matrices comme des tables de valeurs. C’est le cas pour abs, sqrt,
exp, cos, sin, log, tan, acos, asin, atan, etc.
Exemple 1.18 (Fonction exponentielle) Taper :

-->T=1024; tims=(0:T-1);
-->fq =[.01 .013 .014];//===== trois frequences
-->sig = exp(2*%i*%pi*tims’*fq);//===== signal complexe
-->plot(tims’, real(sig))
tims est un vecteur (1 × 1024) et tims’*fq est une matrice (1024 × 3). On peut vérifier ces dimensions
en utilisant whos :
-->whos -name tims

Nom Type Dimensions Octets
tims constant 1 par 1024 8208
-->whos -name fq
fq constant 1 par 3 40
-->whos -name sig

sig constant 1024 par 3 49168

signal_processinglib library 2056
Les instructions who et who_user() peuvent aussi être utilisées.
L’instruction sig = exp(2*%i*%pi*tims’*fq); applique l’exponentielle à chaque élément de la ma-

trice 2*%i*%pi*tims’*fq. Le résultat est la matrice sig (1024×3). L’instruction plot(tims,real(sig))
trace les trois cosinus avec des couleurs différentes. Les couleurs choisies sont prises dans une table de
couleurs « Rouge, Vert, Bleu » indexées initialisée par défaut à :
index R V B
1 0 0 1
2 0 0,5 0
3 1 0 0
4 0 0,75 0,75
5 0,75 0 0,75
6 0,75 0,75 0
7 0,25 0,25 0,25
La table de couleurs peut être modifiée (fonction set(gcf(),"color_map",cmap)). Un certain nombre

de tables sont prédéfinies (graycolormap, jetcolormap, etc.).
Fonctions « Built-in »
Un grand nombre de fonctions peuvent être appelées dans Scilab. Certaines sont fournies par l’envi-
ronnement de Scilab, tandis que d’autres peuvent être développées par des tierces parties.
Parmi toutes ces fonctions, le contenu de certaines d’entre elles peut être visualisé directement, tandis
que d’autres sont écrites en langage machine pour des raisons de vitesse d’exécution.
Exemple 1.19 (Source de fonctions et fonctions compilées) Taper : mtlb_type companion. Sci-
lab affiche le texte de la fonction companion. Toutefois, la commande mtlb_type fft donne :
-->mtlb_type fft
mtlb_type : Ne peut pas ouvrir ’fft’ ni ’fft.m’ ni ’fft.sci’.
signifiant que le code source n’est pas accessible.
1.2.4 Fonctions de matrices

Comme on l’a vu, la commande exp(a) calcule la matrice [exp(a(i, j))]. Cette opération ne doit pas
être confondue avec l’exponentielle de matrice. La lettre « m » ajoutée au nom de la fonction expm(A),
logm(A), sqrtm(A) signifie que l’on a affaire à des fonctions de matrices. Ainsi, eA est définie par :
A Ak
eA = I + + ··· + + ···
1! k!
et est obtenue par l’instruction expm(A).
1.2.5 Autres fonctions utiles

Algèbre linéaire
− La fonction spec donne les valeurs propres et les vecteurs propres d’une matrice.
Exemple 1.20 (Spectre d’une matrice) Taper :
-->[al,be]=spec([1 2;3 4])

be =
- 0.3722813 0
0 5.3722813
al =
- 0.8245648 - 0.4159736
0.5657675 - 0.9093767
-->al*be*inv(al)
ans =
1. 2.
3. 4.
− la fonction poly construit un objet « polynôme » associé à une matrice (polynôme caractéristique),
ou un polynôme dont les racines ou les coefficients sont données par le vecteur argument (voir aussi
l’exemple 1.9).
Exemple 1.21 (Polynômes) Taper :
-->mp=poly([1 2],"x") // option "roots" par defaut

mp =
2
2 - 3x + x
-->mp=poly([1 2],"x","coeff") // option "coeff"
mp =
1 + 2x
-->mp=poly([1 2;3 4],"x") // poly. caracteristique
mp =
2
- 2 - 5x + x
-->typeof(mp)
ans =
polynomial
-->coeff(mp)
ans =
- 2. - 5. 1.
Les matrices polynômiales peuvent être construites à l’aide de la fonction inv_coeff ;

− la fonction roots retourne les racines d’un polynôme dont les coefficients sont donnés par puissances
décroissantes.
Exemple 1.22 (Racines) Taper :
-->a=[1 2;3 4]; spec(a), mp=poly(a,"x")

ans =
- 0.3722813
5.3722813
mp =
2
- 2 - 5x + x
-->[roots(mp),roots(mtlb_fliplr(coeff(mp)))]
ans =
5.3722813 5.3722813
- 0.3722813 - 0.3722813
La fonction mtlb_fliplr « retourne » un vecteur ligne v (permutations de v(k) et v($ − k + 1)).
Exemple 1.23 (Fonction de transfert)

La modélisation de systèmes linéaires invariants dans le temps par une représentation d’état nécessite,
le plus souvent, que l’on donne aussi leur représentation sous forme de fonction de transfert. Dans le
cas de systèmes à une entrée et une sortie, cette dernière s’exprime par le scalaire d + cT (sI n − A)−1 b
(transformée de Laplace) ou d + cT (zI n − A)−1 b (transformée en z) selon que l’on est en temps continu
ou discret. A est la matrice d’état (n × n) et I n la matrice unité (n × n). b et c sont deux vecteurs
(n × 1)) et d un scalaire. Scilab n’étant pas un outil de calcul formel, il nous faut calculer les coefficients
des polynômes numérateur et dénominateur de cette fonction de transfert.
Pour ce faire, on part de l’égalité det(I n + XY ) = det(I m + Y X) où X et Y sont deux matrices
n × m et m × n respectivement. On peut alors écrire (dans le cas du temps continu, le cas du temps
discret étant identique) :
det(1 + cT (sI n − A)−1 b) = det(I n + (sI n − A)−1 bcT )

= det((sI n − A)−1 )det(sI n − A + bcT )
det(sI n − A + bcT )
=
det(sI n − A)
On en déduit la fonction de transfert :
det(sI n − A + bcT )
d−1+
det(sI n − A)
-->A=[-1.5,.5;.5,-1.5]; c=[1;1]; b=[1;1]; // d=0
-->pD=poly(A,"s"), pB=poly(A-b*c.’,"s"); pN=pB-pD

pD =
2
2 + 3s + s
pN =
4 + 2s
1.3 Structures de base

Nous avons vu en début de chapitre comment créer un programme en y insérant une suite d’ins-
tructions. Les deux structures de programmation « tests » et « boucles » enrichissent cette structure
simpliste. Les tests portent sur des expressions logiques ou « booléennes » et résultent en des « ruptures
de séquence » tandis que les boucles donnent des répétitions.
1.3.1 Opérateurs logiques et variables booléennes

Les comparaisons
La comparaison entre variables utilise les opérateurs « == », « ~= », « > », « < », « >= », « <= »,
« <> ».
Les quantités booléennes peuvent être utilisées dans les structures de programmation telles que :
« if ... elseif ... else ... end », « select ... case ... else ... end », « while ... end »
et dans la fonction find.
Exemple 1.24 (Comparaisons) Taper :

-->z=0; if z==0, %T, else %F, end
%T =
où %F et %T sont les constantes booléennes « faux » et « vrai » respectivement.
Exemple 1.25 (Utilisation de while) Ecrire et sauver le programme calcule.sce donné ci-après.
//===== calcule.sce
n=1; xe=1; f=1; merr=1;
while merr>%eps
f=f*n; merr=1/f;
xe1=xe+merr;
n=n+1; xe=xe1;
end
Ce programme calcule une valeur approchée de e à l’aide de son développement en série 1 + 1 + 1/2! +
1/3! + · · · . Le test d’arrêt porte sur la différence de deux valeurs successives soit 1/n!. Tant que cette
valeur est supérieure à %eps, le calcul continue.
L’exécution, et l’affichage du résultat xe, sont obtenus en tapant exec(’calcule.sce’,-1), xe. Le
paramètre « -1 » de l’instruction exec indique que l’on ne veut pas visualiser les instructions pendant
l’exécution.
Opérateurs logiques
Les opérateurs logiques AND (symbole &), OR (symbole |), et NOT (symbole ~) opèrent sur des
quantités booléennes. Les variables prédéfinies « faux » et « vrai » sont désignées par %f, ou %F, et %t, ou
%T, respectivement. Elles ont le type boolean – constante booléenne – (taper typeof(%t)).
Exemple 1.26 (Fonctions logiques) Reprenant l’exemple 1.32, taper :

-->A=ones(4,4); B=triu(A,1); C=(A==B)
C =
F T T T
F F T T
F F F T
F F F F
-->[l,c]=find(B)
c =
2. 3. 3. 4. 4. 4.
l =
1. 1. 2. 1. 2. 3.
Exemple 1.27 (Table de fonctions logiques) Taper :

-->A=[%f %f %t %t]; B=[%f %t %t %f]; typeof(A)
ans =
boolean
-->C = A & B, C = A | B
C =
F F T F
C =
F T T T
-->C = A .* B, typeof(C)
C =
0. 0. 1. 0.
ans =
constant
Remarques
La dernière instruction de l’exemple précédent effectue une multiplication « terme à terme ». Il y a
conversion (fonction bool2s) des booléens en constantes 0 (%f) ou 1 (%t). Le booléen %t correspond à la
valeur 1, %f correspond à la valeur 0.
Il y a toujours deux façons de traiter des expressions logiques. On peut utiliser les constantes %t ou
%f ou utiliser leur « valeur numérique 1 ou 0 respectivement (voir exercices 1.3 et 10.2).
Il faut aussi distinguer les opérations « numériques » ⊕ (addition opération modulo 2 ou « OU exclu-
sif ») qui est différente du OU (« OU inclusif ») et ⊗ qui se confond avec la multiplication normale.
opérateur utilisation de %t et %f utilisation de 0 et 1

ou (|) b1=%t; b2=%f; or([b1,b2]), bn1=1; bn2=0; max([bn1,bn2])
ou b1 | b2, donne T donne 1.
et (&) and([b1,b2]), ou b1 & b2, min([bn1,bn2]), ou bn1 * bn2,
donne F donne 0.
⊕ modulo(b1+b2,2) donne 1. modulo(bn1+bn2,2) donne 1.
⊗ b1 * b2 donne 0. bn1 * bn2, ou min([bn1,bn2]),
donne 0.
isnan (Not-a-Number), isinf (infini), isascii, isalphanum, iscell, etc. sont des booléens utilisés
pour tester l’état ou le type de variables.
1.3.2 Les boucles

Nous avons vu l’utilisation du « while », mais, le plus souvent, on utilise la structure for ... end.
Exemple 1.28 (Boucles de programmes) Taper :

->A=[1 .5; .5 .25];
-->M=eye(2,2); // matrice unite
-->for k=1:5, M = M * A; end
-->M
M =
2.4414063 1.2207031
1.2207031 0.6103516
Cette boucle calcule A5 .Comme pour tous les interpréteurs, l’utilisation de boucles détériore considé-
rablement les performances . Il est conseillé de les éviter autant que faire se peut.
Exemple 1.29 (Eviter les boucles...) Taper :

-->a=rand(400,400);
-->tic; for k=1:400, for m=1:400, a(k,m)=a(k,m)^2; end, end, toc

ans =
0.452
-->tic, a=a.^2; toc
ans =
0.009
tic démarre le chronomètre (précision de l’ordre de la ms), toc l’arrête en donnant le temps écoulé,
en secondes, depuis son démarrage.
1.3.3 Boucles implicites, min, max, find, etc.

1. Les fonctions min, max, median fournissent la valeur demandée – minimum, maximum, médiane –
et l’indice en lequel elle a été trouvée dans la matrice.
Exemple 1.30 (Fonctions min, max, median) Taper :
-->a=[1 2;3 4], median(a), median(a,1), median(a,2)

a =
1. 2.
3. 4.
ans =
2.5
ans =
2. 3.
ans =
1.5
3.5
-->max(a), max(a,"c"), min(a,"m")
ans =
4.
ans =
2.
4.
ans =
1. 2.
Le paramètre "c" indique que l’on cherche selon les colonnes ("r" selon les lignes) et "m" suivant
la même règle que Matlab.
2. La fonction find délivre les indices pour lesquels la condition donnée est remplie.
Exemple 1.31 (Fonction de recherche) Taper :
-->a=rand(3,3), find(a>.5), [l,c]=find(a>.5)

a =
0.1985144 0.2312237 0.6525135

0.5442573 0.2164633 0.3076091
0.2320748 0.8833888 0.9329616
ans =
2. 6. 7. 9.
c =
1. 2. 3. 3.
l =
2. 3. 1. 3.
rand(3,3) fournit un tableau (3 × 3) obtenu par un tirage « aléatoire » de nombres dans l’intervalle
[0, 1]. La première forme du find donne l’indice linéaire, tandis que la seconde fournit les couples
(ℓ(i), c(i)) d’indices des éléments qui remplissent la condition.
Exemple 1.32 (Quelques autres fonctions) Ce qui suit construit tous les couples (m, n), m ̸=
n, obtenus à partir des quatre chiffres 1 à 4.
-->A=ones(4,4); B=triu(A,1) // matrice triangulaire superieure

B =
0. 1. 1. 1.
0. 0. 1. 1.
0. 0. 0. 1.
0. 0. 0. 0.
>-->[nl,nc]=find(B==1); [nl;nc]
ans =
1. 1. 2. 1. 2. 3.
2. 3. 3. 4. 4. 4.
1.4 Les affichages

1.4.1 Affichage 2D
Dans la fenêtre active, la commande plot peuvent être utilisées pour afficher graphiquement des
résultats.
Si x et y sont deux vecteurs de même longueur, plot(x,y) affiche le graphe de y en fonction de
x. Exemple : plot([0;1],[0;1],’red:’) trace un segment d’extrémités (0, 0) et (1, 1) avec une ligne
pointillée rouge (paramètre ’red:’).
Par défaut, plusieurs tracés successifs dans une même fenêtre se superposent. Si ce n’est pas désiré,
on peut utiliser clf pour effacer le contenu de la fenêtre.
− si x et y sont deux matrices réelles de même taille plot(x,y) affiche la première colonne de y en
fonction de la première colonne de x, la seconde colonne de y en fonction de la seconde colonne de
x, etc. Chaque tracé a sa propre couleur ;
− si x est un vecteur réel de longueur N , et y réelle de taille (N × K), plot(x,y) affiche K graphes,
correspondant aux K colonnes, de y en fonction de x ;
− si x est un vecteur complexe, l’affichage du graphe correspondant doit être fait par
plot(real(x),imag(x)).
Exemple 1.33 (Tracés de complexes) Si on veut obtenir le tracé des points

x=[1;2;4]+i*[-1;0;2] avec des « croix », on écrit :
-->set(gca(),"auto_clear","on")
-->x=[1;2;4]+%i*[-1;0;2]; plot(real(x),imag(x),’x’), set(gca(),"grid",[1 1])
set(gca(),"auto_clear","on") inhibe la superposition des tracés. set(gca(),"grid",[1 1])

définit le quadrillage. Le paramètre [1 1] indique que l’on introduit un quadrillage en x et en y,
les deux valeurs [1 1] en donnant la couleur. [1 -1] donnerait un quadrillage noir en x mais pas
en y.
− on peut définir des sous-fenêtres de tracés dans une fenêtre à l’aide de subplot.
Exemple 1.34 (Sous-fenêtres de tracés) Taper :
-->x=(0:%pi/10:2*%pi);
-->subplot(2,1,1), plot(x,sin(x)), set(gca(),"grid",[1 1]) // ou subplot(211)
-->subplot(2,1,2), plot(x,cos(x)), set(gca(),"grid",[1 1]) // ou subplot(212)
On peut « mélanger » les dimensions.

Exemple 1.35 (Mélange de sous-fenêtres de tracés) Taper :
-->clf; f0=.1; tps=[0:20];
-->for k=1:3, subplot(2,3,k), plot(tps,sin(2*%pi*f0*tps)), end
-->subplot(212), plot(tps,cos(2*%pi*f0*tps),’-r’,tps,cos(2*%pi*f0*tps),’o’)
La fonction xsetech permet de définir plus finement (encore que l’on ne puisse que donner des
« pourcentages » des dimensions de fenêtre) les zones des tracés que subplot qui ne laisse pas le
choix des tailles.
Exemple 1.36 (Tracé d’un cercle) Taper :

-->z=exp(2*%pi*%i*[0:100]/100);
-->figure(1); clf, plot(real(z),imag(z));
-->a=get("current_axes"); a.isoview="on"; a.data_bounds = [-1.1,-1.1;1.1,1.1];
La commande a.isoview="on" force l’affichage à s’insérer dans un carré. La seconde, a.data_bounds

= [-1.1,-1.1;1.1,1.1], définit un cadre d’affichage.
Il existe d’autres fonctions pour le tracer : plot2d (voir exemple qui suit), plot2d2 (tracé en « marches
d’escalier »), plot2d3 (tracé avec des « bâtons »), plot2d4 (tracé avec des « flèches » à la place de
segments).
Exemple 1.37 (Tracé de diagramme de Bode) En reprenant la fonction de transfert de l’exemple

1.23, taper (voir figure 1.7 ) :
//===== testbode.sce
w=logspace(-1,1,100);
//===== Laplace transform with s=jw
s=%i*w; vnum=2*s+4; vden=s.*s+3*s+2;
//===== gain complexe
gcplx=vnum ./ vden;
//===== tracer
subplot(211), plot2d("ln",w,20*log10(abs(gcplx))), // gain
set(gca(),"grid",[1 1])
mphi=180*atan(imag(gcplx),real(gcplx))/%pi;
subplot(212), plot2d("ln",w,mphi) // phase
2s+4
Figure 1.7 – Tracé du diagramme de Bode de s2 +3s+2
Le paramètre "ln" de plot2d indique que l’on prend ω en échelle logarithmique (l) et le gain de
décibels 20 log10 (gain) en linéaire (n). Ce tracé peut être fait par la fonction bode qui est une des fonctions
disponibles dans Scilab.
Exemple 1.38 (Cardioïde)

La fonction polarplot permet d’obtenir des tracés en polaire (voir figure 1.8 pour une cardioïde). Taper :
//===== cardioide.sce
clf()
theta=[0:0.02:2*%pi]’; rho=1+cos(theta)
polarplot(theta,rho)
a=gca(); a.isoview=’on’
90
120 60
150 30
180 0.3 0.6 0.9 1.2 1.5 1.8 0
210 330
240 300
270
Figure 1.8 – Tracé d’une cardioïde
Exemple 1.39 (Tracé d’une ellipse et notion de fonction)

Les exposants T et H font référence à la transposition et à la transconjugaison respectivement. Dans sa
forme matricielle, l’équation d’une ellipse est :
(X − X 0 )T E(X − X 0 ) = c
où c est une constante positive, X 0 un vecteur de dimension 2 donnant le centre de l’ellipse, et E une
matrice symétrique positive (2 × 2) (ce qui signifie que, ∀ Y , vecteur complexe, Y H EY est un nombre
positif). Une façon simple d’obtenir une matrice positive est de partir d’une matrice réelle quelconque
réelle G et de calculer E = GT G.
En diagonalisant E, on a E = P DP T où D est diagonale avec tous ses éléments diagonaux positifs,
et P une matrice unitaire, c’est-à-dire telle que P P T = P T P = I où I est la matrice identité.
Soit F = P D 1/2 P T . On a F = F T et F T F = E. F est appelée racine carrée de E. On peut alors
écrire (X − X 0 )T E(X − X 0 ) = (X − X 0 )T F T F (X
√ − X 0 ). En posant Y = F (X − X 0 ), on a Y Y = c
T
qui est l’équation d’un cercle de centre O et rayon c dans des coordonnées orthonormales. Ceci conduit
à la procédure de calcul qui suit :
√
1. Calculer Y = c[cos θ sin θ]T pour θ = 0 à 2π par pas de 2π/N .
2. Faire le changement de variable X = X 0 + F −1 Y .
La fonction de calcul des points d’une ellipse définie par X0, E, et c comme paramètres peut être écrite
de la façon qui suit. Taper cette fonction et sauvez-la avec l’extension sci (Scilab propose ellipse.sci
comme nom de fichier au moment de la sauvegarde) :
function ellipse(X0, E, c)
N=100; theta = (0:N) * (2*%pi) ./ N;
Y = sqrt(c)*[cos(theta);sin(theta)]; // cercle
Fm1=inv(sqrtm(E)); X = diag(X0)*ones(2,N+1)+Fm1*Y;
plot(X(1,:),X(2,:)); set(gca(),"isoview","on");
endfunction
Avant d’appeler cette fonction il faut signaler à Scilab que l’on veut utiliser des fonctions présentes
dans un répertoire donné, ici le répertoire courant. C’est le rôle de la fonction getd. L’appel à ellipse
peut être ensuite être fait :
--> getd() // ou getd
-->X0=[0,0]; c=1; E=[1.3628 .7566;.7566 .5166]; ellipse(X0, E, c);
Pour plusieurs valeurs c = {1, 2, 3, 4, 5} on obtient la figure 1.9 :
-->clf, for c=1:5, ellipse(X0, E, c); end
-->set(gca(),"grid",[1 1])
−2
−4
−6
−8
−4 −2 0 2 4
Figure 1.9 – Tracé des ellipses
√
On peut vérifier que les axes ont pour longueur 1/ λk , où λk est une valeur propre, de direction
donnée par le vecteur propre associé. Les vecteurs propres (fonction spec) ont 1 pour norme :
-->[P,Delta]=spec(E); P’ * P
ans =
1. 0.
0. 1.
Le programme ellaxes.sce trace les deux axes de l’ellipse lorsque le booléen tra a la valeur « vrai »
(figure 1.10 ).
//===== ellaxes.sce
clf
tra=%t
X0=[0,0]; c=1; E=[1.3628 .7566;.7566 .5166];
ellipse(X0, E, c); set(gca(),’grid’,[1 1])
if tra then
[vecp,valp]=spec(E); ml=sqrt(diag(1./valp));
v1=X0’-ml(1)*vecp(:,1); v2=X0’+ml(1)*vecp(:,1);
w1=X0’-ml(2)*vecp(:,2); w2=X0’+ml(2)*vecp(:,2);
plot([v1(1) v2(1)],[v1(2) v2(2)],’-r’,[w1(1) w2(1)],[w1(2) w2(2)],’-r’)
end
−1
−2
−3
−4
−2 −1 0 1 2
Figure 1.10 – Tracé de l’ellipse avec ses axes
1.4.2 Affichage 3D
Fonctions z = f (x, y)
Lorsque l’on a une fonction du type z = f (x, y) la fonction meshgrid permet de définir toutes les
coordonnées d’un quadrillage. Les fonctions mesh ou surf effectuent le tracé.
Exemple 1.40 (Tracé d’une gaussienne en 3D) Taper :

//===== trace2D.sce =====
ocean=%t;
x=(-2:.1:2); y=(-2:.1:2);
[X,Y]=meshgrid(x,y); Z=exp(-(X.^2+Y.^2)/2);
figure(0); mesh(X,Y,Z);
hhs=get("current_axes"); hhs.grid=[1,1]; hhs.children.thickness=4;
xs2eps(gcf(), "../images/trace2Dtest.eps");
hhm=figure(1); surf(X,Y,Z);
if ocean
hhm.color_map = oceancolormap(32);
end
La fonction xs2eps exporte la figure obtenue au format « postscript encapsulé ».

Le booléen ocean positionné à %t ou %f permet, ou non, d’appliquer la palette de couleur
oceancolormap.
Les graphes obtenus sont représentés figure 1.11 .
Surfaces données par les points M (x(t), y(t), z(t))

La fonction param3d permet de tracer des courbes 3D générales.
Exemple 1.41 (Tracé d’une portion de sphère) Taper :

//===== sphere.sce
theta=(0:0.1:%pi); phi=(-%pi/4:0.1:%pi/2);
Nt=length(theta); Np=length(phi);
x=cos(phi’)*cos(theta); y=cos(phi’)*sin(theta);
z=sin(phi’)*ones(1,Nt);
param3d(x,y,z,30 -60);
a=gca(); a.isoview="on";
a.thickness=.5; a.line_style=2;
0.8
0.6
0.2
2
1 0
2
0 1
Y
−1 0
X
−1
−2 −2
Figure 1.11 – Tracé d’une gaussienne : à gauche avec mesh, à droite avec surf
et la palette de couleurs standard
1
−1 0.5
0 z
−0.5
−0.5
0
x 1
0.8
0.5 0.6
0.4 y
0.2
1 0
Figure 1.12 – Portion de sphère
1.4.3 Remarque sur les tracés de courbes

Il faut penser à utiliser les aptitudes de Scilab à manipuler des complexes lorsqu’on veut tracer des
courbes. Considérons en exemple une courbe de Bézier (spline cubique) telle que celles qui sont utilisées
par Adobe Illustrator⃝R
. Son équation est donnée par :
P (t) = P0 t3 + 3P1 t2 (1 − t) + 3P2 t(1 − t)2 + P3 (1 − t)3 avec t ∈ [0, 1] (1.1)
où P0 , P1 , P2 et P3 forment le « polygone de contrôle ». P0 et P3 sont des « points de passage » et P1 et

P2 sont des « points de contrôle » ou « poignées ».
Exemple 1.42 (Tracé d’une courbe de Bézier) Taper :

//===== mybezier.sce
clear, clf
Npts=100; t=(0:1/(Npts-1):1);
//===== points de controle
P0=0; P1=.5+%i; P2=1.4-2*%i; P3=1.5; mypts=[P0;P1;P2;P3]
plot(real(mypts),imag(mypts),’o’), set(gca(),’grid’,[1 1])
set(gca(),"auto_clear","off")
plot(real(mypts),imag(mypts),’:’)
t2=t.*t; t3=t2.*t; Omt=1-t; Omt2=Omt .* Omt; Omt3=Omt2 .* Omt;
Pt=P0*t3 +3 * P1 * t2 .* Omt +3 * P2 * t .* Omt2 + P3 * Omt3;
plot(real(Pt),imag(Pt)), set(gca(),"auto_clear","on")
adb=get(gca(),"data_bounds")+.2*[-1,-1;1,1]; set(gca(),"data_bounds",adb)
1,5
0,5
−0,5
−1
−1,5
−2
−2,5
−0,2 0 0,2 0,4 0,6 0,8 1 1,2 1,4 1,6 1,8
Figure 1.13 – Courbe de Bézier obtenue avec le programme mybezier.m
1.4.4 Les animations

Exemple 1.43 (Tracé progressif, utilisation de delete) Taper :
//===== myanim.m
clear, clf
trc=%t;
f0=1/2; Ts=.05; t=(0:Ts:2); Lt=length(t);
y=sin(2*%pi*f0*t);
subplot(211), plot(t,y,’o’,t,y); set(gca(),"grid",[1 1])
adb=get(gca(),"data_bounds");
subplot(212); a=gca(); set(a,"data_bounds",adb)
for k=2:Lt
if trc plot([t(k-1),t(k)],[y(k-1),y(k)],’-’,t(k),y(k),’or’); end
plot(t(k),y(k),’o’); hh=gce();
xpause(100000) // microsecondes
delete(hh)
end
set(gca(),"auto_clear","on")
Le paramètre trc permet de choisir le type de tracé, continu ou avec des « points ». gce() désigne
l’objet graphique courant, ici le point ou le segment tracé. Le paramètre de la fonction xpause permet
de régler le temps de pause, donc la vitesse du tracé.
Les fonctions comet et comet3d permettent de construire des animations.
Exemple 1.44 (Tracé de courbe de Lissajous) Taper :
phi=linspace(0,2*%pi,100);
clf, comet(sin(3*phi),cos(2*phi+%pi/6))
1.5 Conversion de nombres en chaînes de caractères

Il existe plusieurs façons de passer de quantités numériques à leur représentation textuelle (voir pa-
ragraphe 1.1.2) :
1. considérons la fonction xstringb. Cette dernière permet d’ajouter du texte dans un graphe aux
coordonnées (x, y) (figure 1.14 ). Taper et sauver le programme ellipsecom.sce :
//===== ellipsecom.sce =====

clear
X0=[0,0]; E=[1.3628 .7566;.7566 .5166];
getd // pour charger la fonction ellipse
clf, for c=1:5, ellipse(X0, E, c); end
r=[-6,-7.5,7,1.5]; xrect(r(1),r(2)+r(4),r(3),r(4))
str=["$( X - X_{0} )^H E ( X - X_{0}) = c$"];
xstringb(r(1),r(2),str,r(3),r(4),"fill");
puis exec(’ellipsecom.sce’,-1).
−2
−4
−6
−8
−4 −2 0 2 4
Figure 1.14 – Tracé des ellipses avec légende
La chaîne de caractère est ici obtenue à partir d’une expression (entre les $). La commande
xstringb(x,y,str,w,h,"fill") signifie que le rectangle de tracé est positionné en (x, y) (point
bas-gauche du rectangle de tracé), qu’il a une largeur w et une hauteur h prise « vers le haut »
lorsque h > 0. "fill" indique que la chaîne de caractère remplit au mieux le rectangle ;
2. pour afficher une valeur numérique, il faut la convertir d’abord en chaîne de caractères. Ceci peut
être fait à l’aide de la fonction string.
Exemple 1.45 (Nombres et chaînes de caractères) Taper :
-->x=(0:.3:1.5); typeof(x(1))
ans =
constant
-->y=string(x), typeof(y(1))
y =
!0 0.3 0.6 0.9 1.2 1.5 !

ans =
string
3. la fonction msprintf peut aussi être utilisée pour obtenir des chaînes de caractères.
Exemple 1.46 (Création de la chaîne de caractères) Taper :

-->fq=[10.5 20.566];
-->valf=msprintf(’F1 = %+15.2f, F2 = %4.2e’, fq(1),fq(2))

valf =
F1 = +10.50, F2 = 2.06e+01
L’expression msprintf(...) fournit une chaîne de caractères selon le format spécifié par ’F1 =
%+15.2f, F2 = %4.2e’. Pour plus d’information, il faut se tourner vers la fonction printf du
langage C ;
4. title, legend permettent d’afficher des informations dans une fenêtre de tracer.
1.6 Entrées/sorties
1.6.1 Entrées à partir du clavier ou de la souris
Scilab permet d’effectuer des opérations d’entrées/sorties à partir du clavier, de l’écran ou avec des
fichiers :
1. input pour acquisition à partir du clavier ;
Exemple 1.47 (Acquisition à partir du clavier) Taper :

-->x=input("valeur:"), typeof(x)
valeur:12
x =
12.
ans =
constant
-->x=input("valeur:", "string"), typeof(x)
valeur:chaine
x =
chaine
ans =
string
2. xgetmouse pour récupérer les coordonnées lors d’un « click » dans la fenêtre graphique (voir exemple
1.48) ;
Les fonctions mprinf, msprintf, disp peuvent alors être utilisées pour afficher, ou simplement
convertir, des quantités numériques en chaînes de caractères.
Exemple 1.48 (Acquisition et affichage dans la fenêtre graphique) Taper le programme

qui suit (waitclick), sauvegardez-le et exécutez-le.
//===== waitclick.sce =====
t=(0:%pi/10:2*%pi);
plot(180*t/%pi,sin(t),"diamred")
x=0;
while x>=0
[rep]=xgetmouse([%f,%t]); // acquisition position
x=rep(1); y=rep(2);
aff=[msprintf(’%+5.3f’,x); msprintf(’%+5.3f’,y)];
xstringb(x+10,y-.1,aff,60,.2,"fill");
xrect(x+10,y+.1,60,.2)
plot(x,y,’xr’)
end
Lorsque l’on clique sur la zone « x < 0 », on revient à la fenêtre de commande.

0,8
0,6
0,4
0,2
−0,2
−0,4
−0,6
−0,8
−1
−50 0 50 100 150 200 250 300 350 400
Figure 1.15 – Affichage des coordonnées
1.6.2 Entrées/sorties dans des fichiers

1. load, save pour charger tout ou partie des variables dans un fichier avec un format propre à Scilab.
Exemple 1.49 (Utilisation de load et save) Taper :
-->tps=[0:20]; f1=.07; f2=.11;
-->x1=exp(2*%i*%pi*f1*tps); x2=exp(2*%i*%pi*f2*tps);
-->save(’vals.dat’,’x1’,’x2’);
-->clear x1 x2
-->load(’vals.dat’,’x1’,’x2’);
-->plot(real(x1)), plot(real(x2),’r’); set(gca(),’grid’,[1 1])
2. Les fonctions mopen, mget, mput, mclose , etc. sont utilisées pour les entrées-sorties dans des fichiers.
Exemple 1.50 (Entrées/sorties dans un fichier) Taper :
-->clear; x=[1:100];
-->fid=mopen(’try1.dat’,’wb’);
-->mput(x,"f",fid); % Writing
-->mclose(fid);
puis :
-->clear; fid=mopen(’try1.dat’,’rb’);
-->y=mget(20,"f",fid); % Reading
-->mclose(fid);
Le fichier de données try1.dat est créé avec un tableau x de 100 nombres flottants. La relecture
fournit un tableau y de 20 flottants.
3. D’autres fonctions facilitent le travail du programmeur, entre autres :
meof pour savoir si l’on a atteint la fin du fichier

mfprintf écrit des données formatées dans un fichier
fprintfMat écrit une matrice dans un fichier
mfscanf lit dans un fichier comme la fonction fscanf du « C »
fscanfMat lit une matrice dans un fichier
mgetl lit des lignes d’un fichier texte
mgetstr lit une chaîne de caractères dans un fichier
mprintf formate des données pour affichage dans la fenêtre de Scilab
mputl écrit des chaînes de caractères dans un fichier texte
mputstr écrit une une chaîne de caractères dans un fichier
mseek définit la valeur du pointeur dans un fichier binaire
mtell gestion de fichier binaire
mdelete suppression de fichier
4. Des fonctions permettent de récupérer des données dans un fichier Excel dont il faudra vérifier la
version pour pouvoir y accéder dans Scilab.
Exemple 1.51 (Accès à un fichier « .csv ») Considérons le fichier donnees.csv :
-->mtlb_type donnees.csv
!"rang";"racine" !
! !
!1;1,0000000 !
! !
!2;1,4142136 !
! !
!3;1,7320508 !
! !
!4;2,0000000 !
! !
!5;2,2360680 !
! !
!6;2,4494897 !
! !
!7;2,6457513 !
! !
!8;2,8284271 !
! !
!9;3,0000000 !
! !
!10;3,1622777 !
! !
!11;3,3166248 !
L’exploitation directe de ce fichier peut être faite directement par :
// ----- traitcsv.sce
clear
fid=mopen(’donnees.csv’,’rt’);
x=mgetl(fid);
mclose(fid)
lx=size(x,1);
for k=2:lx
lstr=length(x(k));
idx=strindex(x(k),’;’);
a(k-1,1)=eval(part(x(k),1:idx-1));
y=strsubst(part(x(k),idx+1:lstr),’,’,’.’);
a(k-1,2)=eval(y);
end
plot(a(:,1),a(:,2),’-’,a(:,1),a(:,2),’o’)
set(gca(),’grid’,[1 1])
La fonction csvRead permet d’effectuer le même traitement :

-->xc=csvRead(’donnees.csv’,’;’,’,’);
-->a=xc(2:$,:)
a =
1. 1.
2. 1.4142136
3. 1.7320508
4. 2.
5. 2.236068
6. 2.4494897
7. 2.6457513
8. 2.8284271
9. 3.
10. 3.1622777
11. 3.3166248
La conversion par défaut est faite en « double » (on aurait pu taper

csvRead(’donnees.csv’,’;’,’,’,’double’)). Si on avait eu des chaînes de caractères leur
conversion aurait donné NaN.
Dans la commande csvRead(’donnees.csv’,’;’,’,’); le ’;’ indique le séparateur de champs
utilisé lors de la sauvegarde, tandis que le ’,’ donne le symbole séparateur dans une représentation
numérique.
Considérons maintenant le fichier donnees2.csv contenant des chaînes de caractères :
!"rang";"racine"; !
! !
!1;1,0000000;"23/04/2014" !
! !
!2;1,4142136;"24/04/2014" !
! !
!3;1,7320508;"25/04/2014" !
! !
!4;2,0000000;"26/04/2014" !
! !
!5;2,2360680;"27/04/2014" !
! !
!6;2,4494897;"28/04/2014" !
! !
!7;2,6457513;"29/04/2014" !
! !
!8;2,8284271;"30/04/2014" !
! !
!9;3,0000000;"01/05/2014" !
! !
!10;3,1622777;"02/05/2014" !
! !
!11;3,3166248;"03/05/2014" !
On peut convertir en conservant le type « chaîne de caractères » de la façon suivante :
-->xx=csvRead(’donnees2.csv’,’;’,’,’,’string’)
Attention : Le fichier ’donnees2.csv’ est déjà ouvert dans Scilab.
ans =
!"rang" "racine" !
! !
!1 1.0000000 "23/04/2014" !
! !
!2 1.4142136 "24/04/2014" !
! !
!3 1.7320508 "25/04/2014" !
! !
!4 2.0000000 "26/04/2014" !
! !
!5 2.2360680 "27/04/2014" !
! !
!6 2.4494897 "28/04/2014" !
! !
!7 2.6457513 "29/04/2014" !
! !
!8 2.8284271 "30/04/2014" !
! !
!9 3.0000000 "01/05/2014" !
! !
!10 3.1622777 "02/05/2014" !
! !
!11 3.3166248 "03/05/2014" !
-->a=eval(xx(2:$,1:2));
-->y=part(xx(2:$,3),2:length(xx(2,3))-1);
Si on avait converti en type « double » la conversion de la dernière colonne aurait donné NaN.
1.6.3 Entrées/sorties spécialisées

Un certain nombre de fonctions d’exportation sont disponibles dans Scilab :
1. utilisation des fonctions d’exportation : nous avons déjà vu la fonction xs2eps permettant d’exporter
le tracé courant au format eps. D’autres transformations sont disponibles : xs2gif, xs2jpg, xs2png,
xs2ppm, xs2pdf, xs2svg, xs2ps, xs2emf (Windows) ;
2. un autre moyen consiste à utiliser directement les drivers (terme associé ici à une unité logique)
mis en œuvre dans les fonctions d’exportation vues précédemment.
Exemple 1.52 (Sortie du tracé courant au format « jpeg ») on suppose que l’on vient de
faire un plot et que l’on veut sauvegarder l’image de la fenêtre au format dans le fichier tstbez.jpg.
-->previous_driver = driver(’JPG’)
previous_driver =
Rec
-->xinit(’tstbez.jpg’);
-->xend();
-->driver(previous_driver)
ans =
JPG
previous_driver = driver(’JPG’) retourne le driver courant, ici Rec (« driver écran ») et posi-
tionne l’unité de sortie sur le driver « jpeg ». Ce dernier est initialisé avec xinit auquel on donne le
nom du fichier à traiter. La session graphique est terminé avec xend(). driver(previous_driver)
permet ensuite de revenir au « driver écran ».
Il est toutefois préférable d’utiliser les fonctions d’exportation ;

3. affichage d’une image dans une fenêtre : voir l’exemple du paragraphe 4.1 (à partir de la version
5.4.0). Scilab propose une toolbox dédiée au traitement des images, laquelle est basée sur l’outil libre
ImageMagick. Nous verrons chapitre 3 comment tout de même manipuler des images ;
4. Scilab propose des fonctions « audio ». Taper :
-->y=wavread(’desgens’); // lecture au format .wav (ou loadwave)
-->plot(y(6500:8500)); , set(gca(),’grid’,[1 1])
-->wavread(’desgens’,’info’);
ans =
column 1 to 7
1.0D+00 1.0D+00 8.0D+03 1.6D+04 2.0D+00 1.6D+01 1.0D+00

column 8
1.6D+04
Le résultat de la dernière commande se lit (sous toute réserve...) : « format des données » = 1,
« nombre de canaux » = 1, « fréquence d’échantillonnage » = 8000 Hz, « longueur de l’enregistrement »
= 16000, « alignement » = 2 (2 octets), « nombre de bits par échantillon » = 16, « ? », « longueur de
l’enregistrement » = 16000 échantillons.
0,6
0,4
0,2
0
−0,2
−0,4
−0,6
7000 7200 7400 7600 7800 8000 8200 8400
Figure 1.16 – Tracé d’un morceau de signal audionumérique
Autres fonctions disponibles : auread/auwrite lecture/écriture au format .au, savewave (ou

wavwrite) écriture au format .wav, analyse tracé de spectre d’un signal, soundmap tracé de spectro-
gramme (sans fenêtrage)... dont la documentation est pour le moins approximative.
Pour écouter :
-->y=loadwave("desgens.wav");
-->length(y)
ans =
1.6000000000D+04
-->playsnd(y,8000)
1.7 Exercices
Exercice 1.1 (Méthode de Jacobi (indications page 143)) Le méthode de Jacobi est une des nom-
breuses méthodes itératives de résolution de système linéaire Ax = b. Elle consiste à poser A = M − N pour
faire tourner la récurrence :
{
x0 donné
xn+1 = M −1 N xn + M −1 b
Cet algorithme converge, et donne la solution unique, si et seulement si les valeurs propres de M −1 N sont
de module < 1. Dans la méthode de Jacobi on choisit M = D et N = L + U où D est la matrice diagonale
définie par la diagonale de A, L (resp. U ) la matrice strictement triangulaire inférieure (resp. supérieure)
associée à A. On en déduit :
x(n+1) = J x(n) + D −1 b avec J = D −1 (L + U ) (1.2)
Ecrire la fonction décrite ci-après par son en-tête.

function [x,rho,k]=jacobimethod(A,b,x0,stcr0,maxit)
//=================================================!
// [x,rho,eltime]=JACOBIMETHOD(A,b,x0,stcr0,maxit) !
// Systeme Ax+b !
// x0 = initial state !
// stcr0 = critere d’arret |x(n+1)-x(n)|>stcr0 !
// maxit = max. iteration number !
// x = solution of Ax=b !
// rho = spectral radius !
// k = loop number !
//=================================================!
Tester la méthode avec :

a=1/4; A=[1 a a;a 1 a;a a 1]; b=[1;2;3];
x0=ones(3,1); stcr0=%eps; maxit=200;
[x,rho,k]=jacobimethod(A,b,x0,stcr0,maxit)
Vérifier le nombre d’itérations.
Exercice 1.2 (Méthode de Cholesky et factorisation (indications page 144)) Le problème posé
est celui de la factorisation de matrices hermitiennes définies positives sous la forme A = LLH où L est
une matrice triangulaire inférieure. Il existe plusieurs algorithmes tels que les algotithmes de Cholesky, de
« Cholesky-Banachiewicz », « Cholesky-Crout », etc. Ici nous allons nous intéresser à une réalisation récursive
symbolisée par :
   ∗
ℓ11 0 0 ... 0 ℓ11 ℓ21 . . . ℓn1
 ℓ21 ℓ22 0 0   ℓn2 
   0 ℓ22 
 . .. .   . .. .. 
Ln × LH =  .. . ..  ×  .. . . 
n    
 . .   . . . 
 .. .. 0   .
. . . . 
.
ℓn1 . . . . . . . . . ℓnn 0 . . . . . . 0 ℓnn
   
ℓ11 0T ℓ11 vH
   
=   v
×
  0


Ln−1 LH n−1
   
ℓ211 ℓ11 v H a11 AH
(2:n,1)
   
= 
 ℓ11 v
=
  A(2:n,1)


vv H
+ Ln−1 LH
n−1 A(2:n,2:n)
On en déduit :
 √
 ℓ11 = a11
v = A(2:n,1) /ℓ11

Ln−1 LHn−1 = A(2:n,2:n) − vv
H
Ecrire une fonction calculant L selon l’algorithme décrit.
On notera que Scilab dispose de deux fonctions de factorisation : lu (factorisation LU) et qr (factorisation
QR).
Exercice 1.3 (Opérateurs logiques (indications page 144)) Scilab ne dispose pas d’opérateurs tels
que le produit matriciel lorsque les variables sont logiques. Dans ce cas – on parle de variables d’un corps fini
de Galois à deux éléments appelé GF(2) – les opérations + et × correspondent aux opérations logiques or
et and. Il est cependant toujours possible de faire toutes les opérations avec des variables réelles et récupérer
ensuite le résultat logique. A titre d’exercice, on va écrire un « produit scalaire » de deux façons :
1. on effectue tous les calculs avec les valeurs numériques 0 (correspondant à « faux ») et 1 (correspondant à
« vrai ») et on passe en booléen. Les deux vecteurs seront engendrés par ; v1=grand(N,1,"uin",0,1);
v2=grand(N,1,"uin",0,1); où N est la longueur du vecteur. Si la fonction × donne le bon résultat,
quelle opération doit-on utiliser pour le « OU » ?
2. on effectue tous les calculs avec les valeurs booléennes Les deux vecteurs seront engendrés par ;
v1=grand(N,1,"uin",0,1);, v1=v1==1; v2=grand(N,1,"uin",0,1);, v2=v2==1; où N est la lon-
gueur du vecteur ;
3. écrire une fonction de produit matriciel, C=boolmatrixmul(A,B), où A et B sont deux matrices boo-
léennes aux dimensions adéquates.
Exercice 1.4 (Coloriage (indications page 145)) On dispose d’une image (tableau) pixc définie, et
tracée, de la façon suivante :
nbr=12; nbc=8; pixc=ones(nbr,nbc); pixc(3:8,2:6)=0; pixc(9:12,6:7)=0;
[idl0,idc0]=find(pixc==0); [idl1,idc1]=find(pixc==1); pixc0=pixc;
//===== tracer
plot(idc0,idl0,’or’), plot(idc1,idl1,’x’), plot(cc,cr,’*r’)
adb=get(gca(),’data_bounds’)+[-1,-1;1,1];
set(gca(),’data_bounds’,adb), set(gca(),’grid’,[1 1])
set(gca(),’axes_reverse’,["off","on","off"])
Construire une fonction récursive qui colorie la zone « remplie » de zéros en remplaçant ces derniers par
une autre valeur.
Chapitre 2
Ecriture des programmes et mise au

point

− définir des fonctions et des bibliothèques de fonctions,
− mettre et enlever des points d’arrêt avec setbpt et delbpt,
−
−
Nous avons vu en introduction comment regrouper des commandes en un « programme » et comment

appeler ce dernier dans la fenêtre de commande à l’aide de la commande exec. L’extension choisie est
sce.
Nous avons vu aussi comment créer des fonctions et, contrairement à Matlab, la nécessité de « pré-
charger », à l’aide de la commande getd(), les fonctions que l’on utilise.
2.1 Programmes et fonctions

Il est possible de rassembler des fonctions dans un fichier programme. Ces fonctions ne sont « visibles »
que localement.
Exemple 2.1 (Fonction locale) Le programme ellipsetst trace une ellipse, le calcul de cette der-
nière étant fait par une fonction locale :
//===== ellipsetst.sce
clear
//===== definiton de la fonction
deff(’[X]=ellipse(X0, E, c)’,[’N=100; theta = (0:N) * (2*%pi) ./ N’;
’Y = sqrt(c)*[cos(theta);sin(theta)]’;
’Fm1=inv(sqrtm(E))’;
’X = diag(X0)*ones(2,N+1)+Fm1*Y’]);
//===== fin de definiton
//===== Programme
X0=[0,0]; c=1; E=[1.3628 .7566;.7566 .5166];
[X]=ellipse(X0, E, c);
plot(X(1,:),X(2,:)); set(gca(),"isoview","on")
return
La fonction deff permet de définir localement une fonction.
47
48 Chapitre 2 - Ecriture des programmes et mise au point
L’écriture de programmes ou de fonctions nécessite un minimum de discipline et de structuration.

Dans le cas des fonctions il n’est pas rare que l’on doive par exemple donner des valeurs par défaut aux
arguments. Reprenons la fonction ellipse.sci en la modifiant :
//===== trace d’une ellipse avec tests d’arguments
function ellipse2(X0, E, c)
if argn(2)<3 then c=1; end
if argn(2)<2 then E=eye(2,2); end
if length(X0)~=2 then error(’dimension erronée de X0’), end
N=100; theta = (0:N) * (2*%pi) ./ N ;
Y = sqrt(c)*[cos(theta);sin(theta)];
Fm1=inv(sqrtm(E));
X = diag(X0)*ones(2,N+1)+Fm1*Y;
plot(X(1,:),X(2,:)); set(gca(),"isoview","on");
endfunction
argn(2) donne le nombre d’arguments en entrée. Si celui-ci est inférieur à 3, la valeur attribuée par
défaut à c est 1. Si elle est inférieure à 2, on attribue en plus la matrice unité (2 × 2) à E. ellipse2([1;1])
trace un cercle de rayon 1 centré en (1, 1).
argn(1) donne le nombre d’arguments en sortie.
La fonction teste aussi la dimension et la taille de X0 . Comme X0 peut être un vecteur ligne ou
colonne, on teste seulement sa longueur qui doit être égale à 2. Si ce n’est pas le cas on affiche un message
d’erreur et on sort « proprement de l’exécution » par la fonction error.
-->ellipse2([1;1;2])
!--error 10000
dimension erronée de X0
at line 4 of function ellipse2 called by :
ellipse2([1;1;2])
2.2 Bibliothèques de fonctions

Soit la fonction mellipse :
function [X]=mellipse(X0, E, c)
//===== mellipse.sci
N=100; theta = (0:N) * (2*%pi) ./ N;
Y = sqrt(c)*[cos(theta);sin(theta)];
Fm1=inv(sqrtm(E));
X = diag(X0)*ones(2,N+1)+Fm1*Y;
endfunction
Nous voulons en faire une fonction membre d’une bibliothèque. Cette dernière appelée myloclib
contient les fonctions présentes dans un répertoire local nommé explelib. La commande genlib « com-
pile » les fonctions trouvées et leur donne l’extension .bin. Le format de ces fonctions est compatible
avec Windows, Mac OS et Linux.
-->cd ~/ECOLE/REDACTIONS/SCILAB/Latex/progs; PWD, pwd
PWD =
/Users/blanchet
ans =
/Users/blanchet/ECOLE/REDACTIONS/SCILAB/Latex/progs
-->mkdir(’explelib’)
ans =
1.
-->genlib(’myloclib’,’~/ECOLE/REDACTIONS/SCILAB/Latex/progs/explelib’,verbose=%t)
-- Création de [myloclib] (Macros) --
genlib : Traitement du fichier : mellipse.sci
genlib : Régénère les noms et les bibliothèques
-->myloclib
myloclib =
Emplacement des fichiers de fonctions : ~/ECOLE/REDACTIONS/SCILAB/Latex/progs/explelib/.
mellipse
-->whereis(’mellipse’)
ans =
!myloclib !
! !
!x !
-->X0=[0,0]; c=1; E=[1.3628 .7566;.7566 .5166];
-->[X]=mellipse(X0, E, c);
Lorsque les .bin ont été engendrés, il n’est plus nécessaire d’utiliser la fonction genlib. On se contente
de « charger » les fonctions de la bibliothèque à l’aide de la fonction lib.
Exemple 2.2 (Fonction locale) Taper :

-->myloclib=lib(’./explelib’)
myloclib =
Emplacement des fichiers de fonctions : /Users/blanchet/ECOLE/REDACTIONS/SCILAB/Latex/progs/explelib/.
mellipse
La commande myloclib=lib(’./explelib’) peut être insérée dans le fichier de démarrage de Scilab

« .scilab » de façon à charger cette librairie lors de toute nouvelle session.
2.3 Exécution de chaînes de caractères

La fonction execstr permet d’appeler l’interpréteur pour exécuter le contenu d’une chaîne de carac-
tères considéré alors comme une suite d’instructions.
Exemple 2.3 (Exécution d’une chaîne de caractères) Taper :

-->clear a, merr=execstr("a=1?2",’errcatch’), a
merr =
276.
!--error 4
Variable non définie : a
-->clear a, merr=execstr("a=1?2",’errcatch’,"m")
a=1?2
!--error 276
Opérateur, virgule ou point-virgule manquant.
merr =
276.
-->clear a, merr=execstr("a=1+2, disp(a)",’errcatch’)
3.
merr =
0.
Le paramètre errcatch indique que la fonction retourne un code erreur pour l’analyse de l’expression.
Le paramètre "m" indique qu’un message d’erreur doit être retourné si nécessaire.
2.4 Appel au système d’exploitation

Il est possible d’utiliser les commandes du système d’exploitation à l’aide de la commande unix
(MATLAB « ! »). Dans MacOS ou Linux la récupération dans un fichier myls.txt de la liste des fichiers
du répertoire courant (identifié par pwd) peut être réalisé en tapant unix(’ls > myls.txt’). Sous
Windows ce serait unix(’dir > myls.txt’).
unix_s, unix_w, unix_g permettent de lancer des commandes DOS ou Unix sans sortie, ou en redi-
rigeant la sortie vers la fenêtre de commande ou une fenêtre particulière respectivement.
2.5 Mise au point

Scilab dispose de quelques outils facilitant la mise au point ou permettant d’avoir des informations
sur les performances des programmes.
2.5.1 Points d’arrêt

Les premiers outils de mise au point sont les points d’arrêt dont les fonctions associées sont leur
définition (setbpt), leur affichage (dispbpt) et leur suppression (delbpt).
Exemple 2.4 (Utilisation des points d’arrêt) Pour tester l’utilisation des points d’arrêt, on utilise
le programme ellaxes.sce vu dans le chapitre 1. Taper ensuite :
-->setbpt(’ellipse’,[5]), dispbpt
Point d’arrêt de la fonction : ellipse
5
-->exec(’ellaxes.sce’,-1)
Arrêt après la ligne 5 dans la fonction ellipse.
Saisissez ’resume’ ou ’abort’ pour revenir au niveau de prompt standard.
-1->Fm1
Fm1 =
1.5019974 - 1.2923485
- 1.2923485 2.9473917
-1->resume
-->delbpt(’ellipse’)
L’instruction setbpt a pour paramètres le nom d’une fonction et une liste de numéros de ligne
([n,m,...]) sur lesquelles on désire mettre un point d’arrêt.
resume permet de reprendre l’exécution de la fonction interrompue tandis que abort interrompt cette
exécution en revenant à la fenêtre de commande.
Comme aucune indication de ligne n’est donnée, l’instruction delbpt supprime tous les points d’arrêt
de la fonction ellipse.
2.5.2 Mise au point directe

Sans poser des points d’arrêt, on peut faire de la mise au point en utilisant les fonctions suivantes :
1. pause stoppe l’exécution en permettant d’afficher les variables locales. L’exécution reprend avec
resume ou est abandonnée avec abort,
2. whereami() affiche l’arborescence de l’appel de l’instruction courante,
3. where fait comme whereami en retournant le nom du script courant et le numéro de ligne.
2.5.3 Traitement local des erreurs

La structure try... catch... end permet de gérer les réactions d’un programme lors d’erreurs.
Exemple 2.5 (Traitement local des erreurs) Taper :
//===== testtry.sce
try
fd=mopen(’fichierne.dat’,’r’);
x=mget(1,’d’,fd); // lecture double --> double
mclose(fd);
catch
mprintf(’Verifier la presence du fichier\nx vaut 0’)
x=0;
end
Si le fichier n’existe pas, le programme continue en affectant la valeur 0 à la variable x :
-->exec(’testtry.sce’,-1)
Verifier la presence du fichier
x vaut 0
Il est possible d’utiliser, de façon équivalente, la structure execstr(...,’errcatch’) pour le traite-

ment des erreurs.
Les fonctions warning et error permettent d’afficher des messages d’erreur. error termine l’exécution
courante. La liste des messages d’erreur est donnée à la rubrique error_table de l’aide de Scilab.
2.5.4 Extraction d’informations d’exécution

add_profiling ajoute les instructions de « profiling » (indices de performance) au code d’une fonction
et profile (voir aussi plotprofile et showprofile) en affiche le résultat :
Exemple 2.6 (Insertion et affichage d’informations pour la mise au point) Taper :
-->add_profiling(’ellipse’)
Attention : Redéfinition de la fonction : ellipse.
Utilisez funcprot(0) pour ne pas afficher ce message.
-->X0=[0,0]; c=1; E=[1.3628 .7566;.7566 .5166]; ellipse(X0, E, c);
-->profile(ellipse)
ans =
1. 0.000015 0.
1. 0.000028 12.
1. 0.000032 10.
1. 0.001453 5.
1. 0.000029 13.
1. 0.137104 17.
1. 0.000001 0.
--> remove_profiling(’ellipse’)
Les trois colonnes indiquent, pour chaque instruction, le nombre de répétitions, le temps d’exécution
et la « charge de travail » de l’interpréteur :
1. 0.000015 0. N=100;
1. 0.000028 12. theta = (0:N) * (2*%pi) ./ N;
1. 0.000032 10. Y = sqrt(c)*[cos(theta);sin(theta)];
1. 0.001453 5. Fm1=inv(sqrtm(E));
1. 0.000029 13. X = diag(X0)*ones(2,N+1)+Fm1*Y;
1. 0.137104 17. plot(X(1,:),X(2,:));
1. 0.000001 0. set(gca(),"isoview","on");
L’instruction remove_profiling supprime les instructions de « profiling » du code de la fonction.
L’instruction reset_profiling peut être utilisée pour remettre à zéro les compteurs de « profiling »
du code de la fonction.
Chapitre 3
Eléments sur les images

−
−
−
−
3.1 Utilisation des fonctions fournies par Scilab

Scilab est doté de la fonction Matplot qui joue le rôle de la fonction image de Matlab. Les images
manipulées sont indexées. Cela signifie que, étant donné une matrice A = [aij ], aij sert d’index dans une
table de couleurs aussi appelée palette de couleurs.
Exemple 3.1 (Traitement d’un fichier PGM) Le format PGM (portable graymap) est un format
très simple dans lequel chaque élément aij donne, sur un ou deux octets, le niveau de gris du pixel (i, j)
associé dans l’image (figure 3.1 ).
Le programme tstimage0.sce lit un fichier .pgm en retournant dans le tableau Vimage les niveaux
de gris de l’image. Celle-ci est ensuite affichée à l’aide de Matplot (figure 3.2 ).
//===== tstimage0.sce
// image au format pgm (portable graymap file)
funcprot(0); getd
fid=mopen(’st2672_420p.pgm’,’r’); // image 672*420
//===== traitement en-tete
[nbrows,nbcols,mform]=procheader(fid);
//=====
Vimage=zeros(nbrows,nbcols);
//===== lecture image
for k=1:nbrows
Vrow=mget(nbcols,mform,fid); Vimage(k,:)=Vrow;
end
mclose(fid)
//===== ecriture dans un fichier binaire pour test (format uchar)
fid=mopen(’voiture.dat’,’wb’);
for k=1:nbrows, mput(Vimage(k,:),’uc’,fid); end
mclose(fid)
//===== affichage avec Matplot
f = scf(1); clf; cm=graycolormap(256);
53
54 Chapitre 3 - Eléments sur les images
Figure 3.1 – Exemple de fichier .pgm. On note le « nombre magique » (50

35=« P5 »), les dimensions de l’image codées en ASCII (672 pixels par ligne et
420 lignes) et la valeur maxima, en ASCII, du niveau de gris codé dans l’image,
ici 255, donc codé sur un octet.
Matplot(Vimage, rect=[10 10 nbcols+9 nbrows+9],strf=’170’)

f.color_map=cm; f.auto_resize=’off’; f.axes_size=[nbcols nbrows];
Le programme sauvegarde l’image dans un fichier appelé voiture.dat. D’une façon générale, il est
préférable de sauvegarder (save) le tableau dans un fichier .sod pour pouvoir le relire avec load (para-
graphe 1.6.2).
Figure 3.2 – Résultat de la commande Matplot
La fonction procheader effectue le traitement de l’en-tête du fichier .pgm :
function [nbrows,nbcols,mform]=procheader(fid)
//===== traitement de l’en-tete du fichier PGM

//===== magic number=P5
v=mget(3,’uc’,fid); aa=ascii(v(1:2));
if (ascii(v(1:2)) ~= ’P5’)
error(’Format incorrect (magic number must be P5)’)
end
chsep=[9 10 32];
//===== nombre de colonnes
cc=55; v=[];
while (isempty(find(chsep==cc))), cc=mget(1,’uc’,fid); v=[v cc]; end
nbcols=strtod(ascii(v));
trtcomment(fid);
//===== nombre de lignes
cc=55; v=[];
nbrows=strtod(ascii(v));
trtcomment(fid);
//===== maxcolor
cc=55; v=[];
mform=’uc’; nbmaxcolor=strtod(ascii(v));
if nbmaxcolor>255 then mform=’us’; end
trtcomment(fid);
endfunction
La fonction trtcomment traite les lignes de commentaires éventuelles. Celles-ci commençent par # et
se terminent par un passage à la ligne (code 10) :
function trtcomment(fid)
//===== traitement de ligne de commentaire commencant
// par le caractere ’’diese’’
cc=mget(1,’uc’,fid); moff=mtell([fid]);
if ascii(cc)==’#’ then
cc=55;
while (isempty(find(cc==10))), cc=mget(1,’uc’,fid); end
else
mseek(moff - 1);
end
endfunction
Il est possible d’utiliser, à la place de Matplot, la fonction grayplot pour obtenir l’affichage de l’image.
3.2 Quelques traitements appliqués aux images indexées

Parmi les modifications applicables à une image on trouve les filtrages linéaires. Les plus simples d’entre
eux résultent de la convolution de l’image par une « fonction d’étalement ponctuel », plus simplement un
tableau. Scilab est doté de fonctions pouvant assurer de tels traitements : conv2 et convol2d (Matlab
conv2 et filter2). convol2d est une version de conv2 utilisant la transformée de Fourier discrète 2D
(fonction fft appliquée à un tableau, en Matlab fft2). La figure 3.3 illustre deux filtrages appliqués à
une image.
Le programme veriffft2.sce illustre le cas d’un filtrage (passe-bas ou dérivateur selon la valeur que
l’on donne à B) avec affichage par Matplot.
//===== veriffft2.sce
clear
funcprot(0); getd
load(’imgcar336210.sod’) // image 336*210
//===== definition filtre passe-bas
B=ones(5,5)/25;
//===== ou derivateur
//B=[0 -1 0;1 0 -1;0 1 0];
zr=myfilter2(B,Vimage); // ou zr=convol2d(B,Vimage);
//===== affichage image originale
sV=size(Vimage); nx=sV(2); ny=sV(1);
Figure 3.3 – Résultat d’un filtrage, passe-bas en haut à droite (correspondant

à B=ones(5,5)/25), dérivateur en bas à droite (correspondant à B=[0 -1 0;1
0 -1;0 1 0])
f1=scf(1); clf()
rect0=[10 10 nx+9 ny+9];
Matplot(Vimage, rect=rect0, strf=’070’)
cm=graycolormap(256);
f1.color_map=cm; f1.auto_resize=’off’; f1.axes_size=[nx,ny];
//===== affichage resultat
f2=scf(2); clf()
Matplot(zr, rect=rect0, strf=’070’)
La fonction de filtrage utilise la transformée de Fourier discrète 2D, donc réalisant convol2d, et peut
être écrite de la façon suivante :
function zr=myfilter2(B,Vimage)
sB=size(B); nBx=sB(2); nBy=sB(1);
//===== image
Vimg=[zeros(nBy,nx+nBx);zeros(ny,nBx),Vimage];
Vimgs=fft(Vimg,-1);
//===== filtre
Bt=zeros(ny+nBy,nx+nBx);
Bt(1:nBy,1:nBx)=B; Bts=fft(Bt,-1);
//=====
Zs=Bts .* Vimgs;
clear Bts Vimgs
z=real(fft(Zs,1));
zr=z(nBy+1:ny+nBy,nBx+1:nx+nBx);
endfunction
Remarque : convol2d est une convolution et non un filtrage. Cela implique que la dimension de
l’image résultante est plus importante que celle de l’image de départ.
Le programme veriffft3.sce effectue le même traitement qu’auparavant, avec un affichage
un peu différent (fonction grayplot). On notera la modification de dimension de l’image filtrée
(zr=zr(3:−2, 3 :-2);).
//===== veriffft3.sce
clear
funcprot(0); getd()
load(’imgcar336210.sod’)

//===== definition filtre
B=ones(5,5)/25;
//===== ou derivateur
//B=[0 -1 0;1 0 -1;0 1 0];
//===== zr=myfilter2(B,Vimage);
//===== zr=conv2(B,Vimage); zr=zr(3:$-2,3:$-2);
zr=convol2d(B,Vimage); zr=zr(3:$-2,3:$-2);
//===== Fenetre d’affichage
f1=scf(1); clf, f1.color_map=cm; f1.auto_resize=’off’;
//===== affichage image originale
a=newaxes(); a.axes_bounds=[0 0 ny/nx .50];
grayplot(0:nx-1,0:ny-1,Vimage’, rect=[0 0 nx-1 ny-1], strf=’010’);
a.axes_reverse = ["on","on","off"]; a.auto_clear=’on’;
//===== resultat du traitement
a=newaxes(); a.axes_bounds=[0 0.5 ny/nx .5];
grayplot(0:nx-1,0:ny-1,zr’, rect=[0 0 nx-1 ny-1], strf=’010’);
a.axes_reverse = ["on","on","off"]; a.auto_clear=’on’;
L’utilisation de conv2(B,Vimage,"same") est en principe équivalente à un filtrage 2D. Dans la version

utilisée ici, cela n’a pas l’air de fonctionner correctement. Il suffit de le remplacer par conv2(B,Vimage)
et de modifier la taille de l’image résultante comme pour convol2d.
Exemple 3.2 (Seuillage d’une image) L’opération de seuillage, ou binarisation, fait partie des trai-
tements simples. Ici le seuil est réglé manuellement, mais il existe des méthodes « automatiques » de
recherche de seuil (méthode de Otsu en particulier). Le résultat est donné figure 3.4 .
//===== trtseuil.sce
clear
funcprot(0); getd
load(’wendyNG.sod’)
sV=size(xwen); nx=sV(2); ny=sV(1);
//===== seuillage
xwent=zeros(ny,nx);
idx=find(xwen>=110); xwent(idx)=255;
f1=scf(1); clf()
Matplot(xwent, rect=[0 0 nx-1 ny-1], strf=’070’)
3.3 Installation sur Mac OS des outils « Images »

Les outils de traitement d’images sont fournis par SIVP (Scilab Image and Video Processing)
(http://sourceforge.net/projects/sivp/). Sur Mac OS, on copie le dossier SIVP en SCI/contrib/,
ce qui donne, par exemple :
/Applications/scilab-5.4.0.app/Contents/MacOS/share/scilab/contrib/sivp-0.5.3/}
et on l’installe de la façon qui suit :
-->cd SCI/contrib/sivp-0.5.3
-->exec(’builder.sce’)
Le problème est que SIVP nécessite OpenCV (Open Computer Vision Library)
(http://sourceforge.net/projects/opencvlibrary/files/latest/download?source=directory).
Toujours sous Mac OS, il faut installer au préalable MacPorts :
http://www.macports.org/install.php
Figure 3.4 – Résultat d’un seuillage
puis cmake (sudo port install cmake sous Terminal).
Une fois tout cela installé, on passe à OpenCV (voir site de Tilo Mitra qui explique la démarche,
http://tilomitra.com/opencv-on-mac-osx/) :
# make a separate directory for building
demariolan:~ blanchet$ cd /Applications/OpenCV-2.4.4
demariolan:OpenCV-2.4.4 blanchet$ cmake -G "Unix Makefiles"
# Now, we can make OpenCV. Type the following in:
demariolan:OpenCV-2.4.4 blanchet$ make -j8
sudo make install
# This should now build OpenCV into your /usr/local/ directory.
Cela se passe bien si Xcode est installé. Sinon, grande souffrance...

Chapitre 4
Construction d’interfaces

−
−
−
−
Scilab offre des possibilités de construction d’interfaces graphiques mariant menus déroulants, boutons,
zones de saisie, etc. Les fonctions de base permettant de construire les objets graphiques sont :
− figure pour construire les fenêtres de l’application,
− uicontrol pour afficher, et définir les traitements associés, les objets de contrôle tels que bouton-
poussoirs, cases à cocher, listes déroulantes, etc.
− uimenu pour définir de nouveaux menus et sous-menus, avec les traitement associés,
− newaxes pour définir des zones de tracés dans lesquelles s’inscriront les tracés de fonctions tels que
les plot.
A chacun des objets définis dans l’interface graphique on peut attacher des traitements. Ceux-ci
peuvent être simplement passés comme chaînes de caractères dans la liste des propriétés de l’objet (pro-
priété « callback »).
4.1 Les éléments de contrôle

On notera EC les eléments de contrôle. Les principaux EC sont : les boutons-poussoir (pushbutton),
les cases à cocher (checkbox), les boutons radio (radiobutton), les glissières (slider), les menus déroulants
(popupmenu), les textes statiques (static text), les textes modifiables (editable text), les cadres (frames),
les listes statiques (listbox). Dans les versions les plus récentes, les EC image et table ont été ajoutés.
La liste des EC disponibles dépend de la version de Scilab utilisée.
Le programme interface1.m servant d’illustration construit une fenêtre (figure 4.1 ) comportant
certains de ces EC, essentiellement ici les uicontrol.
rho=1/2;//===== interface1.sce
vers5p4p0=%t;
//=====
f=figure();
f.position=[20,40,450,250]; f.figure_name="interface1";
f.Background=7; // yellow
//===== controles
59
60 Chapitre 4 - Construction d’interfaces
hpb=uicontrol(f,’style’,’pushbutton’,’position’,[5 10 80 20],..
’string’,’PushB / close’,’callback’,’close(f)’);
hrb=uicontrol(f,’style’,’radiobutton’,’position’,[110 175 80 16],..
’value’,1,’hor’,’left’,’string’,’RadioB’);
hcb=uicontrol(f,’style’,’checkbox’,’position’,[110 200 80 16],..
’value’,1,’hor’,’left’,’string’,’CheckBox’);
hsl=uicontrol(f,’style’,’slider’,’position’,[90 225 100 16],..
’min’,-5,’max’,5,’sliderstep’,1);
hsl.value=0;
//===== frame et controles
hfr=uicontrol(f,’style’,’frame’,’position’,[5 65 95 150],..
’backg’,[.9 .9 .9]);
htx=uicontrol(hfr,’style’,’text’,’position’,[5 124 85 20],..
’relief’,’raised’,’backg’,[0 1 0],’string’,’Texte statique’);
maliste=[’item 1’,’item 2’,’autre’];
montxt="zone d"+ascii(39)+"édition";
hed=uicontrol(hfr,’style’,’edit’,’position’,[5 100 85 20],..
’string’,montxt,’hor’,’left’)
hpu=uicontrol(hfr,’style’,’popupmenu’,’position’,[5 76 85 20],..
’string’,maliste,’relief’,’raised’)
hlb=uicontrol(hfr,’style’,’listbox’,’position’,[5 5 85 65],..
’string’,maliste)
//===== autres (version 5.4.0)
if vers5p4p0
hfr2=uicontrol(f,’style’,’frame’,’position’,[250 117 190 125],..
’backg’,[.9 .9 .9]);
him=uicontrol(hfr2,’style’,’image’,’position’,[7 5 176 115],..
’string’,’st3.jpg’);
noms=["Blabla";"Hups"]; prenoms=["Ge";"Mo"]; rangs=["1";"2"];
matable=[[’ ’,’nom’,’prenom’]; [rangs noms prenoms]];
htb=uicontrol(f,’style’,’table’,’position’,[110 10 180 100],..
’string’,matable);
end
//===== graphiques
a=newaxes(); a.box="on"; a.grid=[1 1];
a.axes_bounds=[0.65 0.55 .35 .40];
x=(0:2*%pi/100:2*%pi);
plot(x,sin(x))
Figure 4.1 – Un exemple de fenêtre avec ses EC
Sous Windows 7 professionnel, avec Scilab 5.4.1 64 bits, l’interface s’affiche de la même manière (figure
4.2 ).
Figure 4.2 – Un exemple de fenêtre avec ses EC, sous Windows 7 professionnel
64 bits et Scilab 5.4.1
Commentaires :
1. Le tracé des différents objets peut prendre un temps non négligeable. Ceci cause un effet de « cas-
cade » qui peut être désagréable. Une solution est la suivante :
-->hf=figure(0,’visible’,’off’);
-->plot([0 1],[0 1],’-r’)
-->hf.visible="on";
Dans Scilab, ceci ne s’applique qu’aux tracés dans la figure.

2. L’interface graphique construite est une arborescence d’objets que l’on peut afficher de la façon
suivante :
-->set(get(0), "ShowHiddenHandles", "on")
-->f.children // arborescence principale

ans =
13 by 1 matrix of handles:
==========================
Axes
uicontrol
uicontrol
uicontrol
uicontrol
uicontrol
uicontrol
uicontrol
Axes
uimenu
uimenu
uimenu
uimenu
L’affichage de toutes les feuilles du niveau suivant peut être faite par :
--> for k=1:size(f.children,1), f.children(k).children, end // detail
On peut visualiser les niveaux suivants, s’ils existent, de la même manière. La première commande
donne des informations sur la première feuille de la première branche Axes. Attention : cette branche
correspond à la figure que l’on a définie (sin(x)), tandis que f.children(9) correspond au cadre
de tracé attaché à la fenêtre et définie lors de la création de la fenêtre avec figure. Pour les menus
(uimenu), c’est la même chose. Le premier correspond au dernier affiché, ici le menu d’aide.
-->f.children(1).children(1)
ans =
Handle of type "Compound" with properties:
==========================================
parent: Axes
children: "Polyline"
visible = "on"
user_data = []
tag =
La commande qui suit donne des informations sur le menu &Imprimer... :
-->f.children(13).children(2)
ans =
Handle of type "uimenu" with properties:
========================================
Parent: uimenu
Children: []
Enable = "on"
Foregroundcolor = [0,0,0]
Label = &Imprimer...
Handle_Visible = "off"
Visible = "on"
Callback = printfigure([SCILAB_FIGURE_ID]);
Callback_Type = 0
Checked = "off"
Userdata = []
Tag =
3. Le paramètre booléen vers5p4p0 est utilisé pour le cas où l’on ne disposerait pas des EC image et
table (à partir de la version 5.4.0).
4. figure construit la fenêtre initiale avec une taille et une position données : le point haut gauche
est défini en x = 20, y = 40 pixels, la largeur est égale à 450 pixels et la hauteur 250. La couleur
du fond est définie par la propriété background. Scilab utilise un système de couleurs indexées. Ici
on a utilisé la couleur 7. On vérifiera :
-->color(’yellow’)
ans =
7.
-->cmap=get(sdf(),"color_map");
-->cmap(7,:)
ans =
1. 1. 0.
La première commande retourne l’index associé au jaune dans la table des couleurs utilisée dans la
figure par défaut (sdf() pour set default figure). La seconde récupère cette table dans cmap et
cmap(7,:) donne la composition en « rouge, vert, bleu » du jaune (chaque composante est comprise
entre 0 et 1).
5. Le premier objet graphique construit est un « bouton poussoir » qui provoque la fermeture de la
fenêtre. Ce dernier traitement est spécifié par la propriété « callback » close(f).
6. newaxes permet de définir une zone de tracé. Sa taille et son positionnement sont définis en « po-
sition et taille relative ».
7. Il peut y avoir des différences de comportement selon les versions de Scilab et les machines cibles :
prises en charge des codages d’images, emplacement de menus, etc. Matlab présente le même genre
de problème.
4.2 Pour aller plus loin...

Nous venons de voir l’utilisation des uicontrol pour mettre au point la fenêtre principale. Nous allons
compléter cette construction dans ce qui suit.
4.2.1 Traitement de l’état des figures

La fenêtre peut être fermée en cliquant dans la case de fermeture ou sur le bouton « sortir ». De plus,
au cours de la mise au point, on peut oublier de la fermer avant de relancer le programme. Pour éviter
les désagréments causés par ces cas d’utilisation, on peut, en début de programme, tester si la fenêtre est
ouverte grâce à la fonction findobj (ici on a utilisé le nom, mais il existe un champ tag qui peut l’être
pour ce faire) et la refermer si c’est le cas :
//===== interface2.sce
h = findobj(’figure_name’, ’interface2’)
if(~isempty(h)), messagebox(’interface2 existe deja’,"modal"), close(h), end
f=figure(); f.position=[20,40,450,250]; f.figure_name="interface2";

//===== controles
hpb=uicontrol(f,’style’,’pushbutton’,’position’,[5 10 40 20],..
’string’,’Sortir’,’callback’,’close(f)’);
On a introduit une boîte à message (messagebox) seulement à des fins de démonstration.
4.2.2 Utilisation des callback

Les callback peuvent être fournis dans l’instruction, comme on l’a vu précédemment, ou à travers
des fonctions externes :
if(~isempty(h)), close(h), end
getd(’./exemple1’)
f=figure();
f.position=[20,40,450,250]; f.figure_name="interface2";
fsize=f.position;
//===== controles
hpb=uicontrol(f,’style’,’pushbutton’,’position’,[fsize(3)-50 10 40 20],..
’string’,’Sortir’,’callback’,’close(f)’);
hfr=uicontrol(f,’style’,’frame’,’position’,[5 10 90 65],..
’backg’,[.9 .9 .9]);
hcbc=uicontrol(hfr,’style’,’radiobutton’,’position’,[5 10 80 20],..
’value’,1,’hor’,’left’,’string’,’cosinus’,’callback’,’fctcbc(a,hcbc,hcbs)’);
hcbs=uicontrol(hfr,’style’,’radiobutton’,’position’,[5 35 80 20],..
’value’,0,’hor’,’left’,’string’,’sinus’,’callback’,’fctcbs(a,hcbc,hcbs)’);
//===== axes
a=newaxes(); a.box="on"; a.grid=[1 1];
a.axes_bounds=[0.2 0 .8 .9];
Les fonctions utilisées dans les callback sont enregistrées dans le répertoire ./exemple1 (commande
getd(’./exemple1’) dans le programme) :
//===== traitement du radiobutton cosinus
function fctcbc(a,hcb1,hcb2)
cbc=hcb1.value;
if cbc==1 then
hcb2.value=0; fctcalcul(a,%t)
else
hcb2.value=1; fctcalcul(a,%f)
end
endfunction
//===== traitement du radiobutton sinus

function fctcbs(a,hcb1,hcb2)
cbc=hcb2.value;
if cbc==1 then
hcb1.value=0; fctcalcul(a,%f)
else
hcb1.value=1; fctcalcul(a,%t)
end
endfunction
//===== calcul et affichage fonction

function fctcalcul(a,sincos)
x=(0:2*%pi/100:2*%pi)
if sincos then
y=cos(x);
else
y=sin(x)
end
sca(a); a.auto_clear="on"; plot(x,y), a.tight_limits="on";
endfunction
4.2.3 Utilisation des uimenu

Les uimenu sont utilisés pour ajouter des menus aux menus associés à la fenêtre (visuellement cela
dépend du système d’exploitation utilisé).
global haa
if(~isempty(h)), close(h), end
getd(’./exemple1’)
//=====
f=figure(); f.position=[20,40,450,250];
f.figure_name="interface2"; f.Background=7; // yellow
//===== menus
hm=uimenu(f,’label’,’fonctions’);
// premier niveau
hm1=uimenu(hm,’label’, ’trigo’); hm2=uimenu(hm,’label’, ’hyperb’);
hm3=uimenu(hm,’label’, ’sortir’, ’callback’, "close(f)");
//create two items in the menu "windows"
hm11=uimenu(hm1,’label’, ’sinus’, ’callback’,’mytrt(’’fsin’’)’);
hm12=uimenu(hm1,’label’, ’cosinus’, ’callback’,’mytrt(’’fcos’’)’);
hm21=uimenu(hm2,’label’, ’sinh’, ’callback’,’mytrt(’’fsh’’)’);
hm22=uimenu(hm2,’label’, ’cosh’, ’callback’,’mytrt(’’fch’’)’);
//===== axes
haa=newaxes(); haa.box="on"; haa.grid=[1 1]; haa.axes_bounds=[0 0 1 1];
On remarquera la présence de la directive global dans le programme principal interface4.sce et

dans la fonction appelée mytrt.sci. Il y a en effet dans les programmes manipulant des objets graphiques
un grand nombre de handles que l’on doit passer aux fonctions qui en ont besoin soit en paramètres soit
en global. On peut aussi, comme le fait l’outil guide de Matlab, utiliser une structure pour y ranger
toutes les informations relatives aux objets manipulés et passer cette structure en paramètre de toutes
les fonctions.
La fonction mytrt utilisée dans les callback est enregistrée dans le répertoire ./exemple1 :
function mytrt(action)
global haa
select action
case ’fsin’ then
x=(0:2*%pi/100:2*%pi); y=sin(x);
case ’fcos’ then
x=(0:2*%pi/100:2*%pi); y=cos(x);
case ’fch’ then
x=(-2:4/100:2); y=cosh(x);
case ’fsh’ then
x=(-2:4/100:2); y=sinh(x);
end
sca(haa); haa.auto_clear="on"; plot(x,y), haa.tight_limits="on";
endfunction
Figure 4.3 – Définition de menus

Figure 4.4 – Définition de menus, sous Windows 7 professionnel 64 bits et

Scilab 5.4.1
Chapitre 5
Simulation

−
−
−
Scilab dispose d’un outil de simulation par schémas-blocs appelé Xcos et invoqué à partir du menu
« Applications ».
5.1 Eléments de base

L’appel à Xcos provoque l’affichage (figure 5.1 ) d’un ensemble de blocs et, dans une seconde, d’un
plan de travail où construire le schéma.
Figure 5.1 – Fenêtre des palettes et fenêtre des diagrammes de Xcos
Les blocs réalisant des fonctions de base – horloges, filtres, oscilloscopes, amplificateurs, non-linéarités,
etc. – sont déposés sur le plan de travail et reliés entre eux. Les blocs sont dotés :
− d’entrées et sorties dites « régulières » à gauche et/ou à droite du bloc ;
67
68 Chapitre 5 - Simulation
− d’entrées de contrôle en haut (les activations) ;
− de sorties de contrôle en bas (transmission d’informations de contrôle vers d’autres blocs).
entrées de contrôle
entrées sorties
régulières régulières
sorties de contrôle
Figure 5.2 – Bloc de base
Le fonctionnement des blocs est conditionné par les activations. Celles-ci peuvent être « continues »,
par exemple un intervalle de temps, ou « discrètes », ce sont alors des événements, par exemple délivrés
par une horloge.
Exemple 5.1 (Système à temps continu) Le système considéré est un simple intégrateur alimenté
par un signal sinusoïdal d’amplitude 1, de fréquence 1 Hz et de déphasage 0. Les paramètres de chaque
bloc sont accessibles en « double-cliquant » sur le bloc. La période de l’horloge « activant » l’oscilloscope
définit la finesse de tracé que l’on obtiendra à l’écran. Ici on prend 0,1. Cela signifie que toutes les 0,1 s la
valeur en entrée est lue et utilisée pour construire la courbe à afficher (constituée de segments de droite).
Figure 5.3 – Système à temps continu avec ses fenêtres de paramètres
1
0,5
0
−0,5
−1
30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60
1
0,5
0
−0,5
−1
30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60
Figure 5.4 – Résultat d’exécution

Pour obtenir la superposition des tracés de l’entrée et de la sortie, on peut utiliser un multiplexeur
(figure 5.5 ).
0,8
0,4
0
−0,4
−0,8
60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90
Figure 5.5 – Résultat d’exécution avec superposition des tracés
Exemple 5.2 (Système à temps discret)
Le système est un retard pur alimenté par une sinusoïde, de fréquence 2π Hz, d’amplitude 1 et de
déphasage 0. L’horloge est définie avec une période de 0,1 s et un temps d’initialisation de 0,1 s. Le système
étant par nature à temps discret il nécessite une horloge. Le signal sinusoïdal est considéré comme « temps
discret ». Il hérite des propriétés du système (figures 5.6 et 5.7 ).
Figure 5.6 – Système à temps discret
1
0,5
0
−0,5
−1
180 181 182 183 184
1
0,5
0
−0,5
−1
180 181 182 183 184
Figure 5.7 – Résultat d’exécution : si les couleurs des tracés sont données par
des nombres > 0, on obtient des tracés avec des segments, sinon (nombres < 0)
on obtient des points (peu visibles dans la réalité)
5.2 Les super-blocs

On va considérer ici un système du second ordre défini par la fonction de transfert G(s), d’entrée x(t)
et de sortie y(t) :
K
G(s) = 2 (5.1)
s2 + 2zωN s + wN
où z est le coefficient d’amortissement et wN la pulsation propre.

On définit le schéma global en utilisant un « super-bloc » qui contiendra le système.
Figure 5.8 – Système du second ordre défini en tant que super-bloc
En double-cliquant sur le super-bloc une nouvelle fenêtre s’ouvre dans laquelle on définit le second
ordre « entre » l’entrée et la sortie (figure 5.9 ).
Figure 5.9 – Super-bloc d’un système du deuxième ordre
Le schéma correspond à une représentation d’état sous forme dite « compagnon », soit :
dy1 (t)
= y2 (t)
dt
dy2 (t)
= −ωN
2
y1 (t) − 2zωN y2 (t) + Kx(t)
dt
et y(t) = y1 (t).
La simulation donne le résultat de la figure 5.10 .
5.3 Passage des paramètres

5.3.1 Variables implicites
Dans le paragraphe 5.2 les paramètres tels que pulsation propre, amortissement et gain statique sont
donnés directement dans les fenêtres associées (voir figures 5.6 ou 5.3 ).
Reconsidérons l’exemple du second ordre avec un simple bloc (figure 5.11 ).
Pour avoir des variables (dites paramètres implicites) on doit d’abord les définir dans le contexte du
schéma que l’on définit. Ceci est effectué à partir du menu « simulation - Modifier le contexte ». La fenêtre
qui s’ouvre permet de saisir un script dans lequel les variables qui nous sont utiles doivent être définies
(figure 5.12 ). Ceci fait, on peut maintenant saisir les noms de variables dans les paramètres des blocs,
par exemple K dans le bloc de gain.
1
0,8
0,6
0,4
0,2
0
2
1,5
1
0,5
0
−0,5
−1
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Figure 5.10 – Simulation obtenue pour la réponse indicielle
Figure 5.11 – Bloc d’un système du deuxième ordre ; on remarque que les noms
des paramètres, z, wn, K, apparaissent dans les blocs correspondants, ce qui a
nécessité de définir au préalable le contexte du schéma
5.3.2 Appel de Xcos à partir de scripts Scilab

Les simulations peuvent être lancées à partir de Scilab. Dans l’exemple qui suit nous allons utiliser le
schéma du système du second ordre pour créer une animation.
Exemple 5.3 (Animation utilisant un schéma Xcos) On fait varier l’amortissement z et on visua-
lise la réponse indicielle. Le bloc END permet de définir sur le schéma la durée de la simulation.
//===== batchtstordre2ctxt.sce ======

verbose=%F;
//// acces a la structure scs_m
Figure 5.12 – Définition du contexte : on en a profité pour indiquer que l’on

veut un quadrillage lors de l’affichage des résultats (gda = get default axes)
importXcosDiagram("DirXcos1/tstordre2anim.zcos")
if verbose,
disp(typeof(scs_m), ’TYPE = ’) // le type est "diagram"
disp(scs_m.props, ’STRUCTURE = ’) // la structure
end
// execution
for z=(.1:.05:1.5)
chn=’z=’+string(z); disp(chn)
scs_m.props.context(4)=chn;
scicos_simulate(scs_m);
end
Le schéma Xcos a pour nom tstordre2anim.zcos. Les paramètres choisis sont :
− oscilloscope : Refresh period = 20,

− bloc END : 20,
− « Simulation - Configurer » : Temps d’intégration final = 60 (il semble que la durée de simu-
lation soit la plus petite de celle définie ici et celle définie dans le bloc END).
5.4 Les blocs définis par l’utilisateur

A chaque bloc sont associés deux fonctions. La première, écrite en langage Scilab, sert à définir la
géométrie du bloc et l’accès à ses paramètres. La seconde, écrite de préférence en langage C (langage dit
de type 4) ou Scilab (type 5), définit le traitement effectué par le bloc.
5.4.1 Définition du bloc hors traitement

5.4.2 Définition du traitement
Chapitre 6
Variables aléatoires

−
−
−
−
6.1 Lois usuelles

Nous avons vu en introduction (paragraphe 1.1.3) la fonction rand pour engendrer des séquences
aléatoires uniformes ou gaussiennes. Nous allons revenir sur ces deux cas et regarderons ensuite comment
engendrer des variables aléatoires (v.a.) ayant d’autres lois de répartition.
6.1.1 Loi uniforme sur (a, b)

Définition
Une v.a. X est dite uniforme ou équirépartie sur (a, b) avec b > a, si sa densité de probabilité a pour
expression :

 (b − a)−1 pour x ∈ (a, b)
pX (x) = (b − a)−1 1(x ∈ (a, b)) = (6.1)
 0 sinon
On note que l’ensemble des valeurs possibles de X se réduit à l’intervalle (a, b) et que la probabilité
d’appartenir à un intervalle (c, d) ⊂ (a, b) est égale à (d − c)/(b − a) et est donc proportionnelle à la
longueur de l’intervalle. Sa densité de probabilité est représentée à la figure 6.1 . Elle est constante sur
l’intervalle (a, b).
p X (x)
1
b−a
x
a b
Figure 6.1 – Densité de probabilité de la loi uniforme
73
74 Chapitre 6 - Variables aléatoires
On pourra vérifier à titre d’exercice que sa moyenne, son moment du second ordre et sa variance sont
donnés respectivement par :
∫ b
x a+b
E {X} = dx =
a b − a 2
∫ b 2
{ 2} x a + ab + b2
2
E X = dx =
a b−a 3
{ 2} 2 (b − a)2
var (X) = E X − E {X} =
12
Exemple 6.1 (loi uniforme sur (a, b)) On veut obtenir une v.a. X de loi uniforme sur (a, b), à partir
de la fonction Scilab rand qui donne une v.a. de loi uniforme sur (0, 1). A titre d’exercice on pourra
établir que la v.a. X = (b − a)U + a, où U est une variable uniforme sur (0, 1), est uniforme sur (a, b).
Pour engendrer 1 000 tirages d’une loi uniforme sur [−π, +π], taper :
-->U=rand(1,1000,"uniform");
-->a=-%pi; b=%pi; X=(b-a)*U+a; plot(X,’.’); set(gca(),’grid’,[1 1])
Un tel échantillon est visualisé figure 6.2 .
π
3
2
1
0
−1
−2
−3
−π
0 100 200 300 400 500 600 700 800 900 1000
Figure 6.2 – Tirages de la loi uniforme sur [−π, +π]
Le générateur uniforme est du type « pseudo-aléatoire ». L’état initial du générateur peut être défini
par rand(’seed’,n). Par défaut n = 0.
-->rand(’seed’,0)
-->rand(1,2)
ans =
0.2113249 0.7560439
-->rand(1,2)
ans =
0.0002211 0.3303271
-->rand(’seed’,0)
-->rand(1,2)
ans =
0.2113249 0.7560439
( La première valeur obtenue est31 )égale à x0 = 453816693/231 . La seconde est x1 =

(843314861 × x0 + 453816693) mod 2 /2 . Les valeurs suivantes sont engendrées par cette récur-
31
rence. La documentation de Scilab donne la source du générateur dit urand (1) .

(1). Michael A. Malcolm, Cleve B. Moler, « Urand, A Universal Random Number Generator », Stan-Cs-73-334, January
1973, Computer Science Department, School Of Humanities And Sciences, Stanford University
Pour avoir une initialisation moins prévisible, on peut utiliser n=getdate(’s’); rand(’seed’,n);.
Taper à la suite histplot(10,X). On obtient un diagramme (figure 6.3 ), appelé histogramme, qui
représente une estimation de la densité de probabilité représentée figure 6.1 .
0,18
0,14
0,1
0,06
0,02
0
−4 −3 −2 −1 0 1 2 3 4
Figure 6.3 – Histogramme de X comportant 10 classes
Remarques sur les générateurs de séquences aléatoires

La qualité des séquences engendrées repose sur plusieurs critères :
1. un générateur doit être rapide, peu gourmand en espace mémoire et facilement portable d’un envi-
ronnement informatique à un autre ;
2. les séquences engendrées doivent être de longueur importante pour éviter tout phénomène de « bou-
clage » et donc de périodicité ;
3. on doit pouvoir répéter des séquences données, condition indispensable lorsqu’on est en phase de
mise au point de programmes ;
4. on doit pouvoir engendrer des générateurs indépendants à partir d’un seul et même générateur de
base. Ceci sous-entend que l’on puisse construire facilement sk+n à partir de sk .
Les séquences que l’on veut engendrer sont i.i.d. (indépendantes et identiquement distribuées). D’un
point de vue intuitif, si on considère l’ensemble fini Φp de toutes les séquences de longueur p construites
à partir d’un état initial donné, Φp doit « remplir » l’hypercuble (0, 1)p de manière uniforme. On devrait
pouvoir caractériser la qualité du générateur par l’écart qu’il y a entre une distribution expérimentale et
la distribution uniforme sur (0, 1)p . Cet écart doit évidemment pouvoir être évalué sans avoir à construire
toute la séquence.
En pratique les tests de générateurs sont bâtis sur des ensembles de programmes parmi lesquels
les tests de Dienhard (http://stat.fsu.edu/pub/diehard/), les tests du NIST pour les générateurs
utilisés en cryptographie (http://csrc.nist.gov/rng/), la librairie de tests « TestU01 » de l’université
de Montréal (http://www.iro.umontreal.ca/~simardr/testu01/tu01.html), etc.
6.1.2 Variable aléatoire gaussienne réelle

En physique, de nombreux phénomènes, qui sont la contribution d’une multitude d’effets microsco-
piques, se distribuent suivant une loi gaussienne à l’échelle macroscopique. Le caractère gaussien est une
conséquence du théorème de la limite centrale.
Définition
Une v.a. X est dite gaussienne ou normale, si elle prend ses valeurs dans R et si sa fonction caracté-
ristique (expression A.14) a pour expression :
( )
1
ϕX (u) = exp jmu − σ 2 u2
2
où m est un paramètre réel et σ un paramètre positif. Si σ ̸= 0, on montre que la loi possède une densité
de probabilité qui a pour expression :
( )
1 (x − m)2
pX (x) = √ exp − (6.2)
σ 2π 2σ 2
On vérifie que sa moyenne est égale à m et sa variance à σ 2 .

La figure 6.4 donne la forme de la densité de probabilité de la loi gaussienne.
p X (x)
m
x
6σ
Figure 6.4 – Densité de probabilité gaussienne et intervalle de confiance à 99%
Numériquement on vérifie que plus de 99% des valeurs tombent dans l’intervalle (m − 3σ, m + 3σ).
On parle alors d’intervalle de confiance à 99%. On en déduit une règle pratique dite règle des 3 sigma qui
énonce que l’amplitude crête d’une v.a. gaussienne est égale à ±3σ autour de sa moyenne. On entend par
là que la probabilité de « sortir » de cet intervalle est inférieure à 1%. Si on se contente d’un intervalle de
confiance à 95%, il faut prendre (m − 2σ, m + 2σ). Si au contraire on préfère un intervalle de confiance à
99,9%, il faut prendre (m − 4σ, m + 4σ).
Exemple 6.2 (Variable gaussienne (m, σ 2 )) Soit Y une v.a. gaussienne, centrée et de variance 1.
On peut vérifier que la v.a. X = σY + m a pour moyenne m et pour variance σ 2 . Nous verrons qu’une
conséquence directe de la définition générale d’un vecteur gaussien est que le caractère gaussien se conserve
par transformation linéaire. Pour avoir un échantillon de 1 000 valeurs d’une loi gaussienne de moyenne
4 et de variance 7, taper :
//===== histog1d.sce
clear; N=1000; m=4; sigma2=7;
X=sqrt(sigma2)*rand(1,N,’normal’)+m;
figure(1); plot(X,’.’); set(gca(),’grid’,[1 1])
figure(2); histplot(10,X);
L’échantillon des 1 000 tirages est donné figure 6.5 et l’histogramme correspondant figure 6.6 .
14
12
10
8
6
4
2
0
−2
−4
0 100 200 300 400 500 600 700 800 900 1000
Figure 6.5 – Tirages de la loi gaussienne (m = 4, σ = 7)
6.1.3 Variable aléatoire gaussienne complexe

Dans certains problèmes, en particulier dans le domaine des communications, on introduit une notation
complexe de la forme X = U + jV où U et V désignent deux v.a. gaussiennes, { }réelles, indépendantes,
centrées et de même variance σ 2 /2 (et non pas σ 2 , voir expression 6.4 de E |X|2 ).
0,14
0,1
0,06
0,02
0
−4 −2 0 2 4 6 8 10 12 14
Figure 6.6 – Histogramme de la loi gaussienne (m = 4, σ = 7)
Définition
Du fait de l’indépendance (définition A.7) des parties réelle U et imaginaire V , la loi conjointe du
couple (U, V ) a pour densité de probabilité :
( 2) ( 2)
1 u 1 v
pU V (u, v) = pU (u)pV (v) = √ exp − 2 × √ exp − 2
σ π σ σ π σ
( 2 )
1 u + v2
= exp −
πσ 2 σ2
En remarquant que |x|2 = u2 + v 2 , et en introduisant la notation pX (x) = pU V (u, v), on peut encore
écrire :
( )
1 |x|2
pX (x) = exp − (6.3)
πσ 2 σ2
L’expression 6.3 porte le nom de densité de probabilité d’une v.a. gaussienne complexe. On ajoute parfois
le terme circulaire qui rappelle que les courbes d’égale densité sont les cercles u2 + v 2 = constante.
Notons que :
{ } { } { }
E |X|2 = E {XX ∗ } = E {(U + jV )(U − jV )} = E U 2 + E V 2 = σ 2 (6.4)
L’expression 6.3 nécessite quelques mises en garde :
− l’argument x est complexe ;
− en comparant l’expression 6.3 à l’expression 6.2 donnant la densité de probabilité d’une loi gaus-
sienne réelle, on note qu’il y a disparition des facteurs 2 et de la racine carrée.
Exemple 6.3 (Variable aléatoire gaussienne complexe) Pour engendrer 1 000 échantillons d’une
variable aléatoire gaussienne complexe (voir expression 6.3), centrée et de variance 5, taper le programme
suivant (figure 6.7 ) :
//===== histoGC1d.sce
clear, close
varX=5; sigma=sqrt(varX);
U=sqrt(varX/2) * rand(1,1000,’normal’);
V=sqrt(varX/2) * rand(1,1000,’normal’);
X=U+%i*V;
//===== tracer
plot(real(X),imag(X),’.’); set(gca(),’grid’,[1 1])
cercle=sigma*fft([0 -1 zeros(1,100)]);
plot(real(cercle),imag(cercle),’r’); set(gca(),’isoview’,’on’)
6.1.4 Vecteurs aléatoires gaussiens

Définition : on dit que {X1 , . . . , Xn } sont n variables conjointement gaussiennes ou encore que le
vecteur [X1 . . . Xn ]T de dimension n est gaussien, si toute combinaison linéaire de ses composantes,
6
5
4
3
2
1
0
−1
−2
−3
−4
−5
−6
−5 −4 −3 −2 −1 0 1 2 3 4 5
Figure 6.7 – Echantillon de variable aléatoire gaussienne complexe
à savoir Y = aT X avec a = [a1 ... an ]T quelconque, est une v.a. gaussienne.
⋆ On montre que la loi de probabilité d’un vecteur gaussien de dimension n, de vecteur moyenne m
(de dimension n) et de matrice de covariance C (de dimension n × n) a pour fonction caractéristique :
( )
1 T
ϕX (u1 , . . . , un ) = exp jm u − u Cu
T
(6.5)
2
où u = (u1 , . . . , un )T ∈ Rn . Si det(C) ̸= 0, la loi possède une densité qui a pour expression :

( )
1 1 T −1
pX (x1 , . . . , xn ) = √ exp − (x − m) C (x − m) (6.6)
(2π)n/2 det(C) 2
où x = (x1 , . . . , xn )T .
⋆ Si n variables conjointement gaussiennes ne sont pas corrélées, alors elles sont indépendantes.
En effet, si on fait C = σ 2 I dans l’expression 6.6, pX (x1 , . . . , xn ) = pX1 (x1 ) . . . pXn (xn ), et donc,
d’après A.12, les variables sont indépendantes.
⋆ Soit [X1 . . . Xn ]T un vecteur gaussien de vecteur moyenne mX et de matrice de covariance C X .

Alors le vecteur aléatoire Y = AX + b où A et b sont une matrice et un vecteur de dimension ad hoc,
est gaussien et on a :
mY = AmX + b et C Y = AC X AT
On dit que le caractère gaussien se conserve par transformation linéaire. Ce résultat est une consé-
quence de la définition 6.1.4 et de la propriété A.5.
6.2 Estimation de la densité de probabilité

Un théorème, appelé à tort « loi des grands nombres », établit que la probabilité pour une v.a. X
d’appartenir à un intervalle ∆i peut être approchée, pour N suffisamment grand, de la manière suivante :
− on considère N v.a. indépendantes et de même loi que X ; on effectue un tirage, ce qui donne la
réalisation x1 , . . ., xN ;
− on détermine le nombre ni de valeurs de cette réalisation qui tombent dans l’intervalle ∆i ;

− on prend pour approximation de P {X ∈ ∆i } la quantité ni /N .

La quantité ni /N est appelée fréquence empirique. On peut utiliser ce résultat pour estimer la densité
de probabilité pX (x) au point x de la v.a. X supposée continue. En effet, par définition, on a :
∫
P {X ∈ ∆i } = pX (u)du
∆i
Si ∆i est un segment choisi assez petit autour du point x, on a pX (u) ≈ pX (x) et le second membre
est approximativement égal à pX (x) × δi où δi désigne la longueur de ∆i . On en déduit une formule
pratique pour estimer pX (x) :
ni
pX (x) ≈ (6.7)
N δi
où ni est le nombre de points observés dans l’intervalle ∆i .
Partant d’un échantillon de N valeurs, la procédure pour estimer la densité de probabilité en Nc
points, ou « classes », {x1 , . . . , xP } peut alors se résumer ainsi :
1. on partitionne l’intervalle des valeurs observées en Nc sous-intervalles ∆1 , . . . , ∆Nc , de longueurs res-
pectives δ1 , · · · , δNc , situés autour des points x1 , . . . , xNc . En général, on choisit des sous-intervalles
de même longueur et xk est pris au milieu du sous-intervalle ∆k , sauf éventuellement pour les deux
intervalles extrêmes ;
2. on estime la densité de probabilité au point xk par :

nk
pbX (xk ) = (6.8)
N δk
∑
où nk est le nombre de points dans l’intervalle ∆k . Notons que k pbX (xk )δk = 1.
Exemple 6.4 (Estimation d’une densité de probabilité) On construit un échantillon de longueur

N = 2 000 tirages d’une variable aléatoire gaussienne (on prend la même loi que dans l’exemple vu
précédemment). On estime directement la densité et on compare à ce que l’on obtient par histplot.
//===== esthistog1d.sce
clear
getd()
Nc=15; N=2000; m=4; sigma2=7; sigma=sqrt(sigma2);
X=sigma*rand(1,N,’normal’)+m; Xmin=min(X); Xmax=max(X);
figure(1); histplot(Nc,X,normalization=%t);
//===== Calcul et affichage de l’histogramme
[ni,xcc] = myhist(Nc,X,%t,%t);
//=====
Npts=120; x=linspace(Xmin,Xmax,Npts);
dp=exp((-(x-m).^2)/sigma2/2)/sigma/sqrt(2*%pi);
plot(x,dp,’r’)
On utilise la fonction de calcul de l’histogramme (1D) suivante :

function [ni,xcc] = myhist(Nc,X,bnorm,bplot)
//================================================================!
// Nc = nombre de classes !
// X = donnees !
// bnorm = normalisation (densite) ou non (nombre de tirages) !
// bplot = si %t, plot !
// ni = nombre tirages dans les classes ou estimation densite !
// en fonction de bnorm !
// xcc = centre des classes !
//================================================================!
N=length(X);
Xmin=min(X); Xmax=max(X); delta=(Xmax-Xmin)/Nc;
xc=linspace(Xmin,Xmax,Nc+1); ni=zeros(1,Nc);
for k=1:Nc
idx=find((X>=xc(k))&(X<xc(k+1)));
ni(k)=length(idx); xcc(k)=(xc(k)+xc(k+1))/2;
xcc(k)=(xc(k)+xc(k+1))/2
end
ni(Nc)=ni(Nc)+1;
if bnorm then
ni=ni/N/delta;
end
if bplot then
plot2d3(xcc,ni), plot(xcc,ni,’o’)
end
endfunction
Le paramètre bnorm de myhist.sci joue le même rôle que le paramètre normalization de histplot.
Pour une valeur %t Il indique que l’on veut tracer la densité, sinon, pour %f, le nombre d’occurrences
dans chaque intervalle.
0,16
0,14
0,12
0,1
0,08
0,06
0,04
0,02
0
−4 −2 2 4 6 8 10 12 14 16
Figure 6.8 – Estimation de la densité de probabilité
Le problème du choix de la valeur de Nc est un problème complexe. Ce que nous pouvons dire ici est
que Nc doit être grand pour que la densité de probabilité soit correctement estimée mais suffisamment
petit devant N de façon à ce que le nombre de points dans chaque sous-intervalle reste grand. On peut
prendre par exemple Nc = N 1/3 qui tend vers l’infini quand N → ∞ tend vers l’infini et qui est tel que
N/Nc tend aussi vers l’infini quand N → ∞.
La fonction hist de Matlab ne fonctionne pas comme histplot. Elle ne se contente pas de tracer un
histogramme mais retourne le nombre de tirages dans chaque intervalle et les centres de chaque intervalle.
Il faut ensuite estimer les densités (expression 6.8) et, éventuellement, faire tracer l’histogramme obtenu.
6.3 Génération de variables aléatoires dans Scilab

6.3.1 Générateurs de Scilab
Outre rand Scilab dispose de grand permettant d’accéder à de nombreuses distributions. De plus le
générateur de base utilisé pour engendrer la séquence peut être choisi (nous avons vu précédemment le
générateur urand). Par défaut celui-ci est de type Mersenne-Twister [1] (2) . Les lois disponibles (extrait
de la documentation, les fonctions indiquées entre parenthèses fournissent les fonctions de répartition) :
1. loi « beta » (cdfbet) :
2. loi « binomiale » (binomial, cdfbin) (Bernoulli) et loi « binomiale négative » (cdfnbn) :
3. loi du « χ2 » (cdfchi) et du « χ2 » non centrée (cdfchn) :
4. loi « exponentielle » :
5. loi « F variance ratio » (cdff) :
(2). http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
6. loi « non central F variance ratio » (cdffnc) :

7. loi « gamma » (gamma, cdfgam) :
8. loi « normale » (cdfnor, erf) et « multi normale » (vectorielle) :
9. loi « géométrique » (Bernoulli) :
10. loi « de Markov » :
11. loi « multinomiale » :
12. loi « de Poisson » (cdfpoi) :
13. loi « permutations aléatoires » :
14. loi « uniforme (def) », « (unf) », « (uin) », « (lgi) ».
Exemple 6.5 (Tirage selon la loi « gamma ») Etant donnée Γ(k) :

∫ +∞
Γ(k) = tk−1 e−t dt avec k ∈ R∗+
0
la loi de répartition « gamma », ou eulérienne, est définie à partir de la densité de probabilité :
xk−1 e−x/θ xk−1 β k e−βx

pX (x, k, θ) = = pour t > 0, avec k > 0, et θ = 1/β > 0 (6.9)
Γ(k)θk Γ(k)
et pX (x, k, θ) = 0 pour t < 0. k et β sont appelés « forme » et « échelle » dans Scilab.
Le programme tstgamma.sce illustre la façon de se servir de grand pour engendrer un échantillon de

v.a. selon la loi « gamma », de la fonction associée cdfgam et de la fonction gamma (figure 6.9 ).
//===== tstgamma.sce
scf(0), clf()
N=1000; forme=2; beta=2; echelle=1/beta;
Y=grand(1,N,"gam",forme,echelle);
subplot(321), plot(Y,’.’), set(gca(),’grid’,[1 1])
subplot(322),histplot(10,Y), set(gca(),’grid’,[1 1])
X=linspace(0,10,100); lx=length(X);
//===== fonction de repartition
[P,Q]=cdfgam("PQ",X,ones(1,lx)*forme,ones(1,lx)*echelle);
subplot(312), plot(X,P), set(gca(),’grid’,[1 1])
//===== densite
px=(X .^ (forme-1)) .* exp(-X*echelle)/gamma(forme)*(echelle^forme);
subplot(313), plot(X,px), set(gca(),’grid’,[1 1])
Scilab est doté de la fonction pr=binomial(p,n) qui retourne la suite P {X = k} dans n tirages
indépendants suivant une loi de Bernoulli :
( )
n k
P {X = k} = p (1 − p)n−k
k
6.3.2 Chaîne de Markov

Construction d’un graphe de Markov
Une chaîne de Markov peut être engendrée à partir d’un graphe à états. Notons Xn l’état dans lequel
on se trouve à l’instant n et pi (n) = P {Xn = i} la probabilité pour que X se trouve dans l’état i,
0 ≤ i ≤ N − 1, à l’instant n. Dans le cas markovien, la probabilité pour l’état Xn+1 d’être dans l’état j
à l’instant n + 1 ne dépend que de l’état à l’instant qui précède et est donnée par :
∑−1
λ=N ∑−1
λ=N
pj (n + 1) = P { Xn+1 = j | Xn = λ} pλ (n) = aλ,j pλ (n) (6.10)
λ=0 λ=0
5
4 0,6
3 0,4
2
0,2
1
0 0
0 200 400 600 800 1000 0 1 2 3 4 5
1
0,8
0,6
0,4
0,2
0
0 1 2 3 4 5 6 7 8 9 10
0,2
0,15
0,1
0,05
0
0 1 2 3 4 5 6 7 8 9 10
Figure 6.9 – Echantillon de 1000 tirages selon la loi « gamma » avec k = 2 et

θ = 1/2, histogramme, fonction de répartition et densité de probabilité
Figure 6.10 – Etats et transitions d’un graphe de Markov
[ ]
En posant pT (n) = p0 ... pN −1 et A = [aij ], on peut écrire :
∑
N −1
pT (n + 1) = pT (n) × A où 0 ≤ pk ≤ 1, 0 ≤ aij ≤ 1 et aij = 1 (6.11)
j=0
Scilab dispose de la fonction genmarkov(rec,tr,flag) pour engendrer un graphe de Markov de

probabilités de transition aléatoires. Le premier paramètre est un vecteur définissant les classes non
connexes du graphe.
Exemple 6.6 (Classes non connexes) Taper :
-->genmarkov([1 2 1],0)
ans =
1. 0. 0. 0.
0. 0.3181325 0.6818675 0.
0. 0.5711632 0.4288368 0.
0. 0. 0. 1.
Le graphe contient trois classes. La deuxième contient deux états et les probabilités de transition sont
tirées aléatoirement (figure 6.11 ).
Exemple 6.7 (Classes non connexes et états transitoires) Le deuxième paramètre d’appel de
genmarkov est le nombre d’états transitoires. Un état transitoire, ou source, est un état dans lequel
on ne peut revenir une fois que l’on en est sorti et qui donne accès à tous les autres états. Taper :
Figure 6.11 – Graphe à trois classes et quatre états
-->genmarkov([1 2 1],1)
ans =
1. 0. 0. 0. 0.
0. 0.0118626 0.9881374 0. 0.
0. 0.6980631 0.3019369 0. 0.
0. 0. 0. 1. 0.
0.0656237 0.3468243 0.3846394 0.1882441 0.0146684
Le graphe contient toujours trois classes. Il y a un état transitoire. Dès lors que l’on « en est sorti »
pour aller vers un autre état, on ne peut y revenir (figure 6.12 ).
Figure 6.12 – Graphe à trois classes, cinq états dont un transitoire
Le troisième paramètre d’appel (flag) de genmarkov indique si l’on doit permuter les états.
Construction d’une séquence markovienne

La fonction grand(n,"markov",P,x0) permet d’engendrer une suite markovienne d’états. n est le
nombre d’états à engendrer, P la matrice de transition de Markov et x0 l’état initial.
Exemple 6.8 (Construction d’une suite de markovienne d’états) Taper :
-->P=genmarkov([3],0), ye=grand(10,"markov",P,2)
P =
0.3043490 0.3671631 0.3284879
0.4194912 0.2426225 0.3378863
0.2726937 0.3022184 0.4250879
ye =
1. 1. 2. 1. 3. 3. 3. 3. 3. 2.
6.3.3 Génération de variables aléatoires de loi quelconque

Bien que Scilab dispose de nombreux générateurs, on peut se demander s’il est possible de construire
un générateur d’une loi quelconque. La réponse est affirmative et une solution est fournie par inversion
de la fonction de répartition.
Génération d’une variable aléatoire discrète

Soit X une v.a. discrète dont on veut engendrer un échantillon. Notons {a0 , a1 , . . . , an . . . , } l’ensemble
des valeurs de X, pX (n) = P (X = an ) sa loi de probabilité et FX (x) = P {X ≤ x} sa fonction de
FX(x)
1
U
pX(2)
pX(1)
pX(0) x
a0 a1 0 a2 a3
Figure 6.13 – Fonction de répartition d’une variable aléatoire discrète
répartition. Nous avons représenté figure 6.13 la forme générale de la fonction FX (x). Sa valeur, en
∑k
x = ak , s’écrit FX (ak ) = n=0 pX (n).
Considérons alors une v.a. U de loi uniforme sur (0, 1) et soit Y la v.a. obtenue, à partir de U , par
inversion de la fonction de répartition, ce qui s’écrit :


 [0, pX (0)[

 alors Y = a0



 [pX (0), pX (0) + pX (1)[ alors Y = a1
Si U ∈ .. (6.12)



 .



 [FX (ak−1 ), FX (ak )[ alors Y = ak , etc.
Loi de probabilité de la v.a. Y ainsi obtenue est précisément celle de la variable X cherchée. En effet
en utilisant le fait que U est uniforme, nous pouvons écrire successivement :
∫ FX (ak )
P {Y = ak } = P {U ∈ [FX (ak−1 ), FX (ak [} = du
FX (ak−1 )
= FX (ak ) − FX (ak−1 ) = pX (ak )
La variable Y construite suivant la procédure 6.12 suit donc la loi cherchée.
⋆ Soit la fonction bijective et dérivable x = f (u) et U une v.a. dont la loi a pour densité de probabilité
pU (u). Alors la v.a. X = f (U ) a pour densité de probabilité :

du pU (u) pU (g(x))
pX (x) = pU (u) = dx = ′ (6.13)
dx |f (g(x))|
du
où f ′ (u) = dx/du désigne la dérivée de f (u) et où u = g(x) désigne la fonction inverse de x = f (u), à
savoir telle que g(f (u)) = u.
Génération d’une variable aléatoire continue

Appliquons 6.13 dans le cas particulier où U est une v.a. uniforme sur (0, 1), dont la densité de
probabilité a pour expression pU (u) = 1(u ∈ (0, 1)). La loi de la v.a. X = f (U ) a alors pour densité de
probabilité :

du
pX (x) = 1{g(x) ∈ (0, 1)} (6.14)
dx
où u = g(x) représente l’inverse de x = f (u). Choisissons pour g(x) la fonction F (x), où F (x) est
précisément la fonction de répartition de la v.a. dont on veut engendrer un échantillon. On a du dx =
F ′ (x) ≥ 0. En portant dans 6.14 et en notant que F (x) ∈ [0, 1], il vient pX (x) = F ′ (x), ce qui signifie
que la loi de X a pour densité de probabilité F ′ (x) qui est bien celle de la loi cherchée.
Ce résultat est mis à profit pour engendrer, à partir du générateur uniforme sur (0, 1), un échantillon
d’une variable aléatoire dont la densité de probabilité pX (x) est donnée. En voici l’algorithme :
∫x
1. On détermine la fonction u = −∞
pX (t)dt.
2. On détermine son inverse x = g(u).
3. Si U est un échantillon uniforme sur (0, 1), alors X = g(U ) est un échantillon dont la loi a pour
densité de probabilité pX (x).
6.4 Exercices
Exercice 6.1 (Loi de Poisson (indications page 146))
La v.a. X, à valeurs dans N, suit une loi de Poisson lorsque :
ak
P {X = k} = pX (k) = e−a (6.15)
k!
où a désigne une quantité positive appelée paramètre de la loi.
1. Déterminer la moyenne et la variance de X.
2. Déterminer, pour k ∈ N, la relation de récurrence qui donne pX (k) en fonction de pX (k − 1), ainsi que
celle donnant FX (k) = P {X ≤ k}.
3. En utilisant 6.12, écrire un programme qui engendre une v.a. de Poisson de paramètre a = 5, à partir
d’une v.a. U qui suit la loi uniforme sur (0, 1).
4. En utilisant la fonction myhist, vérifier le résultat obtenu.
Exercice 6.2 (Loi exponentielle (indications page 147))

Une v.a. suit la loi exponentielle si elle prend ses valeurs dans R+ et si sa densité de probabilité a pour
expression :
pX (x) = λ exp(−λx)1(x ∈ [0, +∞[) (6.16)
où le paramètre λ ≥ 0.
1. Déterminer la moyenne et la variance de X.
2. En utilisant la fonction de répartition de X, déterminer une fonction X = g(U ) telle que X suive une
loi exponentielle de paramètre λ lorsque U suit une loi uniforme sur (0, 1).
3. En utilisant la fonction myhist, vérifier le résultat obtenu.
Exercice 6.3 (Loi de Rayleigh (indications page 149)) X suit la loi de Rayleigh si sa densité de
probabilité a pour expression :
( )
x x2
pX (x) = 2 exp − 2 1(x ∈ [0, +∞[) (6.17)
σ 2σ
√
1. vérifier que E {X} = σ π/2 ;
2. U suivant une loi uniforme sur (0, 1), déterminer la fonction X = g(U ) telle que X suive une loi de
Rayleigh ;
3. en utilisant la fonction myhist, vérifier le résultat obtenu.
Exercice 6.4 (Loi de Bernoulli (indications page 149))

On dit que B suit une loi de Bernoulli (ou de pile ou face) de paramètre p, si B est une v.a. qui prend pour
seules valeurs 0 et 1, avec les probabilités respectives P {X = 1} = p et P {X = 0} = 1 − p. On considère N
variables de Bernoulli Bn indépendantes et on pose :
1 ∑
N
S= Bn
N n=1
1. Déterminer en fonction de p, la moyenne et la variance de Bn .

2. Déterminer en fonction de p, E {Bk Bn } pour k ̸= n. On rappelle que si deux v.a. U et V sont
indépendantes, elles ne sont pas corrélées, c’est-à-dire E {U V } = E {U } E {V }.
3. Déterminer en fonction de p et de N , la moyenne m et la variance σ 2 de la v.a. S.
4. On admet que, pour N grand, la probabilité pour S de se trouver dans l’intervalle (m − 2σ, m + 2σ)
est supérieure à 95%. Partant de là on peut dire que S fournit une estimation de m avec une précision
relative εr = 2σ/m. Déterminer l’expression de εr en fonction de p et de N . En déduire que pour
εr = 10% et pour les petites valeurs de p, une valeur approchée de N est donnée par N ≈ 400/p.
5. Ecrire un programme qui calcule la longueur N d’une séquence de Bernoulli de paramètre p = 0,1 de
façon à ce que la moyenne empirique S approche p à εr près.
La loi de Bernoulli peut servir, entre autres applications, à modéliser une suite aléatoire de bits en vue
de la simulation d’un système de communication numérique. ou encore, comme il est fait dans l’exemple
6.9, à modéliser des erreurs.
Exemple 6.9 (Estimation d’une probabilité d’erreur)

On considère une expérience aléatoire au cours de laquelle une suite de valeurs est reçue avec une
probabilité p d’erreurs et on se pose le problème d’estimer p à partir d’une suite de N observations. Pour
cela on envoie une séquence donnée de longueur N et on la compare à la séquence reçue. La question qui
se pose est « quelle valeur de N faut-il prendre pour estimer la probabilité d’erreur avec une précision de
10% ? ».
Modélisons la suite des erreurs par une suite de variables aléatoires Bn telles que Bn = 0 si les valeurs
en position n, dans la séquence originale et dans la séquence erronée, sont identiques et Bn = 1 si elles
sont différentes. La v.a. :
1 ∑
N
S= Bn (6.18)
N n=1
donne alors une estimation de la probabilité d’erreur inconnue p. Si on suppose que les v.a. Bn sont
indépendantes, on peut utiliser les résultats obtenus dans l’exercice 6.4. Pour estimer p avec une précision
ϵr de l’ordre de 10% et un intervalle de confiance de 95%, il faut partir d’une suite de longueur N ≈ 400/p.
Si on se contente d’un intervalle de confiance de 70%, la même précision ϵr = 0,1 est obtenue pour
N ≈ 100/p. C’est souvent en pratique la valeur qui est retenue pour calculer la longueur d’une séquence
de test. Notons que N p représente approximativement le nombre d’erreurs. Cela conduit à adopter la
règle suivante :
Pour estimer une probabilité d’erreur avec un précision de 10% et un niveau de confiance
de 70% il faut « voir passer » une centaine d’erreurs. Il faut donc effectuer l’estimation sur
une séquence dont la longueur est de l’ordre de 100/p.
Si la valeur de p cherchée est de l’ordre de 10−5 , il faut prendre N = 10 000 000. Une telle longueur
peut nécessiter un temps de simulation important, même sur une machine très rapide. Cette situation est
très courante dans le domaine des communications numériques.
Exercice 6.5 (Ellipse de confiance (indications page 150)) On note pX (x1 , x2 ) la densité de pro-
babilité d’un vecteur aléatoire gaussien de dimension 2, de moyenne m et de matrice de covariance C.
1. On pose :
∫
α = P {X ∈ ∆(s)} = pX (x1 , x2 )dx1 dx2
∆(s)
où ∆(s) est l’ensemble des points du plan défini par :

{ }
∆(s) = x = (x1 , x2 ) ∈ R2 : (x − m)T C −1 (x − m) < s
dont la frontière dans R2 est l’ellipse centrée sur m d’équation (x − m)T C −1 (x − m) = s.

On se propose de déterminer la relation qui lie s et α. On dit que l’ellipse E représente l’ellipse de
confiance à 100 α % de la variable X.
En effectuant le changement de variable Y = C −1/2 (X − m), montrer que s = −2 log(1 − α).
[ ]
2,3659 −0,3787
2. On prend m = [0 0]T , C = et α = 0,95.
−0,3787 0,6427
Ecrire un programme :
− qui engendre un échantillon gaussien de dimension 2 de taille N = 200, de moyenne m et

de matrice de covariance C à partir d’un échantillon Y = (Y1 , Y2 ) centré, blanc, obtenu par
y=rand(2,N,’normal’),
− qui affiche les points de coordonnées x dans le plan, ainsi que l’ellipse d’équation (x−m)T C −1 (x−
m) = s (utiliser la fonction ellipse déjà vue en exemple où s = −2 log(1 − α)),
− qui compte le nombre de points à l’extérieur de l’ellipse et le compare à la valeur (1 − α)N . Penser
à utiliser la fonction find portant sur la condition y12 + y22 > s.
Exercice 6.6 (Chaîne de Markov (indications page 150)) On observe une suite d’états engendrés
par un graphe de Markov comme suite de N entiers ℓ ∈ {1, n}. On cherche à identifier la matrice de transition
A à partir de cette observation. L’idée est de chercher à maximiser la probabilité conditionnelle pcN d’obtenir
une telle suite connaissant les n2 coefficients aij . Cette quantité est appelée vraisemblance. La solution obtenue
est dite solution du maximum de vraisemblance.
1. Etant donné un état initial ℓ0 , donner pcN en fonction de ℓ0 et des aij . Exprimer le logarithme de cette
quantité, logarithme que l’on désigne par log-vraisemblance.
∑n
2. Le problème apparait alors comme un problème de maximisation sous la contrainte j=1 aij = 1. Ce
problème peut être résolu en introduisant un degré de liberté supplémentaire dans l’expression que l’on
cherche à maximiser. Cette méthode est désignée par méthode des multiplicateurs de Lagrange. On
construit le lagrangien augmenté L de la façon suivante :
 
∑
n
L ({aij }, λ)) = log (pcN ) + λ  aij − 1 (6.19)
j=1
La résolution du système consiste à chercher un maximum de L qui est une fonction des aij et de λ.
3. Ecrire un programme qui engendre une séquence de Markov correspondant à la matrice :

 
0 1 0 0 0
3/4 0 1/4 0 0 
 
A= 0 1/3 1/3 1/3 0 
1/4 1/4 1/4 0 1/4
1/3 0 0 2/3 0
et en donne une estimation à partir d’une observation de la séquence des états.

Chapitre 7
Eléments d’automatique linéaire à

temps continu

−
−
−
−
Scilab a été doté dès le départ de nombreuses fonctionnalités relatives au domaine de l’automatique. Nous
en donnons dans ce chapitre les éléments de base en les rattachant aux concepts sous-jacents. On fournit
les programmes Scilab mais aussi les programmes MATLAB correspondant, pour mettre en évidence les
quelques différences qui existent entre les deux langages.
7.1 La transformée de Laplace

Ce paragraphe porte sur la transformée de Laplace (TL) de fonctions du temps et son application aux
systèmes linéaires invariants (SLI).
7.1.1 Définition
On considère les fonctions x(t) continues par morceaux telles que ∃ C et λ > 0 tels que |x(t)| <
C exp(λt). On suppose aussi qu’il existe α, 0 < α < 1, tel que limt→0 tα |x(t)| → 0. On dira que ces
fonctions appartiennent à l’espace L . Dans ces conditions on peut définir la transformée de Laplace de
x(t) par la fonction complexe X(p) de la variable complexe p par :
∫ ∞
X(p) = x(t)e−pt dt (7.1)
0
L’ensemble des valeurs de p telles que la TL existe est le domaine de convergence (DC) de X(p). Ce
dernier est de la forme Re(p) > λ.
La TL, telle que définie ici avec la borne inférieure de l’intégrale égale à 0, est l’outil privilégié de
résolution des équations différentielle linéaires à coefficients constants (EDLCC) lorsqu’on cherche des
solutions causales, ce qui est le cas dans le domaine de l’automatique.
Son utilisation ne s’arrête cependant pas à la résolution des EDLCC mais permet aussi de résoudre
certaines équations différentielles aux dérivées partielles ou autres équations différentielles non linéaires.
89
90 Chapitre 7 - Eléments d’automatique linéaire à temps continu
On peut remarquer que, si l’on pose p = 2πjf , et pour peu que la fonction x(t) soit causale (nulle
pour t < 0), on obtient la transformée de Fourier de x(t) (encore faut-il vérifier qu’elle existe, c’est-à-dire
que l’axe imaginaire appartient au domaine de convergence !) :
∫ ∞ ∫ ∞
−2πjf t
X(p) = x(t)e dt = x(t)e−2πjf t dt (7.2)
0 −∞
⋆ On supposera dans tout ce qui suit que les domaines de convergence sont toujours de la forme
Re(p) > λ et on admettra que cette condition est équivalente à dire que les fonctions correspondantes
sont causales, c’est-à-dire nulles pour t < 0. Le théorème de Paley-Wiener établit ce résultat.
7.1.2 Quelques propriétés

On note X(p) la TL de x(t), Y (p) la TL de y(t), etc.
Les propriétés de base :
1. linéarité : ax(t) + by(t) → aX(p) + bY (p) ;
2. dérivation : dx(t)/dt → pX(p) − x(0+ ) ;

∫t
3. intégrale : 0 x(u)du → X(p)/p ;
4. exponentielle : exp(−at) → 1
p+a et 1
p+a → exp(−at)u(t) (u(t) est l’échelon unité ou fonction de
Heaviside) ;
5. échelon unité : u(t) → 1

p ;
6. retard : x(t − τ ) → X(p) exp(−τ p) ;
7. modulation : x(t) exp(−at) → X(p + a).
8. dérivée par rapport à p : dX(p)/dp → (−t)x(t)u(t) ;
9. théorèmes limites :
limt→0+ x(t) = limp→∞ pX(p)

limt→+∞ x(t) = limp→0 pX(p)
1
Exemple : on cherche l’original de (p+2)2 . On part de la propriété (8) de dérivation par rapport à p :
d 1 −1
= 2 → tu(t)
dp p p
puis on utilise la propriété de modulation pour obtenir t exp(−2t)u(t).

Obtention des théorèmes limites :
∫
− lorsque p → ∞, I = ẋ(t) exp(−pt)dt → 0. De plus, par intégration par parties :
∫ +∞ ∞
0
ẋ(t) exp(−pt)dt = [x(t) exp(−pt)]0+
∫ +∞
+p 0 x(t) exp(−pt)dt = pX(p) − x(0+ )
on obtient le résultat cherché ;

∫ +∞
− I = 0 ẋ(t) exp(−pt)dt = pX(p) − x(0+ ). Si p → 0 :
∫
I→ ẋ(t)dt = x(∞) − x(0+ )
d’où le résultat.
Exemples
1
1. Original de (p−1)(p+2) :
1/3 1/3
1
(p−1)(p+2) = p−1 − p+2
( t )
→ 1
3 e − e−2t u(t)
2. Soit X(p) = 2p−1

(p+1)(p+2) . Calculer l’original x(t) et vérifier les valeurs en t = 0 et t = ∞ :
2p−1
= − p+1
(p+1)(p+2)
3 5
+ p+2
( )
→ −3e−t + 5e−2t u(t)
On a bien limp→∞ pX(p) = 2 et limp→0 pX(p) = 0.
7.1.3 Notion de système

Les systèmes physiques auxquels nous nous intéressons ici sont régis par des équations différentielles
linéaires à coefficients constants.
Application de la TL aux EDLCC

Considérons l’EDLCC suivante :
ÿ(t) + ẏ(t) + y(t) = 2ẋ(t) + x(t) (7.3)
En appliquant la TL :
[ ]
L (p) = p2 Y (p) − py(0) − ẏ(0)
+ [pY (p) − y(0)] + Y (p)
= 2 [pX(p) − x(0)] + X(p)
soit :
2p + 1 py(0) + ẏ(0) − x(0)
Y (p) = X(p) +
p2 + p + 1 p2 + p + 1
P0 (p)
= G(p)X(p) + (7.4)
D(p)
en posant G(p) = N (p)/D(p).
On reconnaît dans l’expression 7.4 la solution composée :
− d’une solution particulière (partie forcée) – G(p)X(p) ;
− et de la solution générale de l’équation sans second membre (partie libre) – P0 (p)/D(p) – dépendant
des conditions initiales.
G(p) est une fraction rationnelle en p. Les racines du polynôme numérateur N (p) sont appelés les
zéros et celles du dénominateur D(p) les pôles.indexpoles@pôles
Lorsque les zéros et les pôles sont à partie réelle négative, on dit que le système est à minimum de
phase.
Le système comme “boîte noire”

Une équation différentielle peut être considérée comme une “boîte noire” ayant pour entrée x(t) et
comme sortie y(t). On peut montrer que, si on a affaire à une EDLCC, le système est donc linéaire et
invariant, alors y(t) peut être écrit sous la forme d’une convolution notée ⋆ :
∫ +∞ ∫ +∞
y(t) = g(u)x(t − u)du = g(t − u)x(u)du = (x ⋆ g)(t) (7.5)
−∞ −∞
g(t) est appelée réponse impulsionnelle du système. et :

(x ⋆ g)(t) → X(p)G(p)
∫ t
X(p)G(p) → g(u)x(t − u)du
0
en raison de la causalité (g(t) et x(t) sont nulles pour t < 0).
G(p) est appelée fonction de transfert. G(jω), ou G(2πjf ), est appelé gain complexe. Lorsque
G(p) = N (p)/D(p) et que le degré de D(p) est > degré de N (p) on dit que le système est strictement
propre. La valeur de G(0) est appelée gain en continu.
La réponse à un échelon unité est appelée réponse indicielle.
La stabilité
La notion de stabilité qui nous intéresse ici est la stabilité entrée bornée - sortie bornée (EBSB) : si
|x(t)| < A ⇒ |y(t)| < B.
Théorème 7.1.1 (Stabilité EBSB) ∫

Un système est stable EBSB si et seulement si sa réponse impulsionnelle est sommable : R |g(t)|dt.
Théorème 7.1.2 (CNS de stabilité EBSB)

Un système est stable EBSB si et seulement si les pôles de la fonction de transfert sont à partie réelle
négative.
Exemple 7.1 (Second ordre pur) Un système du second ordre pur a pour fonction de transfert :
2
ωN
G(p) = 2 (7.6)
p2 + 2zωN p + ωN
où z est le coefficient d’amortissement et ωN la pulsation propre. Il a d’autant plus d’intérêt que l’on se
réfère souvent à ce type de système pour caractériser le comportement de systèmes d’ordres plus élevés.
On dit qu’un système présente une résonance lorsque son gain complexe présente un maximum. Dans
le cas d’un système d’ordre quelconque ce maximum peut être local.
Récapitulatif :
√ √
0 < z < 22 2
2
<z<1 z≥1
oscillations oscillations pas d’oscillations
et résonance pas de pas de résonance
résonance
Résultats divers :
√
− pulsation du régime oscillant : ωo = ωN 1 − z 2 ;
− constante de temps de l’exponentielle décroissante : τ = 1/(zωN ). Le temps de réponse à 5% est
minimum pour z ≈ 0,707 ;
− dépassement relatif (dans la réponse à un échelon, dépassement du premier maximum par rapport
à la valeur limite) :
( )
−zπ
D = exp √
1 − z2
√
− à la résonance ωR = ωN 1 − 2z 2 et le module du gain :
1
|G(ωR )| = √
2z 1 − 2z 2
Le coefficient de surtension Q est défini comme |G(ωR )|/|G(0)|. Ici cela donne Q = 2z√1−2z
1
2
;
√
− la pulsation de coupure ω−3 à −3 dB est définie par G(ω−3 )/G(0) = 2/2 et l’on a ω−3 2
= ωR 2
+
√
4 4
ω−3 + ωR .
7.2 Outils graphiques

Ce paragraphe porte sur les représentations graphiques utilisées en automatique “fréquentielle”.
7.2.1 Diagrammes de Bode

Les diagrammes de Bode, associés à une fonction de transfert, donnent la gain, en dB, et la phase en
degrés, en fonction de log(ω). Ils utilisent des diagrammes asymptotiques.
Premier ordre
Un système du premier ordre est modélisé de la façon suivante :
A dy(t)
G(p) = ↔ + ay(t) = Ax(t)
p+a dt
Programme Scilab ordre1.sce :
//===== ordre1.sce
// exec(’ordre1.sce’,-1)
clear
clf
den=poly([1,1],’s’,"coeff");
wlog=logspace(-1,1,100); jw=wlog*%i;
mp=1 ./ horner(den,jw);
subplot(211),
plot2d("ln",wlog,20*log10(abs(mp)));
h=gca(); h.grid=[1 1];
phi=atan(imag(mp),real(mp))*180/%pi;
subplot(212), plot2d("ln",wlog,phi);
Figure 7.1 – Diagramme de Bode de 1/(p + 1)
Il existe une fonction bode dans Scilab, fonction qu’il est évidemment préférable d’utiliser. Le
programme précédent explique cependant simplement comment on peut effectuer les calculs et les
affichages.
Programme Matlab ordre1.m :

%===== ordre1.m
clear
clf
den=[1,1];
wlog=logspace(-1,1,100); jw=wlog*1i;
%===== module
mp=1 ./ polyval(den,jw);
mpdB=20*log10(abs(mp));
mx=max(mpdB); mn=min(mpdB);
d=(mx-mn)*.05;
subplot(211), semilogx(wlog,mpdB);
set(gca,’ylim’,[mn-d,mx+d]), grid
%===== phase
phi=atan2(imag(mp),real(mp))*180/pi;
subplot(212), semilogx(wlog,phi);
grid;
Comme le gain est exprimé en décibels, les diagrammes de gain associés aux pôles et aux zéros
s’ajoutent simplement. Il en est de même de la phase puisqu’on a une somme des différents arguments.
Exemple 7.2 (Diagramme de Bode) On considère la fonction de transfert :
p+2
G(p) =
(p + 1)(p + 4)
◦ Tracer le diagramme de Bode de G(p) : du fait de l’utilisation de logarithmes pour l’abscisse et

l’ordonnée du diagramme de gain, il suffit d’ajouter les diagrammes asymptotiques des gains des termes
1/(p + 1), (p + 2) et 1/(p + 4). Il en est de même pour le diagramme de phase car on a la somme des
arguments des trois mêmes termes.
p+2
Figure 7.2 – Diagramme de Bode de (p+1)(p+4)
◦ Donner la réponse impulsionnelle du système G(p) : on peut partir de l’original de H(p) = (p+1)(p+4)
1
,
soit h(t) = 3 exp(−t) − 3 exp(−4t). Comme on multiplie par p + 2, cela correspond à une dérivation et à
1 1
une multiplication par 2, soit g(t) = dh(t)/dt + 2h(t).

Deuxième ordre
Reprenons l’expression 7.6.
2
ωN
G(p) = 2
p2 + 2ωN p + ωN
d2 y(t) dy(t)
↔ 2
+ 2zωN 2
+ ωN 2
y(t) = ωN x(t)
dt dt
Le comportement en fréquences d’un second ordre est illustré par le diagramme de Bode pour plusieurs
valeurs de l’amortissement.
Programme Scilab ordre2.sce :
//===== ordre2.sce
// exec(ordre2.sce,-1)
clear, clf
wn=1; z=[.1 .3 .5 sqrt(2)/2 1 2];
for k=1:length(z)
mcof=[wn*wn,2*z(k)*wn,1];
den=poly(mcof,’s’,"coeff");
subplot(211)
phi=atan(imag(mp),real(mp))*180/%pi;
subplot(212)
plot2d("ln",wlog,phi);
end
Figure
√ 7.3 – Diagrammes de Bode de 1/(p2 + 2zp + 1) pour z = 0.1, 0.3, 0.5,
2/2, 1 et 2
Programme Matlab ordre2.m :

%===== ordre2.m
clear, clf
wn=1; z=[.1 .3 .5 sqrt(2)/2 1 2];
Npts=100;
wlog=logspace(-1,1,Npts); jw=wlog*1i;
for k=1:length(z)
mcof=[1,2*z(k)*wn,wn*wn];
mp=1 ./ polyval(mcof,jw);
mpdB=20*log10(abs(mp));
subplot(211), semilogx(wlog,mpdB);
grid on, hold on
phi=atan2(imag(mp),real(mp))*180/pi;
subplot(212), semilogx(wlog,phi);
grid on, hold on
end
7.2.2 Diagrammes de Nyquist

Le diagramme de Nyquist donne, dans le plan complexe, le lieu de G(jω) lorsque ω varie de −∞ à
+∞. Si l’on ne dispose pas du logiciel adéquat, le plus simple est de tracer le diagramme de Bode et d’en
déduire le diagramme de Nyquist.
Programme Matlab ordre2nyq.m :
%===== ordre2nyq.m
clear,clf
wn=1; z=[.1 .3 .5 sqrt(2)/2 1 2];
Npts=200;
wlog=logspace(-1,1,Npts); jw=wlog*1i;
mp=zeros(length(z),Npts);
for k=1:length(z)
mcof=[1,2*z(k)*wn,wn*wn];
mp(k,:)=1 ./ polyval(mcof,jw);
end
mp=mp.’; plot(real(mp),imag(mp))
limx=get(gca,’xlim’); limy=get(gca,’ylim’);
hold on, plot(limx,[0 0]),
plot([0 0],limy),
plot(real(mp(:,1)),imag(mp(:,1)),’.’)
hold off, grid, axis(’square’)
−0.5
−1
−1.5
−2
−2.5
−3
−3.5
−4
−4.5
−5
−3 −2 −1 0 1 2 3
2
Figure
√ 7.4 – Diagrammes de Nyquist de 1/(p + 2zp + 1) pour z = 0.1, 0.3,
0.5, 2/2, 1 et 2
Le diagramme de Nyquist est essentiellement utilisé pour discuter de la stabilité d’un système en
boucle fermée alors qu’il ne reflète que le contenu fréquentiel de la fonction de transfert en boucle ouverte.
7.2.3 Exemples de diagrammes de Nyquist

2p+1
Diagramme de (p+2)(p+4)
0.2
10 dB 4 dB 0 dB −4 dB −10 dB
6 dB 2 dB −2 dB −6 dB
0.15
0.1
20 dB
0.05 −20 dB
−0.05
−0.1
−0.15
−0.2
−1 −0.8 −0.6 −0.4 −0.2 0 0.2 0.4
1/8
2p+1
Figure 7.5 – Diagramme de Nyquist de (p+2)(p+4)
2p+1
Diagramme de (p−2)(p+4)
0.4
2 dB −2 dB −6 dB −10 dB
4 dB −4 dB
6 dB 0 dB
0.3
10 dB
0.2
0.1 20 dB
−20 dB
0
−0.1
−0.2
−0.3
−0.4
−1 −0.8 −0.6 −0.4 −0.2 0 0.2 0.4
−1/8
2p+1
Figure 7.6 – Diagramme de Nyquist de (p−2)(p+4)
p
Diagramme de p2 +0,5p+1
1
Diagramme de p(p2 +0,5p+1)
Lorsque ω = ε > 0, on peut écrire :
1 1 1
≈ ≈ (−0,5ε − j)
p(p2 + 0,5p + 1) jε(0,5jε + 1) ε
La partie réelle tend donc vers −0,5 lorsque ω → 0.

1
2 dB 0 dB
0.8 4 dB −2 dB
superposition
0.6 6 dB des tracés
0.4 10 dB −4 dB
−6 dB
0.2 −10 dB
20 dB
0
−20 dB
−0.2
−0.4
−0.6
−0.8
−1
−1 −0.5 0 0.5 1 1.5 2
p
Figure 7.7 – Diagramme de Nyquist de p2 +0,5p+1
10
8
6
4 0 dB
2 2 dB −2 dB −4 dB
4 dB 6 dB 10 dB
0
−10 dB
−2 −6 dB
−4
−6
−8
−10
−2.5 −2 −1.5 −1 −0.5 0
1
Figure 7.8 – Diagramme de Nyquist de p(p2 +0,5p+1)
7.2.4 Diagrammes de Black-Nichols

Le diagramme de Black-Nichols (phase en degrés - module en dB) est du même type que le diagramme
de Nyquist. Il était utilisé pour calculer manuellement la fonction de transfert en boucle fermée et de
déterminer un compensateur avec plus de facilité qu’avec le diagramme de Nyquist. L’abaque de Black-
Nichols représente les caractéristiques |z/(1 + z)| = constante et argz/(1 + z) = constante pour faciliter
le passage boucle ouverte - boucle fermée.
Exercice 7.1 (Etude d’un troisième ordre) (indications p. 152) On considère le système de fonction
de transfert G(p) :
1
G(p) = (7.7)
(p2 − 1)(p + 2)
1. donner sa réponse impulsionnelle ;
2. donner sa réponse indicielle à conditions initiales nulles sans refaire de décomposition en éléments
simples ;
3. dessiner le diagramme de Bode de G(p) :
4. dessiner le diagramme de Nyquist de G(p).
25 0.5
0
357 3
20 1
−1
15
354 2.3 6
3
10
6 −3
5 350
12 10
0 340 20 −6
−5 320 40
−12
−10
300 60
−15 280 80
260 240 220 200 160 140 120 100 −18
−350 −300 −250 −200 −150 −100 −50 0
Figure 7.9 – Abaque de Black-Nichols
25 0.5
0
357 3
20 1
−1
15
354 2.3 6
3
10
6 −3
5 350
12 10
340 20 −6
0
−5 320 40
−12
−10
300 60
−15 280 80
260 240 220 200 160 140 120 100 −18
−350 −300 −250 −200 −150 −100 −50 0
Figure 7.10 – Abaque de Black-Nichols pour un second ordre avec z=[.1 .3

.5 sqrt(2)/2 1 2]
7.3 Le pourquoi du bouclage

Il est illusoire de vouloir commander un système sans avoir d’information sur les grandeurs que l’on
veut piloter.
Considérons en exemple le réglage de la température dans la pièce d’une maison. L’ouverture de la
porte perturbe la température ambiante et le seul moyen de maintenir celle-ci à une valeur désirée est de
connaître la valeur à tout instant. Si cette dernière baisse il faut augmenter la puissance de chauffe et,
inversement, baisser la puissance de chauffe si elle augmente.
Autre exemple simple, celui d’un véhicule censé se déplacer de façon autonome. On peut en construire
un modèle mathématique très précis. Dans ce cas, l’application de commandes – du moteur et de la
direction – devrait pouvoir permettre de conduire le véhicule d’un point à un autre sans problème. Il n’en
est rien. Il suffit de supposer que le véhicule passe sur un petit caillou pour que cette petite perturbation
dévie le véhicule sans que l’on en tienne compte. De la même façon une erreur sur le modèle, par exemple
en supposant que les roues directrices sont de diamètre identique, suffit à provoquer le même type de
difficulté. La seule façon de faire est de connaître en permanence la position du véhicule pour corriger, si
nécessaire, toutes les erreurs pouvant affecter la trajectoire.

Ces deux exemples illustrent les deux caractéristiques dont on veut doter un système commandé :
1. suive de consigne : on veut, dans tous les cas, que la grandeur pilotée suive la consigne qui est
définie ;
2. rejet des perturbations : on veut aussi que les perturbations éventuelles (la porte qui s’ouvre, le
petit caillou sur la trajectoire) soient “corrigées” sans intervention extérieure ;
3. performances : on veut, de façon générale, assurer des performances satisfaisantes : le suivi de

consigne, ou la correction de la perturbation, doit être fait assez vite sans avoir trop d’oscillations.
7.3.1 Schémas généraux

Il y a deux cas selon qu’il y a plusieurs entrées ou sorties (MIMO, multiple input - multiple output)
ou une entrée et une sortie (SISO, single input - single output) (figure 7.11 ).
Figure 7.11 – Cas mono-entrée / mono-sortie (SISO)
Fonction de transfert SISO :

K(p)G(p)
H(p) =
1 + K(p)G(p)M (p)
7.3.2 Utilisation du diagramme de Nyquist

On peut stabiliser un système instable par bouclage, mais ce n’est pas toujours possible.
Critère géométrique de stabilité EBSB : étant donné G(p), fonction de transfert en boucle ouverte
(BO), le système en boucle fermée (BF) est stable EBSB si et seulement si le lieu de Nyquist associé à
G(p) tourne autour du point critique (−1, 0), dans le sens trigonométrique, un nombre de fois égal au
nombre de pôles instables de G(p) lorsque p parcourt le contour de Bromwich B (figure 7.12 ).
Figure 7.12 – Contour de Bromwich
Le contour de Bromwich englobe en principe les pôles sur l’axe imaginaire, ceux-ci étant considérés
comme instables. Ce n’est cependant pas une obligation. Dans le cas contraire on considère les pôles sur
l’axe imaginaire comme pôles stables (voir exemple 7.3).
Indications : considérons la fonction de transfert rationnelle G(p) :
(p − a)N0 (p)
G(p) =
D(p)
Lorsque p parcourt B, la variation de phase due au seul terme (p − a) est de −2π (figure 7.13 ). Si a
est un pôle, cette variation est 2π. Pour les pôles ou zéros en dehors du contours B, la variation de phase
est nulle. On déduit de cela que, lorsque p parcourt B, G(p) tourne autour de l’origine Np (G) − Nz (G)
fois dans le sens direct autour de l’origine où Np (G) et Nz (G) sont respectivement le nombre de pôles et
le nombre de zéros de G(p) dans le demi-plan droit.
Figure 7.13 – Variation de phase pour un zéro en a et un pôle ou zéro b extérieur

àB
Une condition de stabilité EBSB en boucle fermée est que les pôles de H(p) = G(p)/(1+G(p)) doivent
être à partie réelle négative. Ceci se traduit par “les zéros de 1 + G(p)” ne sont pas dans B. Or, lorsque
p parcourt B, 1 + G(p) tourne Np (1 + G) − Nz (1 + G) fois dans le sens direct autour de l’origine. Or
Np (1 + G) = Np (G) et Nz (1 + G) doit être nul. La condition de stabilité s’écrit alors : le lieu de 1 + G(p)
doit tourner autour de l’origine Np (G) fois dans le sens direct. De façon équivalente le lieu de G(p) doit
tourner autour du point (−1, 0) Np (G) fois dans le sens direct. (−1, 0) est appelé point critique.
Exemple : diagramme de Nyquist de la fonction de transfert
4k(p − 2)
p2 + 5p + 4
avec k > 0, (figure 7.14 pour k = 1) obtenu par le programme Matlab explenyquist51.m.
%===== explnyquist51.m
% utilisation de la toolbox control
num=[1 -2]*4; den=[1 5 4];
g2p=tf(num,den); tf(g2p)
nyquist(g2p), grid
En Scilab, on aurait :
//===== nyquiststab.sce
num=poly([-2 1]*4,’p’,"coeff");
den=poly([4 5 1],’p’,"coeff");
monsysteme=syslin(’c’,num,den);
nyquist(monsysteme)
Le système en BO est stable, donc Np (G) = 0.
1. si le gain k est > 1/2 (c’est pour ω = 0 que l’on a le gain maximum), le lieu de Nyquist tourne une
fois, dans le sens inverse, autour du point critique. Le système en BF est donc instable ;
2. Si k est < 1/2, le lieu de Nyquist ne tourne pas autour du point critique. Le système en BF est
stable ;
3. Pour k = 1/2, la fonction de transfert en BF est :
2(p − 2) 2(p − 2)
= 2
p2 + 5p + 4 + 2(p − 2) p + 7p
qui est instable à cause du pôle p = 0.

2
2 dB 0 dB −2 dB
1.5
4 dB −4 dB
1
6 dB −6 dB
0.5 −10 dB
10 dB
20 dB −20 dB
point 0
critique
−0.5
−1
−1.5
−2
−2 −1.5 −1 −0.5 0 0.5 1
4k(p−2)
Figure 7.14 – Diagramme de Nyquist de p2 +5p+4 , pour k = 1
Exemple 7.3 (Choix du contour de Bromwich) Soit le système de fonction de transfert :
p+1
p(p + 4)
0.1
2 0
1
0 0.001
0
−1
−2
0 0.02 0.04 0.06 0.08 0.10 0.12 0.14 0.16 0.18 0.2
p+1
Figure 7.15 – Diagramme de Nyquist de p(p+4)
Le diagramme de Nyquist (figure 7.15 ) présente une asymptote en x = 3/16. On peut écrire :
1 p 1 3
G(p) ∼ (1 + p)(1 − + θ(p2 )) = + + θ(p)
p→0 4p 4 4p 16
Lorsque p = jω → 0+ , la partie réelle → 3/16 et la partie imaginaire vers −∞.

Problème de la “fermeture à l’infini” : pour fermer le contours de Bromwich, on a le choix de considérer
p = 0 comme un pôle instable ou un pôle stable. Dans le premier cas, on doit l’inclure dans (B), dans le
second, on l’exclut (figure 7.16 ).
Le système en boucle fermée est toujours stable.
7.3.3 Autres critères de stabilité

Il existe des critères de stabilité évitant le calcul des pôles de la fonction de transfert.
Figure 7.16 – Les deux choix pour le contour de Bromwich
3/16
0
−1
−2
0 0.04 0.08 0.12 0.16 0.2
p+1
Figure 7.17 – Fermeture du diagramme de Nyquist de p(p+4)
1. CN de stabilité : tous coefficients positifs ;

2. critère de Hurwitz ;
3. critère de Routh : partant de D(p) = an pn + an−1 pn−1 + · · · , on construit le tableau
an an−2 an−4 ... 0

an−1 an−3 an−5 ... 0
b1 = b2 = ... ... 0
an−1 an−2 −an an−3 an−1 an−4 −an an−5
an−1 an−1 ... ... 0
c1 = b2 = ... ... 0
b1 an−3 −b2 an−1 b1 an−5 −b3 an−1
b1 b1 ... ... 0
... ... ... ... 0
Le nombre de pôles à partie réelle positive est donné par le nombre de changements de signe des
termes de la première colonne.
Dans le cas où le tableau de Routh possède un élément nul dans la première colonne alors :
− si la ligne correspondante contient un ou plusieurs éléments non-nuls, D(p) possède au moins
une racine dans le demi-plan droit ouvert ;
− si tous les éléments de la ligne sont nuls alors :
– D(p) a au moins une paire de racines imaginaires pures,
– ou D(p) possède une paire de racines réelles de signes opposés,
– ou D(p) possède quatre racines complexes conjuguées deux à deux et de parties réelles de
signes opposés deux à deux.
Exemple 7.4 (Moteur commandé par l’induit) Asservissement de position à l’aide d’un moteur à
courant continu commandé par l’induit :
θ(p) 1 α
G(p) = ≈ ( JR
)=
V (p) Kp 1 + K2 p
p(1 + βp)
En boucle fermée avec un amplificateur :
kG(p) kα
H(p) = =
1 + kG(p) βp2 + p + kα
7.3.4 Critères de performances

Les performances d’un système peuvent être définies en termes de comportement vis-à-vis des entrées
ou en terme de robustesse (résistance aux perturbations ou aux erreurs de modélisation). Les critères les
plus simples sont les suivants :
− critères issus de l’analogie avec le second ordre : les marges de stabilité.
1,5
Exemple 7.5 (Marges de stabilité) Considérons G(p) = p2 +0,5p+1 (figure 7.18 ).
4
0 dB
−2 dB
2 2 dB
4 dB −4 dB
1
6 dB −6 dB
10 dB −10 dB
0
−1
−2
−3
−4
−1.5 −1 −0.5 0 0.5 1 1.5 2
Figure 7.18 – Marges de stabilité
On relève les marges principales :
1. la marge de phase est obtenue par ∆φ = 180 − φG=1 ;

2. la marge de gain est obtenue par la distance exprimée en décibels entre le point critique et le
point d’intersection du lieu de Nyquist avec l’axe imaginaire. Dans notre cas, la marge de gain
est infinie et la marge de phase ≈ 30˚ ;
3. la marge de gain-phase est la distance minimum entre point critique et le lieu de Nyquist ;
4. la marge de retard MR = θ/ω0 où ω0 est la pulsation pour laquelle le gain vaut 1. Elle donne la
valeur d’un retard pur amenant le point de module 1 sur le point critique. En effet, un retard
pur étant de la forme e−τ p , une valeur de τ = MR amène le point G(ω0 ) sur le point critique.
− critères temporels en général définis pour une réponse indicielle : temps de réponse, dépassement,
retards, etc. A ces critères sont reliés les notions d’erreurs de position, vitesse, etc.
Ces critères permettent de définir un compensateur. Le compensateur traditionnel est le PID

(proportionnel-intégral-dérivé).
7.3.5 Le compensateur PID

Le compensateur PID a pour fonction de transfert :
( )
1 τd p
K(p) = k 1 + + avec N ≫ 1 (7.8)
τi p 1 + τNd p
Il n’est pas facile de régler un compensateur PID. Le nombre des paramètres est en effet important et,
si l’on doit effectuer ce réglage manuellement, on préfère régler séparément les effets de gain, d’intégration
et de dérivation.
− proportionnel : gain pur k ;
− proportionnel-intégral (PI),
1 + τp
K(p) = kb (7.9)
τp
− proportionnel-dérivé (PD) :
( )
τd p
K(p) = k 1 + (7.10)
1 + τNd p
avec pour forme standard :
1 + aτ p
K(p) = ka (7.11)
1 + τp
avec a > 1, ka > 0, τ > 0.
7.3.6 Exemple d’application

Asservissement de position à l’aide d’un moteur à courant continu commandé par l’induit :
θ(p) 1 α
G(p) = ≈ ( JR
)=
V (p) Kp 1 + K2 p
p(1 + βp)
En boucle fermée avec un amplificateur :

kG(p) kα
H(p) = =
1 + kG(p) βp2 + p + kα
Ce système est donc toujours stable.
Utilisation du gain
Examinons la réponse indicielle en faisant varier la valeur de k (figure 7.19 ).
Un gain élevé donne une réponse plus rapide mais avec beaucoup d’oscillations.
Utilisation d’un compensateur proportionnel-dérivé

Un compensateur proportionnel-dérivé modifie la phase dans le bon sens mais augmente le gain en
hautes fréquences.
On choisit une pulsation ωm correspondant à l’axe de symétrie du diagramme de Bode du compensa-
teur. On se donne ka pour avoir un gain égal à 1 en ce point. Le paramètre a est choisi pour assurer la
marge de phase que l’on veut appliquer en ce point.
∆φ = 50 (marge de phase choisie)
ϕm = ∆φ − ϕωm − 180
ϕm = ϕm ∗ π/180
a = (1 + sin(ϕm ))/(1 − sin(ϕm ))
1 1
τ = √ ka = √
ωm a a
1.6
1.2
0.8
0.4
0
0 5 10 15 (s)
Figure 7.19 – Réponses indicielles pour k = .03, k = .05, k = .1, k = .5
20
15
10
5
0
60
30
0
(rad/s)
Figure 7.20 – Diagramme de bode d’un compensateur proportionnel-dérivé

avec k = 1, a = 10, τ = 1
Exercice 7.2 (Paramètres du compensateur PD) (indications p. 154) Justifier toutes les valeurs et
relations que l’on vient de donner.
En pratique on essaie plusieurs valeurs pour ωm en examinant par exemple la réponse à un échelon
comme critère.
Exercice 7.3 (Réglage de PID) (indications p. 154) On considère le compensateur proportionnel-
60
40 système
20
système + compensateur
0
compensateur
−20
−40
50
compensateur
0
−50
−100 système + compensateur
système
−150
−200
Figure 7.21 – Application du compensateur proportionnel-dérivé en ω = 2.6685

rad/s avec une marge de phase de 50˚
25
système
20
15
10
−5
−10
−15
−350 −300 −250 −200 −150 −100 −50 0
Figure 7.22 – Diagramme de Black-Nichols avec application du compensateur
1.4
système
1.2
0.8
0.6
0.4
0.2
0
0 5 10 15 20 25
Figure 7.23 – Réponses indicielles du système bouclé et du système bouclé

compensé
intégral :
1 + τp
K(p) = kr
τp
Tracer ses diagrammes de Bode et Nyquist.

En pratique on choisit la pulsation ωm à laquelle on veut appliquer le retard de phase φ. On déduit la
valeur de τ par φ = π/2 − atan(ωm τ ). Enfin on ajuste le gain kr .
7.3.7 Lieu d’Evans ou lieu des pôles

Le lieu d’Evans est le lieu des pôles du système en boucle fermée alimenté par un gain pur k variant
de 0 à +∞, soit le lieu des zéros de 1 + kG(p) lorsque k varie de 0 à +∞.
7.4 Scilab pour l’automatique

7.4.1 Réponses indicielles du second ordre
// ------ step2order.sce
clear, clf
wn=1; z=[.1 .3 .5 sqrt(2)/2 1 2];
t=linspace(0,14,100);
for k=1:length(z)
dcof=[wn*wn,2*z(k)*wn,1];
den=poly(dcof,’s’,"coeff");
ncof=wn*wn;
num=poly(ncof,’s’,"coeff")
monsysteme=syslin(’c’,num,den);
y=csim(’step’,t,monsysteme);
plot(t,y)
end
Passage à une représentation d’état :

-->monsys=tf2ss(num/den); monsys=clean(monsys)
monsys =
monsys(1) (state-space system:)
!lss A B C D X0 dt !
monsys(2) = A matrix =
0. 1.
- 1. - 0.2
monsys(3) = B matrix =
0.
1.
monsys(4) = C matrix =
1. 0.
monsys(5) = D matrix =
0.
monsys(6) = X0 (initial state) =
0.
0.
monsys(7) = Time domain =
[]
Attention, la fonction companion ne retourne pas monsys(2)) :

-->A=companion(den)
A =
- 0.2 - 1.
1. 0.
Il vaut mieux passer par la fonction abcd :

-->[A,B,C,D]=abcd(monsys)
D =
0.
C =
1. 0.
B =
0.
1.
A =
0. 1.
- 1. - 0.2
Chapitre 8
Résolution d’équations
8.1 Systèmes d’équations et recherches de zéros

8.1.1 Zéros d’une fonction par la méthode de Newton
Le principe de la méthode est illustré par la figure 8.1 . Etant donné le graphe G de y = f (x), on
construit une suite de valeurs xn de la façon suivante : on considère la tangente (∆n ) en xn à G et son
intersection avec l’axe Ox. On réitère ce processus jusqu’à ce que |xn+1 − xn | < ε.
Figure 8.1 – Schéma de récurrence dans la méthode de Newton
La convergence de la méthode dépend de plusieurs conditions portant sur la fonction x − y/y ′ et le

choix de la valeur initiale x0 .
Exercice 8.1 (Méthode de Newton (indications p. 156))
1. en notant yn = f (xn ) et yn′ la dérivée de y = f (x) en x = xn , donner la relation de récurrence liant

xn+1 à xn ;
2. on se donne un polynôme de la façon suivante :
myrts=[1,sqrt(2),3]; mypol=poly(myrts,’x’);
Ecrire un programme calculant les racines - données par myrts – de ce polynôme, à l’aide de la méthode
de Newton.
8.1.2 Racines d’un polynôme par Newton-Raphson

Scilab dispose, avec roots, d’une fonction de calcul de racines d’un polynôme. En guise d’exercice
nous allons utiliser la méthode de Newton-Raphson au lieu de la méthode de Jenkins-Traub (voir l’aide
de roots pour des références) utilisée par Scilab. On considère le polynôme P (z) de degré D :
∑
D
P (z) = a(n)z n (8.1)
n=0
111
112 Chapitre 8 - Résolution d’équations
Le principe du calcul est le suivant : on se donne une valeur initiale z = x0 + jy0 . On fait ensuite
varier z de ∆z = ∆x + j∆y, ∆x et ∆y étant fournis par les formules de Newton pour faire en sorte que
le P (z) se rapproche de l’origine (figure 8.2 ). Le test d’arrêt est donné par |∆x| + |∆y| < ε.
Figure 8.2 – Principe de la méthode
1. Au cours du calcul z n est évalué par récurrence. On pose z n = (x + jy)n = Xn + jYn et les Xn et
Yn sont obtenus par :
Xn = xXn−1 − yYn−1 et Yn = xYn−1 + yXn−1 (8.2)
∑D ∑D ∑D
2. On note P (z) = U + jV = n=0 a(n)z n = n=0 a(n)Xn + j n=0 a(n)Yn et :
∂U ∑D
∂V ∂V ∑D
∂U
= na(n)Xn−1 = et = na(n)Yn−1 = − (8.3)
∂x n=1
∂y ∂x n=1
∂y
3. Les formules de Newton sont obtenues à partir de (voir figure 8.2 ) :
∂U ∂U ∂V ∂V
−U = ∆x + ∆y et −V = ∆x + ∆y
∂x ∂y ∂x ∂y
et des expressions 8.3 :
U ∂U
∂x + V ∂x
∂V
U ∂V − V ∂U
∆x = − ( ) 2 ( )2 et ∆y = ( ∂x)
∂x
( ∂V )2 (8.4)
∂U ∂U 2
∂x + ∂V
∂x ∂x + ∂x
Exercice 8.2 (Méthode de Newton-Raphson (indications p. 157))
Ecrire une fonction de calcul d’une racine [xc,yc,cErr]=CalcXY(pol,x0,y0,nblps) où pol est le

polynôme donné sous forme de vecteur de ses coefficients (par ordre des puissances croissantes), (x0,y0) est
le point de départ, teps le ε de test de fin de boucle, nblps le nombre maximal autorisé de boucles, (xc,yc)
la solution trouvée et cErr un code erreur (par exemple un nombre d’itération qui « déborde »).
8.1.3 Systèmes d’équations non linéaires

Scilab propose la fonction fsolve. Sa syntaxe d’appel est la suivante :
[x [,v [,info]]]=fsolve(x0,fct [,fjac] [,tol])
Considérons un exemple simple.
Exemple 8.1 (Résolution par fsolve) Soit à résoudre le système d’équations :

{ 2 x1 x2
x1 − 2 − 1 = 0
(8.5)
x1 x2 + 2x22 − 2 = 0
Sa solution par fsolve dans sa version la plus simple est donnée par :
// ----- testsolve01.sce
// avec estimation du jacobien
deff(’[y]=mysyst(x)’,’y=[x(1)^2 - x(1)*x(2)/2 - 1; x(1)*x(2)+2* x(2)^2-2]’);
[xsol,v]=fsolve([20;20],mysyst);
disp(xsol) // solution
disp(v) // verification (v=mysyst(xsol))
disp(info) // code d’arret
Le vecteur solution est xsol. Le jacobien utilisé dans la résolution est estimé. Il peut être donné dans
l’appel à fsolve :
[ ]
2x1 − x22 − x21
J= (8.6)
x2 x1 + 4x2
// ----- testsolve02.sce
// avec jacobien
deff(’[y]=mysyst(x)’,’y=[x(1)^2 - x(1)*x(2)/2 - 1; x(1)*x(2)+2* x(2)^2-2]’);
deff(’[y]=msjac(x)’,’y=[2*x(1)-x(2)/2, -x(1)/2 ; x(2), x(1)+4*x(2)]’);
[xsol,v,info]=fsolve([20;20],mysyst,msjac);
disp(xsol), // solution
disp(v), // verification
8.2 Résolution d’équations différentielles ordinaires (ODE)

8.2.1 Résolution par passage du continu au discret
Le passage du continu au discret peut être fait par transformation bilinéaire (les automaticiens dési-
gnent ce passage par « méthode de Tustin »). On considère la système :
1
G(p) = (8.7)
1 + τp
On peut utiliser la fonction bilin ou, plus simplement, la fonction cls2dls de la façon suivante :
//===== tpsc2tpsd.sce
// simulation ar passage temps continu --> temps discret
function [myentr,etat]=f(t)
f0=0.5; y=sin(2*%pi*f0*t);
myentr=sign(y);
endfunction
// systeme lineaire
p=poly(0,’p’); num=1; tau=0.6; den=1+tau * p;
mysys=syslin(’c’,num,den); // systeme lin. temps continu
// systeme lineaire temps discret
T=.03; t=(0:T:7);
mysysd=cls2dls(tf2ss(num/den),T); //representation d’état
[D,N,P]=ss2tf(mysysd); // forme fonction de transfert
num=coeff(D*P+N); num=num($:-1:1);
den=coeff(P); den=den($:-1:1);
y=filter(num,den,myentr);
clf, plot(t,y), set(gca(),’grid’,[1 1])
On pourra constater que cette méthode est moins satisfaisante – du moins lorsqu’on fait des simulations
– que celle utilisant csim ou ode dès qu’il y a des discontinuïtés (on applique ici un signal « créneau »,
comme pour l’exemple qui suit).
8.2.2 Cas linéaire

Dans le cas linéaire on peut utiliser les fonctions de l’automatique temps continu. La fonction de
résolution csim utilise la fonction ode.
Exemple 8.2 (Utilisation de la fonction csim) On applique à l’entrée d’un filtre RC un signal « cré-
neau » et on désire en afficher la sortie. La fonction de transfert du filtre est
1 1
G(p) = = (8.8)
1 + RCp 1 + τp
La construction du créneau se fait par sign(sin(2πf0 t)).
//===== repcren.sce
function [myentr,etat]=f(t)
f0=0.5; y=sin(2*%pi*f0*t);
myentr=sign(y);
endfunction
// systeme lineaire
p=poly(0,’p’); num=1; tau=0.6; den=1+tau * p;
mysys=syslin(’c’,num,den); // systeme lin. temps continu
// simulation
t=(0:.03:7);
etat0=sqrt(tau)/2; // y/etat=sqrt(1/tau)
[y,etat]=csim(f,t,mysys,etat0);
// traces
//clf
myentr=f(t); plot(t,myentr,’r’,t,y)
a=gca(); a.grid=[1 1];
0.8
0.6
0.4
0.2
−0.2
−0.4
−0.6
−0.8
−1
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5 5.5 6 6.5 7
Figure 8.3 – Réponse à un créneau
Dans le programme on a défini un état initial qui donne une sortie y0 égale à 1/2 à l’instant initial. Ici
on a un premier ordre et l’obtention du scalaire liant la sortie à l’état peut être fait de la façon suivante :
-->yy=tf2ss(num/den); // représentation d’état

-->etat0=y0 / yy(4);
√
Ici on peut vérifier que la constante liant la sortie à l’état est 1/ τ . En effet, la représentation d’état
utilisée :
{
dt = − τ x(t) + τ u(t)
dx 1 √1
(8.9)
y(t) = √1τ x(t)
√
est obtenue en définissant l’état par x(t) = τ y(t).
8.2.3 Système différentiel

La résolution de systèmes de la forme dy/dt = f (t, y), où y est un vecteur, utilise la fonction ode de
Scilab.
Exemple 8.3 (Résolution d’un système « proies-prédateurs ») Soit à résoudre le système

d’équations, dites de Lotka-Volterra, suivant :
{ dx1
dt = ax1 − bx1 x2 (8.10)
dt = −cx2 + dx1 x2
dx2
avec a, b, c et d > 0.
// ----- testode05.sce
// points fixes [0;0] et [c/d;a/b] (omeg^2=ac)
a=1; b=1; c=1; d=1;
function xdot=f(t, x), xdot(1)=a*x(1)-b*x(1)*x(2); xdot(2)=-c*x(2)+d*x(1)*x(2); endfunction
xinit=[3/2 1.1 1.1 1 1;3 1.3 1.1 2 4];
t0=0; t=[0:0.1:2.35*%pi];
for k=1:5
x0=xinit(:,k);
y=ode(x0,t0,t,f);
plot(y(1,:),y(2,:))
end
a=gca(); a.data_bounds=[0,0;4.5,4.5]; a.grid=[1 1];
4.5
3.5
2.5
1.5
0.5
0
0 0.5 1.5 2.5 3.5 4.5
Figure 8.4 – Trajectoires de phase pour plusieurs valeurs initales
Exemple 8.4 (Runge-Kutta d’ordre 4)
//===== RK4.sce
function ydot=f(t, y),ydot=y^2-y*sin(t)+cos(t),endfunction
t=[0:h:%pi]; Lt=length(t);
y0=0; t0=0; h=0.1; t=0:h:%pi;
y=ode(’rk’,y0,t0,t1,f)
subplot(211), plot(t,y); set(gca(),’grid’,[1 1])
y1=y;
//===== resolution par RK4 standard
hs2=h/2; hs6=h/6;
y(1)=y0;
for k=1:Lt-1
k1=f(t(k),y(k));
k2=f(t(k)+hs2,y(k)+hs2*k1);
k3=f(t(k)+hs2,y(k)+hs2*k2);
k4=f(t(k)+h,y(k)+h*k3);
// on pondere les pentes estimees
y(k+1)=y(k)+(k1+2*k2+2*k3+k4)*hs6;
end
plot(t,y,’r’)
y2=y;
//===== resolution par RK4 - regle des 3/8
y(1)=y0; hs3=h/3; dhs3=2*hs3; hs8=h/8;
for k=1:Lt-1
k1=f(t(k),y(k));
k2=f(t(k)+hs3,y(k)+k1*hs3);
k3=f(t(k)+dhs3,y(k)-k1*hs3+k2*h);
k4=f(t(k)+h,y(k)+k1*h-k2*h+k3*h);
// on pondere les pentes estimees
y(k+1)=y(k)+(k1+3*k2+3*k3+k4)*hs8;
end
plot(t,y,’o’)
subplot(212), plot(y1’-y2’), plot(y1’-y’,’r’);
title(’Ecart par rapport à ode de Scilab: bleu RK4, rouge RK4(3/8)’)
Chapitre 9
Les extensions

−
−
−
−
Scilab propose plusieurs façons de construire des fonctions écrites en d’autres langages (« C », Fortran,
« C++ », Java). Ces fonctions peuvent être appelées à partir de programmes selon plusieurs méthodes.
Matlab propose ce même type d’extension, avec les .mex.
Nous allons dans ce qui suit décrire les plus simples de ces méthodes.
9.1 Appel à l’aide de la fonction call

L’exemple qui suit est pris dans la documentation de Scilab. Une fonction Scilab, ishigami.sce,
appelle une fonction écrite en langage « C » (ishigami.c) à travers un call. Pour pouvoir engendrer le
binaire sous forme d’une bibliothèque dynamique, ainsi que le chargeur associé, des fonctions sont prévues
dans Scilab pour automatiser cette création. La commande ilib_for_link est chargée de tout ce travail.
Les différentes phases d’écriture sont les suivantes :
1. Comme on travaille en « C », il faut s’assurer que le « path » du système permet d’accéder aux
déclarations (.h) utilisées par le compilateur « C ». Sous Mac OS X, cela se fait en rajoutant, si ce
n’est déjà fait, la commande suivante :
export PATH=/usr/bin:$PATH
dans le fichier .profile.

2. On rééxécute ensuite le fichier .profile :
. ./.profile echo $PATH
3. Pour plus de clarté on crée un répertoire, ishigami, dans lequel on range la fonction en « C » :
#include <math.h>
void ishigami(int *nx, double *x, int *np, double *p, int *ny , double *y)
{
double a,b,s1,s2;
a = p[0]; b = p[1];
117
118 Chapitre 9 - Les extensions
s1 = sin(x[0]); s2 = sin(x[1]);
y[0] = s1 + a * s2 * s2 + b * x[2] * x[2] * x[2] * x[2] * s1;
}
4. puis la fonction Scilab d’appel ishigami.sci de la fonction précédente à l’aide d’un call :
function y = ishigami(x,p)
nx = size(x,"c");
np = size(p,"c");
ny = 1;
y = call("ishigami",nx ,1,"i",x ,2,"d",np ,3,"i" ,..
p ,4,"d",ny ,5,"i","out" ,[1,ny],6,"d");
endfunction
5. Construction des fichiers nécessaires au chargement de la librairie dynamique à l’aide de la com-

mande ilib_for_link("ishigami","ishigami.c",[],"c");
-->ilib_for_link("ishigami","ishigami.c",[],"c");
Génère un fichier loader
Génère un Makefile
ilib_gen_Make : Configure : Génère le Makefile.
ilib_gen_Make : Copie les fichiers de compilation (Makefile*, libtool...) vers TMPDIR
ilib_gen_Make : Copie ishigami.c vers TMPDIR
ilib_gen_Make : Modification du Makefile dans TMPDIR.
Exécute le Makefile
Génère un fichier cleaner
Le répertoire contient maintenant les fichiers :
!loader.sce !
!libishigami.dylib !
!ishigami.sci !
!ishigami.c !
!cleaner.sce !
dans lequel apparait la bibliothèque dynamique libishigami.dylib.

Scilab utilise un répertoire temporaire pour la construction des fichiers utilisés lors de la compilation
et de l’édition de liens (figure 9.1 ).
6. Chargement de la librairie dynamique : –>exec(’loader.sce’);. Ce chargement est fait par la

commande link que l’on trouve dans le script loader.sce :
// This file is released under the 3-clause BSD license. See COPYING-BSD.
// Generated by builder.sce : Please, do not edit this file
// ----------------------------------------------------------------------------
//
ishigami_path = get_absolute_file_path(’loader.sce’);
//
// ulink previous function with same name
[bOK, ilib] = c_link(’ishigami’);
if bOK then
ulink(ilib);
end
//
link(ishigami_path + ’libishigami’ + getdynlibext(), [’ishigami’],’c’);
// remove temp. variables on stack
clear ishigami_path;
clear bOK;
clear ilib;
// ----------------------------------------------------------------------------
Durant l’exécution on peut noter le chargement :

Figure 9.1 – Fichiers de travail dans TMPDIR
-->link(ishigami_path + ’libishigami’ + getdynlibext(), [’ishigami’],’c’);

Bibliothèque partagée chargée.
Édition de liens effectuée.
7. On peut maintenant tester l’appel à la fonction :
-->format (25), x = [1 2 3]; p = [7. 0.1]; y = ishigami(x,p)

y =
13.44513863477450144046
8. Un certain nombre de problèmes peuvent surgir lors de cette manipulation. En dehors des erreurs
habituelles de langage, il peut y avoir quelques difficultés avec les chemins d’accès définis dans $PATH
et avec les librairies installées pour la création des bibliothèques dynamiques. Ainsi, sur Mac OS
X, l’outil Xcode est maintenant installé dans le répertoire /Developer et les différentes librairies
et déclarations utiles dans des frameworks. Les chemins d’accès aux compilateurs, déclarations et
autres bibliothèques sont donc légèrement différents de ceux d’Unix et peuvent causer quelques
soucis...
9.2 Introduction à l’API

9.2.1 Exemple d’utilisation de l’API
L’interface de programmation (API) fournit toutes les fonctions permettant d’accéder aux paramètres
de l’appel à la fonction Scilab. L’exemple qui suit est pris dans la documentation (1) .
1. sci_ishigami.c effectue la récupération des arguments et appelle l’exécution de la fonction

ishigami.c :
#define __USE_DEPRECATED_STACK_FUNCTIONS__
# include "stdlib.h"
# include "stack-c.h"
# include "api_scilab.h"
(1). http://forge.scilab.org/index.php/p/docsciextensions/timeline/all/
# include "Scierror.h"
# include "localization.h"
// recuperation et verification des arguments
int sci_ishigami(char *fname);
void ishigami(int *nx,double *x,int *np,double *p,int *ny,double *y);
// y = ishigami ( x , p )
// Computes the Ishigami function
int sci_ishigami(char *fname) {
double *x;
double *p;
double *y;
int nRowsX,nColsX;
int nRowsP,nColsP;
int nRowsY,nColsY;
SciErr sciErr;
int *piAddr = NULL;
int iType = 0;
CheckRhs(2,2) ;
CheckLhs(0,1) ;
// Get 1st argument : x
sciErr = getVarAddressFromPosition(pvApiCtx,1,&piAddr);
if(sciErr.iErr) //========== verification
{ printError(&sciErr,0);
return 0; }
sciErr = getVarType(pvApiCtx,piAddr,&iType);
{ printError (&sciErr,0);
return 0; }
if(iType != sci_matrix) //========== verification
{ Scierror(204 ,_("%s: Wrong type for input argument #%d: Matrix expected .\n"),fname,1);
return 0; }
sciErr = getMatrixOfDouble(pvApiCtx,piAddr,&nRowsX,&nColsX,&x);
{ printError(&sciErr,0);
return 0; }
CheckDims(1,nRowsX,nColsX,1,3);
// Get 2nd argument : p
sciErr = getVarAddressFromPosition(pvApiCtx,2,&piAddr);
return 0; }
sciErr = getVarType(pvApiCtx,piAddr,&iType);
return 0; }
if(iType != sci_matrix) //========== verification
{ Scierror(204,_("%s: Wrong type for input argument #%d: Matrix expected.\n"),fname,2);
return 0; }
sciErr = getMatrixOfDouble(pvApiCtx,piAddr,&nRowsP,&nColsP,&p);
return 0; }
CheckDims(2,nRowsP,nColsP,1,2);
// Create output argument y in Scilab
nRowsY = 1;
nColsY = 1;
sciErr = allocMatrixOfDouble(pvApiCtx,Rhs+1,nRowsY,nColsY,&y);
return 0; }
// Compute y
ishigami(&nColsX,x,&nColsP,p,&nColsY,y);
// Let Scilab know that Rhs + 1 is the 1st (and only) output argument
LhsVar (1) = Rhs+1;
return 0;
}
// traitement effectif
void ishigami(int *nx,double *x,int *np,double *p,int *ny,double *y)
{
double a, b, s1 , s2;
a = p [0];
b = p [1];
s1=sin(x [0]);
s2=sin(x [1]);
y[0] = s1 + a*s2*s2 + b*x [2]* x [2]* x [2]* x [2]* s1;
}
La permière ligne, la directive #define __USE_DEPRECATED_STACK_FUNCTIONS__ indique que l’on

utilise des fonctions déclarées dans stack-c.h et qui sont, en principe, obsolètes. Il n’est pas toujours
très évident de savoir ce que l’on peut utiliser ou non. Cela dépend des versions, des sous-versions
et du développement éventuel d’outils nouveaux (on s’intéressera en particulier à l’outils ATOMS,
ensemble de fonctions qui permet de gérer le développement de nouvelles fonctions).
2. Constructeur builder.sce du module dans lequel la fonction tbx_build_gateway est chargée de
la compilation :
gateway_path = get_absolute_file_path("builder.sce");
libname = "ishigamigateway";
namelist = ["ishigami" "sci_ishigami"];
files = ["sci_ishigami.c"];
ldflags = ""; cflags = "";
libs = [];
tbx_build_gateway(libname,namelist,files,gateway_path,libs,ldflags,cflags);
clear tbx_build_gateway;
⋆ Prendre soin de rajouter cflags="" dans builder.sce (Mac OS seulement ?).

-->exec builder.sce
-->gateway_path = get_absolute_file_path("builder.sce");
-->libname = "ishigamigateway";
-->namelist = ["ishigami" "sci_ishigami"];
-->files = ["sci_ishigami.c"];
-->ldflags = ""; cflags = "";
-->libs = [];
-->tbx_build_gateway(libname,namelist,files,gateway_path,libs,ldflags,cflags);
Génère un fichier gateway
ilib_gen_Make : Copie libishigamigateway.c vers TMPDIR
ilib_gen_Make : Copie sci_ishigami.c vers TMPDIR
Exécute le makefile
-->clear tbx_build_gateway;
-->TMPDIR
TMPDIR =
/private/var/folders/T3/T3uNZ+-NF74VI8zuXVInHk+++TQ/-Tmp-/SCI_TMP_774_QwujBr
Figure 9.2 – Fichiers de travail dans TMPDIR
3. Chargement de la bibliothèque dynamique et exécution de l’appel :
-->exec loader.sce;
-->x = [1 2 3]; p = [7. 0.1];
-->y = ishigami(x,p)
-->exec loader.sce;
-->exec loader.sce;
-->x = [1 2 3]; p = [7. 0.1];
-->y = ishigami(x,p)
y =
13.445139
9.2.2 Utilisation des fonctions de l’API

Nous allons voir comment utiliser les fonctions de l’interface de programmation au travers d’un
exemple simple. On commence par créer un dossier nommé tstdatatype dans lequel sera stocké le
programme de test.
1. La structure générale du programme est la suivante :
#include <api_scilab.h>
int sci_mycheckrhs(char * fname)

{
CheckInputArgument(pvApiCtx, 2, 3); // min=2, max=3
CheckOutputArgument(pvApiCtx, 0, 1); // min=0, max=1
// Read input argument

// Perform some operations
// Return output argument
return 0;
}
On commence par tester le nombre de paramètres. En cas d’erreur le contrôle est rendu à Scilab.
Les appels :
CheckOutputArgument(void* _pvCtx, int iMin, int iMax)

CheckInputArgument(void* pvCtx, int iMin, int iMax)
remplacent CheckLhs et CheckRhs qui sont maintenant obsolètes (fonctions utilisées dans l’exemple
précédent).
2. On crée dans le dossier tstdatatype un dossier destiné à recevoir les fonctions que l’on construit à
l’aide de l’API. Celui-ci est nommé sci_gateway/c/ et on enregistre la fonction sci_mafonction.c
construite. Cette dernière teste, partiellement, le type de la donnée fournie en paramètre.
#include "api_scilab.h"
int sci_mafonction(char *fname,unsigned long fname_len)

{
SciErr sciErr;
int* piAddr = NULL;
int iType = 0;
int iRows = 0;
int iCols = 0;
CheckInputArgument(pvApiCtx, 1, 1); // un seul parametre en entree

//CheckOutputArgument(pvApiCtx, 0, 1); // rien en sortie
sciprint("\n\n");
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);

if(sciErr.iErr)
{
printError(&sciErr, 0);
return 0;
}
sciErr = getVarType(pvApiCtx, piAddr, &iType);

if(sciErr.iErr)
{
return 0;
}
sciprint("\tType: ");
switch(iType)
{
case sci_matrix :
sciprint("double\n");
break;
case sci_ints :
{
char pstSigned[] = "signed";
char pstUnsigned[] = "unsigned";
char* pstSign = pstSigned;
int iPrec = 0;
sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr, &iPrec);

if(sciErr.iErr)
{
return 0;
}
if(iPrec > 10)

{
pstSign = pstUnsigned;
}
sciprint("%s integer %d bits\n", pstSign, (iPrec % 10) * 8);
}
break;
case sci_strings :
sciprint("strings\n");
break;
default :
sciprint("Autre type\n");
return 0;
}
if(isVarComplex(pvApiCtx, piAddr))
{
sciprint("\tComplex: Yes\n");
}
sciprint("\tDimensions: ");
if(isVarMatrixType(pvApiCtx, piAddr))
{
sciErr = getVarDimension(pvApiCtx, piAddr, &iRows, &iCols);
if(sciErr.iErr)
{
return 0;
}
sciprint("%d x %d", iRows, iCols);
}
return 0;
}
3. La construction de la librairie dynamique se fait par exécution de la suite d’instructions :
files=["sci_mafonction.c"];
WITHOUT_AUTO_PUTLHSVAR = %t;
ilib_build(’build_lib’,[’mafonction’,’sci_mafonction’],files,[]);
Son exécution donne :
-->files=["sci_mafonction.c"];
-->WITHOUT_AUTO_PUTLHSVAR = %t;
-->ilib_build(’build_lib’,[’mafonction’,’sci\_mafonction’],files,[]);
Génère un fichier gateway
ilib_gen_Make : Copie libbuild_lib.c vers TMPDIR
ilib_gen_Make : Copie sci_mafonction.c vers TMPDIR
Exécute le makefile
4. On charge ensuite la librairie dynamique contenant la fonction à l’aide du loader construit par
ilib_for_link.
-->exec(’loader.sce’);
5. Si cela s’avère nécessaire utiliser cleaner.sce avant de relancer builder. Si l’on s’y prend mal on
peut avoir aussi à décharger la librairie libbuild_lib.dylib :
[bOK, ilib] = c_link(’libbuild\_lib’);

if bOK then, ulink(ilib); end
6. Si tout se passe bien, on obtient :
–>mafonction(2);
Type: double
Dimensions: 1 x 1
–>mafonction(’chaine’);
Type: strings
Dimensions: 1 x 1
Chapitre 10
Exercices divers
10.1 Divers
Exercice 10.1 (Projection sur un écran) (indications p. 154)
Le problème posé est celui de la représentation d’un objet « 3D » sur un écran. L’idée de départ consiste à
« projeter » l’objet sur un écran placé entre celui-ci et l’œil de l’observateur (figure 10.1 ).
P O
y
C Dr
x
Ds
Figure 10.1 – Projection conique sur le plan P
On choisit un système de référence et on suppose que l’écran est orthogonal à l’axe des x. Etant donné
un point M (xM , yM , zM ), le point projeté sur l’écran est P (xP , yP , zP ), avec xP = Dr − Ds . L’œil C de
l’observateur est en (Dr , 0, 0). On définit δ :
Ds
δ= ⇒ yP = δ × yM , zP = δ × zM
Dr − xM
Application : on considère un objet 3D défini par la fonction newimg. Celle-ci définit un filtre désigné
par DoG (Difference of Gaussians).
function [tx,ty,tz,xx,yy]=newimg()
ty = linspace (-8, 8, 21)’; tx = ty;
[xx, yy] = meshgrid (tx,ty);
zz=(-xx .^ 2 - yy .^ 2);
tz = exp(zz/4)/4-exp(zz/10)/10; // (DoG)
tz=40*tz;
endfunction
127
128 Chapitre 10 - Exercices divers
On ne cherche pas à obtenir une vue réaliste de l’objet. On se contentera de projeter les points qui le
définissent sans se soucier des « facettes » qui peuvent le composer.
1. Ecrire une fonction qui projette l’objet défini sur l’écran (figure 10.2 ). On prendra Dr = 20 et Ds = 12.
Son synopsis est le suivant :
function [pos2D,lm]=projconique(Ds,Dr,tb3N)
//!==================================================!
//! Dr = distance object reference origin - observer !
//! Ds = distance from the screen to the observer !
//! tb3N = array(3,1:N) [[x1;y1;z1],...,[xN;yN;zN]] !
//!==================================================!
y
x
Dr
Ds
Figure 10.2 – Construction de la projection
2. Plutôt que modifier les emplacements de l’observateur ou la position de l’écran, on se contente de

déplacer l’objet. Donner les trois matrices de rotation autour des trois axes en fonction des angles φx ,
φy et φz exprimés en degrés. Ecrire trois fonctions mettant en œuvre ces transformations. Prendre
comme description :
function vxp=rotx(vp,phix)
//!=========================================!
//! phix = rotation around x-axis (degrees) !
//! vp=(3,N)-matrix, vxp=(3,N)-matrix !
//!=========================================!
3. Ecrire un programme qui déplace l’objet 3D (rotation et translation) et projette son image sur l’écran.
10.2 Communications
Exercice 10.2 (Codage/décodage sur un canal de communication (indications p. 157))
Un canal de communication peut être représenté de façon très simplifiée par le schéma de la figure 10.3 . Le
codage de chaque symbole binaire bk donne un vecteur binaire sk émis sous forme de symboles +1 et −1 (s̃k ).
Au cours de la transmission ces symboles sont soumis à des perturbations modélisées par un bruit additif, nk .
+
+
Figure 10.3 – Exemple de canal de communication
Les bits reçus r̃k , remis en forme, sont transmis au décodeur pour correction des erreurs éventuelles... si
possible.
Codage convolutionnel non-récursif
Considérons le codeur schématisé figure 10.4 . Ce codeur est dit convolutionnel car il réalise, pour chaque
suite {sk (n)}, k = 1, 2, 3 la convolution de la suite bn par une suite {gk (n)}. Ici, {g0 (n)} = {1, 0, 0},
{g1 (n)} = {1, 0, 1} et {g2 (n)} = {1, 1, 1}.
Figure 10.4 – Exemple de « 1/3 rate convolutional non-recursive encoder ». Le

symbole ⊕ désigne un additionneur « modulo 2 ».
Le « train » de bits émis est de la forme {..., s2 (n − 1), s1 (n − 1), s0 (n − 1), s2 (n), s1 (n), s0 (n), ...}. Le
fonctionnement du codeur peut être représenté, entre autres, par un graphe d’état (figure 10.5 ).
bn-1bn-2 bnbn-1
bn/s2s1s0
bn/s2s1s0 00 0/000 00
0/000 1/111 1/111
00 10
10 0/110 10
1/011
0/100 1/001 1/001
1/011 0/110
1/101 11 01 11 1/101 11
0/010 0/100
0/010
01 01
Figure 10.5 – Fonctionnement du codeur : à gauche le graphe d’état (chaque

transition porte b(n)/(s2 s1 s0 )(n)), à droite une étape du codage
A chaque bit bn est associé un vecteur de trois bits s0 (n), s1 (n) et s2 (n). On a donc introduit de la
redondance pour pouvoir éventuellement corriger la suite reçue. On a quatre états dont on a choisi le codage
pour simplifier la programmation.
Décodage par « fonction majorité »
La séquence reçue est constituée de blocs de trois bits. Notons b(n|k) le bit reconstruit à l’instant n
connaissant les bits reçus r0 (k), r1 (k) et r2 (k). On peut écrire :

 bn|n = r0 (n)
b = r1 (n) + r2 (n)
 n−1|n
bn−2|n = r0 (n) + r1 (n)

 bn+1|n+1 = r0 (n + 1)
b = r1 (n + 1) + r2 (n + 1)
 n|n+1
bn−1|n+1 = r0 (n + 1) + r1 (n + 1)

 bn+2|n+2 = r0 (n + 2)
b = r1 (n + 2) + r2 (n + 2)
 n+1|n+2
bn|n+2 = r0 (n + 2) + r1 (n + 2)
z-1 z-1 z-1 z-1 z-1 z-1 z-1 z-1 z-1
fonction majorité
Figure 10.6 – Décodage de la séquence. bn|k est le bit reconstruit à l’aide de

r0 (k), r1 (k), ...
On utilise une fonction « majorité » pour obtenir le bit estimé b̂n :
b̂n = bn|n bn|n+1 + bn|n+1 bn|n+2 + bn|n+2 bn|n (10.1)
1. Ecrire un programme qui effectue la simulation du codeur décrit précédemment. On prendra une suite
aléatoire de bits {bk } engendrée par la fonction grand. Cette suite est ensuite codée. La suite d’entrée
et la suite résultante {sk } seront rangées dans un fichier appelé codedseq.sod.
2. Ecrire un programme qui « bruite » la suite {sk } (on choisira un taux d’erreur de l’ordre du 1 à 2 %)
puis effectue le décodage tel que décrit précédemment. Comparer les suites d’entrée et reconstruite.
Exercice 10.3 (Algorithme de Viterbi (indications p. 159)) Reprenons le codeur de l’exercice 10.2.
Partant de l’état (00), avec une suite d’entrée 0 1 1 0 1, on obtient une séquence émise 000 111 011 010 001
(figure 10.7 ).
0 1 1 0 1
a1a2 b0a1 b1b0 b2b1 b3b2 b4b3
r2r1r0
00 000 00 000 00 000 00 000 00 000 00
110 110 110
111 111 01 111 01 111 01 111 01

001 001 001
100 100 100 100
10 10 010 10 010 10 010 10
011
011 011 011
11 101 11 101 11 101 11
Figure 10.7 – Codage de la suite 0 1 1 0 1
En pratique, lorsque les séquences à coder sont très longues, on traite ces dernières par blocs. Ainsi, dans
le cas de la transmission de voix dans les téléphones utilisant la norme GSM (utilisée en particulier sur les
premiers téléphones portables), la taille des blocs est de 189 bits.
Supposons que la suite reçue soit 000 110 111 010 000 (correspondant au vecteur d’erreur 000 001 100
000 001). Partant de l’état initial que l’on s’est donné, on marque les états avec la distance de Hamming
minimale entre l’état courant et l’état initial et avec l’état précédent sur le chemin le plus court. Considérons
la figure 10.8 . On a noté A, B C, D les quatre états du codeur.
triplets reçus
a1a2 b0a1 b1b0 b2b1 b3b2 b4b3
000 110 111 010 000
A 00 000 00 000 00 000 00 000 00 000 00
r2r1r0
(0,A) (2,A) 110 (5,A) 110 (4,B) 110 (4,A)
B 111 111 01 111 01 111 01 111 01
(4,C) 001 (3,C) 001 (2,D) 001 (4,D)
100 100 100 100
C 10 10 010 10 010 10 010 10
(3,A) 011 (1,A) 011 (2,A) 011 (5,B) 011 (3,B)
D 11 101 11 101 11 101 11
(5,C) (2,C) (3,C) (5,D)
Figure 10.8 – Marquage des états
Partant de (0, 0), la distance entre le triplet reçu et le triplet porté sur la treillis est de 0 sur le chemin de
A à A et 3 sur le chemin de A à C. L’état précédent sur le chemin le plus court est A. On marque donc les
deux états A et C au deuxième pas avec (0, A) et (3, A) respectivement. On recommence au pas suivant. Le
triplet reçu est 110. On augmente les distances A → A de 2, A → C de 1, C → B de 1 et C → D de 2.
Les distances deviennent donc 2, 4, 1, 5 et l’état précédent sur le plus court chemin A, C, A, C. On itère le
procédé jusqu’à la fin de la séquence.
Arrivés au terme du traitement, tous les états du treillis sont marqués. On choisit au dernier pas l’état
dont la distance à l’état initial est le plus court (distance donnant le nombre d’erreurs trouvées) et il suffit de
remonter jusqu’à l’état initial en utilisant le marquage. On reconnait là un algorithme de recherche de plus
court chemin dans un graphe orienté.
Ecrire un programme effectuant une simulation du décodage de Viterbi tel que décrit dans ce paragraphe.
10.3 Méthode de Monte-Carlo

10.3.1 La méthode de Monte-Carlo pour le calcul d’une intégrale
Le calcul d’une intégrale peut être réalisé simplement
∫ xmax par la méthode de Monte-Carlo. Considérons
l’exemple de la figure 10.9 . On désire calculer I = xmin p(x)dx. La méthode consiste à tirer N points
(xi , yi ) de façon uniforme dans le rectangle délimité par xmin , xmax , ymin et ymax et à compter les Ns
points qui se trouvent « sous » p(x). La valeur de I est alors approximativement donnée par :
Ns
I≈ (ymax − ymin )(xmax − xmin ) + ymin (xmax − xmin ) (10.2)
N
Exemple 10.1 (Calcul d’intégrale) On désire calculer

∫ ∫
xmax 7/2 ( )
I= p(x)dx = 5 − 2x − x2 + x3 /2 dx (10.3)
xmin 1
On utilise la fonction de calcul de p(x) suivante :

function Px=myfuncx(x)
x2=x .* x; x3=x .* x2;
Px=5-2*x-x2+x3/2;
endfunction
et le programme de calcul de l’intégrale est le suivant :

//===== integfunc.sce
verbose=%f;
dx=.02; x=[0:dx:4]; px=myfuncx(x); plot(x,px);
xmin=1; xmax=3.5; x=[xmin:dx:xmax]; px=myfuncx(x);
13
12
11
10
9
8
7
6
5
4
3
2
1
0
0 0,5 1 1,5 2 2,5 3 3,5 4
Figure 10.9 – Exemple de calcul d’intégrale
Ith=5*(xmax-xmin)-(xmax^2-xmin^2)-(xmax^3-xmin^3)/3+(xmax^4-xmin^4)/8;
plot(x,px,’k’), set(gca(),’grid’,[1 1])
ymin=min(px); ymax=max(px);
plot([0 4],[ymin ymin],’-r’,[0 4],[ymax ymax],’-r’)
db=get(gca(),’data_bounds’); // = [0,-4;4,13]
plot([xmin xmin],[0 db(2,2)],’-r’)
plot([xmax xmax],[0 db(2,2)],’-r’)
//===== tirages
N=10000;
U=[xmin+(xmax-xmin)*grand(1,N,"def"); ymin+(ymax-ymin)*grand(1,N,"def")];
if verbose, plot(U(1,:),U(2,:),’.b’), end
x=U(1,:); px=myfuncx(x); y=U(2,:);
idx=find(y <= px); Ns=length(idx);
I=(Ns/N*(ymax-ymin)+ymin)*(xmax-xmin);
str=msprintf("Valeur = %10.7f, pour %10.7f",I,Ith)
disp(str)
Il y a une incertitude quant aux valeurs exactes de ymin , ymax , xmin et xmax (à cause du pas de calcul
pour la fonction et des erreurs, faibles, introduites dans le codage des valeurs).
10.3.2 Evaluation d’une espérance

Il n’est pas rare que le calcul d’une espérance mathématique doive être fait expérimentalement à
l’aide d’une moyenne empirique. Si les moyens informatiques dont on dispose permettent ce calcul dans
un grand nombre de cas, le problème n’est pas tant ce calcul que la confiance que l’on peut accorder au
résultat.
Le résultat général peut être exprimé de la façon qui suit. Etant donnée une variable aléatoire X,
supposée réelle et de variance finie (ce qui constitue une hypothèse importante), et X1 , ..., Xn des variables
aléatoires de même loi que X, nous notons m b N et σ
bN2
les estimées de la moyenne et de la variance :
( )
1 ∑ 1 ∑ 2
N N
bN
m = Xk et bN
σ 2
= Xk −m
b 2N (10.4)
N N
k=1 k=1
L’espérance E {X} est dans l’intervalle :

[ ]
bN
σ 2
bN
σ 2
∆= mb N − α −1/2 b N + β −1/2
,m , α ≥ 0, β ≥ 0 (10.5)
N N
avec la probabilité (asymptotiquement) :

∫ β ( 2)
1 t
√ exp − dt (10.6)
2π −α 2
La loi des grands nombres dit que, étant donné une suite {Yi } i.i.d., on a :
∫
1 ∑ n→∞
n +∞
Yi −→ E {Y1 } = yp(y)dy (10.7)
n i=1 −∞
Ici on fait un tirage d’une suite {ξi } i.i.d. et on suppose Yi = f (ξi ). On peut écrire :
∫ +∞
1 ∑
{ξi } → I = f (x)p(x)dx ≈ f (ξi ) (10.8)
−∞ N i
La procédure d’acceptation rejet permet de tirer les échantillons d’une loi donnée en utilisant une
loi auxiliaire. Cette méthode peut s’avérer plus efficace que le tirage direct à partir de la distribution
donnée. Une alternative est l’échantillonnage d’importance (IS pour Importance Sampling) qui effectue
un tirage suivant une loi auxiliaire et affecte des poids dépendant de la loi recherchée. Un avantage de
l’IS est que les échantillons de la distribution auxiliaire (on dit aussi instrumentale) peuvent être utilisés
pour différentes lois-cible.
Paradoxalement il peut ne pas être optimal de tirer les échantillons sous la vraie distribution. Nous
allons le voir dans la suite.
Exercice 10.4 (Calcul d’intégrale (indications p. 160))

On désire calculer :
∫ +∞ ∫ +∞
1
f (x)p(x)dx avec p(x) = √ e−x /2
2
I(α) = p(x)dx = (10.9)
α −∞ 2π
1. Ecrire un programme de calcul de I(α) utilisant la méthode de Monte-Carlo. On prendra n = 10 000
échantillons et plusieurs valeurs pour α (α = 1, 2, 3, 4). Comparer les résultats obtenus avec la vraie
valeur (voir les fonctions erf et erfc de Scilab).
A partir de L = 200 essais, afficher la dispersion des valeurs obtenues en utilisant la fonction myboxplot.
Celle-ci permet d’avoir une idée de la répartition des valeurs calculées. On y trouve la médiane des valeurs
et les limites des premier et troisième quartile q1 et q3 . Le paramètre w de la fonction donne ici les limites
q1 − w(q3 − q1 ) et q3 + w(q3 − q1 ).
function myboxplot(x,w)
x=gsort(x,’g’,’i’);
Lx=length(x); Q=round(Lx/4);
xm=median(x); [m,k]=min(abs(x-xm));
xLQ=x(max(1,k-Q)); xHQ=x(min(Lx,k+Q));
wH=xHQ + w*(xHQ - xLQ); wL=xLQ - w*(xHQ - xLQ);
plot([-1 +1],[xm xm],’r’)
plot([-4 +4],[xLQ xLQ],’:r’,[-1 +1],[xLQ xLQ],’b’)
plot([-4 +4],[xHQ xHQ],’:r’,[-1 +1],[xHQ xHQ],’b’)
plot([-1 -1],[xLQ xHQ],’b’,[1 1],[xLQ xHQ],’b’)
plot([-.5 +.5],[wH wH],’b’,[-.5 .5],[wL wL],’b’)
plot([0,0],[xHQ,wH],’b’,[0,0],[xLQ,wL],’b’)
plot([-4 +4],[wH wH],’:r’,[-4 +4],[wL wL],’:r’)
idxH=find(x>wH); idxL=find(x<wL);
if ~isempty(idxH), plot(zeros(1:length(idxH)),x(idxH),’xr’), end
if ~isempty(idxL), plot(zeros(1:length(idxL)),x(idxL),’xr’), end
set(gca(),’auto_ticks’,[’off’,’on’])
endfunction
2. L’expression du théorème central limite est la suivante :

√
n(In − I) −→ N (0, γ 2 ) avec γ 2 = var (f (X1 ))
n→+∞
Donner l’expression de γ 2 en fonction de I(α). On note ε = γ/I(α). Donner une interprétation de ε et

son expression en fonction de I(α). En déduire la raison pour laquelle la valeur de l’intégrale pour α = 4
est très difficile à approcher.
3. On considère une loi de Cauchy de « moyenne" 0 et d’étalement 1 (cette loi n’a ni moyenne ni variance
calculables) :
1 1 1 1
pX (x) = ⇒ F (x) = atan(x) + (10.10)
π 1 + x2 π 2
(a) Ecrire un programme qui construit une suite suivant la loi de Cauchy à partir d’une suite unifor-
mément répartie. Comparer histogramme et répartition théorique en superposant leurs tracés.
(b) Echantillonnage d’importance : si on sait simuler relativement à une loi q auxiliaire (instrumentale),
on sait simuler relativement à p. On peut en effet écrire :
∫ ∫
p(x)
f (x)p(x)dx = f (x) q(x)dx (10.11)
q(x)
où p/q est appelé rapport d’importance ou poids d’importance. Si le support de q contient le

support de p, on peut faire le calcul par :
∫
1 ∑ p(ξi )
f (x)p(x)dx ≈ f (ξi ) (10.12)
N q(ξi )
Ecrire un programme qui met en œuvre ce dernier calcul. Comparer avec la méthode de Monte-Carlo
directe (utiliser la fonction myboxplot).
10.4 Corde vibrante

10.4.1 Solution en temps continu
On suppose que la ligne est idéale (pas de pertes, parfaitement flexible, inextensible, etc.) et qu’il n’y
a pas de point de fixation. L’équation de mouvement est alors :
∂ 2 y(t, x) 1 ∂ 2 y(t, x)
2
= 2 (équation de d’Alembert) (10.13)
∂x c ∂t2
où 1/c2 = ρ/T avec ρ la masse linéïque et T une constante de tension. On suppose que les points évoluent
selon l’axe y seulement.
→
− −
→
Figure 10.10 – Chaque élément de corde est soumis aux forces T 1 et T 2
L’équation 10.13 peut être retrouvée de la façon suivante : comme il n’y a pas de mouvement selon
x, |T1 cos(α)| = |T2 cos(β)| = T . Selon y, le bilan des forces s’écrit :
∂ 2 y(t, x)
T2 sin(β) − T1 cos(α) = ρ∆x
∂t2
2
T2 sin(β) T1 cos(α) ρ∆x ∂ y(t, x)
⇒ − =
T T T ∂t2
ρ∆x ∂ 2 y(t, x)
⇒ tan(β) − tan(α) = (10.14)
T ∂t2
tan(β) − tan(α) apparaît comme la variation de la tangente ∂y/∂x entre x et x + ∆x, soit :
∂2y
tan(β) − tan(α) = ∆x (10.15)
∂x2
d’où l’équation 10.13.
La solution de cette équation est somme d’une onde yg (t, x) « se déplaçant » vers la « gauche » et
d’une onde yd (t, x) « se déplaçant » vers la « droite ». Ces deux ondes se déplacent à la vitesse c :
( x) ( x)
y(t, x) = yg t − + yd t + (10.16)
c c
On peut en effet vérifier que le changement de variable α = t − x
c et β = t + x
c conduit à l’équation :
∂ 2 yα,β ∂yα,β
= 0 ⇒ = cte = g(β)
∂α∂β ∂β
( x) ( x)
⇒ yα,β = G(β) + D(α) = yg t − + yd t +
c c
10.4.2 Simulation en temps discret

On effectue un échantillonnage spatial et un échantillonnage temporel. On pose tn = nTe et xm = mX.
A partir de 10.16, et en choisissant X = cTe , on obtient :
( ) ( )
mX mX
y(t, x) = yg nTe − + yd nTe + (10.17)
c c
= yg ((n − m)Te ) + yd ((n + m)Te ) (10.18)
Exercice 10.5 (Equation de d’Alembert (indications √ p. 162)) On se donne T = 5 newtons (kg m

s−2 ) et ρ = 50 grammes / mètre. On en déduit c = T /ρ = 10 m/s. Ecrire un programme qui affiche le
mouvement de la corde. Cette dernière est initialisée par (figure 10.11 ) :
//===== DoG initialization
xcmax=0.3; l2=round(xcmax/X);
xc=[-l2:l2]*X; Lxc=length(xc); xc2=xc .* xc;
sigma1=10*X; sigma2=15*X;
f1=a*exp(-xc2/sigma1/sigma1/2)/sigma1;
f2=a*exp(-xc2/sigma2/sigma2/2)/sigma2;
yd=f1-f2; yg=yd;
10
8
4
2
0
−2
−4
−0.3 −0.2 −0.1 0 0.1 0.2 0.3
Figure 10.11 – Différence de gaussiennes
L’onde de départ se partage en deux ondes identiques yd et yg . Le terme « DoG » signifie « différence de
gaussiennes ». Dans le cadre du traitement d’image un filtrage DoG est de type passe-bas, mais préserve mieux
les transitions qu’un filtre passe-bas simple.
Annexes
A.1 Rappels élémentaires sur les variables aléatoires

A.1.1 Définitions
Une variable aléatoire (v.a.) est une application qui associe à chaque épreuve possible d’une expérience
une valeur numérique.
D’un point de vue pratique, il est souvent suffisant de distinguer deux cas en fonction du type des
valeurs possibles de l’expérience aléatoire. Soit elles sont discrètes soit elles sont continues. Un exemple
du cas discret est donné par l’observation du nombre de personnes présentes dans une file d’attente : les
seules valeurs possibles sont les entiers positifs ou nuls. Par contre, le relevé de la vitesse des véhicules
sur une route fournit un exemple de v.a. continue : les valeurs possibles étant, cette fois-ci, les nombres
réels compris par exemple entre 0 et 130 km/h.
Définition A.1 Une v.a. X est dite discrète si l’ensemble des valeurs possibles est au plus dénombrable.
Si on note {a0 , . . . , an , . . .}, où n ∈ N, l’ensemble de ces valeurs, la loi de X est caractérisée par la
suite :
pX (n) = P {X = an } (A.1)
qui représente la probabilité pour que X soit égale à l’élément an . Ces valeurs vérifient 0 ≤ pX (n) ≤ 1 et
∑
n≥0 pX (n) = 1. On en déduit la probabilité pour que la v.a. X soit comprise entre a et b :
∑ ∑
P {X ∈]a, b]} = pX (n) = pX (n)1(an ∈]a, b])
n∈I n≥0
où I est l’ensemble des indices n tels que an soit compris entre a et b, ce qui s’écrit I = {n ≥
0 tel que an ∈]a, b]}. La fonction définie pour tout x ∈ R par :
∑
FX (x) = P {X ≤ x} = pX (n) (A.2)
{n:an ≤x}
est appelée la fonction de répartition de la v.a. X. Elle est monotone croissante et vérifie FX (−∞) = 0
et FX (+∞) = 1. Elle se présente (voir figure A.1) comme une fonction en « marches d’escalier » dont
les sauts, situés aux points d’abscisse an , ont une hauteur égale à l’amplitude pX (n).
Définition A.2 soit X et Y deux v.a. discrètes à valeurs dans {a0 . . . an . . . } et {b0 . . . bk . . . } respec-
tivement. La loi de probabilité conjointe est donnée par la suite des quantités positives :
pXY (n, k) = P {X = an , Y = bk } (A.3)

∑ ∑
avec 0 ≤ pXY (n, k) ≤ 1 et n≥0 k≥0 pXY (n, k) = 1.
P {X = an , Y = bk } représente la probabilité pour que l’on ait simultanément X = an et Y = bk .

Cette définition s’étend sans difficulté au cas d’un nombre fini de v.a.
137
138 Annexes
FX(x)
1
U
pX(2)
pX(1)
pX(0) x
a0 a1 0 a2 a3
Figure A.1 – Fonction de répartition d’une variable aléatoire discrète
Propriété A.1 Soit X et Y deux v.a. discrètes à valeurs respectivement dans {a0 . . . an . . .} et
{b0 . . . bk . . .} et dont la loi de probabilité conjointe est caractérisée par pXY (n, k). On a :
∑
+∞
pX (n) = P {X = an } = pXY (n, k) (A.4)
k=0
∑
+∞
pY (k) = P {Y = bk } = pXY (n, k) (A.5)
n=0
On désigne pX (n) et pY (k) par les termes de loi marginale de X et loi marginale de Y respectivement.
Définition A.3 On dit qu’une v.a. X est continue si elle prend ses valeurs dans R et si, quels que soient
a et b, la probabilité pour X d’appartenir à l’intervalle ]a, b] s’écrit :
∫ b
P {X ∈]a, b]} = pX (x)dx (A.6)
a
∫ +∞
où pX (x) est une fonction positive ou nulle (pas nécessairement inférieure à 1) qui vérifie −∞ pX (x)dx =
1. pX (x) s’appelle la densité de probabilité de la loi de X. La fonction définie pour tout x ∈ R par :
∫ x
FX (x) = P {X ≤ x} = pX (u)du (A.7)
−∞
est appelée la fonction de répartition de la variable aléatoire X. Elle est monotone croissante et vérifie
FX (−∞) = 0 et FX (+∞) = 1. On note que pX (x) représente aussi la dérivée de FX (x) par rapport à x.
Définition A.4 soit X et Y deux v.a. à valeurs dans R × R. Elles sont dites continues si, quel que soit
le domaine ∆ de R2 , la probabilité pour le couple (X, Y ) d’appartenir à ∆ est donnée par :
∫∫
P {(X, Y ) ∈ ∆} = pXY (x, y)dxdy (A.8)
∆
où la fonction pXY (x, y) est positive ou nulle et vérifie :

∫∫
pXY (x, y)dxdy = 1
R2
pXY (x, y) s’appelle la densité de probabilité de la loi conjointe du couple (X, Y ).
Propriété A.2 Soit X et Y deux v.a. continues dont la loi de probabilité conjointe est caractérisée par
pXY (x, y). Alors les lois de X et de Y ont pour densités de probabilité marginales :
∫ +∞
pX (x) = pXY (x, y)dy (A.9)
−∞
∫ +∞
pY (y) = pXY (x, y)dx (A.10)
−∞
On désigne respectivement pX (x) et pY (y) par les termes de densités de probabilité marginale de X
et de Y .
Un cas particulier où interviennent deux v.a. réelles (X, Y ) est celui d’une v.a. complexe Z = X = jY .
On peut aussi avoir le cas mixte où l’une des deux variables aléatoires est discrète et l’autre continue,
ce qui conduit à la définition qui suit.
Définition A.5 Soit X une v.a. à valeurs dans {a0 . . . an . . .} et Y une variable aléatoire à valeurs dans
R. Alors, quels que soient an d’une part et a et b d’autre part, la probabilité :
∫ b
P {X = an , Y ∈]a, b]} = pXY (n, y)dy (A.11)
a
∑ ∫
où la fonction pXY (n, y), n ∈ {0 . . . k . . .}, y ∈ R, est positive ou nulle et vérifie n≥0 R pXY (n, y)dy = 1.
Définition A.6 On dit que les v.a. X et Y sont indépendantes si et seulement si la loi conjointe est le
produit des lois marginales. Cela s’écrit (en nous limitant aux cas précédents) :
− pour deux v.a. discrètes :
pXY (n, k) = pX (n)pY (k)
− pour deux v.a. continues :
pXY (x, y) = pX (x)pY (y)
− pour deux v.a. mixtes :
pXY (n, y) = pX (n)pY (y)
où les lois marginales sont obtenues à partir des formules A.4, A.5, A.9 et A.10.
Insistons sur le fait que, connaissant pXY (x, y), on peut répondre à la question de savoir si X et Y
sont ou non indépendantes. Il suffit de calculer les lois marginales et de vérifier si l’on a pXY (x, y) =
pX (x)pY (y). Si c’est le cas, X et Y sont indépendantes.
De façon plus générale, on a la définition suivante :
Définition A.7 on dit que les v.a. (X1 , . . . , Xn ) sont indépendantes dans leur ensemble si et seulement
si leur loi de probabilité conjointe est le produit des lois marginales. Ceci s’écrit :
pX1 X2 ···Xn (x1 , x2 , . . . , xn ) = pX1 (x1 )pX2 (x2 ) . . . pXn (xn ) (A.12)
où les lois marginales s’obtiennent comme les intégrales de dimension (n − 1) calculées à partir de
pX1 X2 ...Xn (x1 , x2 , . . . , xn ).
Par exemple la loi marginale de X1 a pour expression :

∫ ∫
pX1 (x1 ) = . . . pX1 X2 ...Xn (x1 , x2 , . . . , xn )dx2 . . . dxn
| {z }
Rn−1
En pratique le résultat qui suit nous donne le moyen de vérifier simplement l’indépendance de v.a. :
Si pX1 X2 ...Xn (x1 , x2 , . . . , xn ) est un produit de n fonctions positives de la forme f1 (x1 )f2 (x2 ) . . . fn (xn ),
alors les variables sont indépendantes.
⋆ Attention, si n v.a. sont indépendantes deux à deux, cela n’implique pas nécessairement qu’elles
soient indépendantes dans leur ensemble.
140 Annexes
A.1.2 Moments et fonction caractéristique

Définition A.8 Soit X une v.a. et f (x) une fonction. On appelle espérance mathématique de f (X)
(resp. f (X, Y )) la quantité, notée E {f (X)} (resp. E {f (X, Y )}), définie :
− pour une v.a. discrète, par :

∑
E {f (X)} = f (an )pX (n)
n≥0
− pour une v.a. continue, par :

∫
E {f (X)} = f (x)pX (x)dx
R
− pour deux v.a. discrètes, par :

∑∑
E {f (X, Y )} = f (an , bk )pXY (n, k)
n≥0 k≥0
− pour deux v.a. continues, par :

∫∫
E {f (X, Y )} = f (x, y)pXY (x, y)dxdy
R R
Remarque : si X1 , X2 , . . ., Xn sont indépendantes, et si f1 , f2 , . . ., fn désignent n fonctions inté-

grables, alors :
{ n }
∏ ∏
n
E fk (Xk ) = E {fk (Xk )} (A.13)
k=1 k=1
Définition A.9 On appelle fonction caractéristique de la loi de probabilité des v.a. X1 , . . ., Xn , la

fonction de (u1 , . . . , un ) ∈ Rn définie par :
{ n }
{ ju1 X1 +···+jun Xn } ∏
ϕX1 ···Xn (u1 , · · · , un ) = E e =E ejuk Xk
(A.14)
k=1

Du fait que ejuX = 1, la fonction caractéristique existe et est continue même si les moments n’existent
pas. Exemple : la loi de Cauchy, dont la densité de probabilité est pX (x) = 1/π(1 + x2 ), ne possède aucun
moment et a pour fonction caractéristique e−|u| . On note que |ϕX1 ···Xn (u1 , · · · , un )| ≤ ϕX (0, · · · , 0) = 1.
Théorème A.1.1 (Théorème fondamental)

(X1 , · · · , Xn ) sont indépendantes si et seulement si, en tout point (u1 , u2 , . . . , un ) de Rn :
∏
n
ϕX1 ···Xn (u1 , · · · , un ) = ϕXk (uk )
k=1
Notons que la fonction caractéristique {ϕXk (uk}) de la loi marginale de Xk se calcule directement à
partir de A.14. En effet on a ϕXk (uk ) = E ejuk Xk = ϕX1 ···Xn (0, · · · , 0, uk , 0, · · · , 0).
Exemple A.1 (Premiers calculs)

} dans {0, 1} avec P {X = 0} = p0 ≥ 0, P {X = 1} = p1 ≥ 0 et p0 + p1 = 1.
Soit X une v.a. à {valeurs
Calculer E {X}, E X 2 , E {cos(πX)} et ϕX (u).
Indications : il vient :
{ }
E {X} = 0 × p0 + 1 × p1 = p1 et E X 2 = 02 × p0 + 12 × p1 = p1
puis :
E {cos(πX)} = cos(0) × p0 + cos(π) × p1 = p0 − p1
enfin :
ϕX (u) = p0 eju×0 + p1 eju×1 = p0 + p1 eju
Définition A.10 on appelle moment d’ordre n l’espérance mathématique de la fonction f (x) = xn .
Définition A.11 on appelle moyenne de la v.a. X le moment d’ordre 1 à savoir E {X}. Si la moyenne
est nulle on dit que la v.a. est centrée. On appelle variance de la v.a. X la quantité positive définie par :
{ } { }
var (X) = E (X − E {X})2 = E X 2 − (E {X})2
Sa racine carrée est appelée l’écart-type.
L’écart-type s’interprète comme la mesure des fluctuations de la variable aléatoire autour de sa

moyenne : plus elle est grande, plus les valeurs de X sont dispersées autour de E {X}. Ceci est pré-
cisé par la propriété qui suit :
Propriété A.3 Soit X une v.a. de moyenne E {X} et de variance var (X). Alors ∀δ > 0 :
P {|X − E {X} | ≥ δ} = P {E {X} − δ ≤ X ≤ E {X} + δ}

var (X)
≤ (A.15)
δ2
L’inégalité A.15 signifie que la probabilité pour que X s’écarte de sa moyenne de ±δ est donc d’autant
plus petite que la variance est petite.
A titre d’exercice, montrons que, quelles que soient les constantes a et b :
{
E {aX + b} = aE {X} + b
(A.16)
var (aX + b) = a2 var (X)
En effet {A.16 est une conséquence
} directe de la linéarité de l’intégrale. Posons{ Y = aX + b, alors
}
var (Y ) = E (Y − E {Y })2 . En portant E {Y } = aE {X} + b, il vient var (Y ) = E a2 (X − E {X})2 =
a2 var (X).
Une généralisation de ces deux résultats à des vecteurs aléatoires (les composantes sont des variables
aléatoires), sera donnée par la propriété A.5.
Définition A.12 Soit (X, Y ) (1) deux v.a., on appelle covariance entre X et Y la quantité définie par :
cov(X, Y ) = E {(X − E {X})(Y ∗ − E {Y ∗ })} (A.17)

= E {XY ∗ } − E {X} E {Y ∗ }
On dit que X et Y ne sont pas corrélées si cov(X, Y ) = 0 soit encore E {XY ∗ } = E {X} E {Y ∗ }. On
appelle coefficient de corrélation la quantité définie par :
cov(X, Y )
ρ(X, Y ) = √ √ (A.18)
var (X) var (Y )
L’application de l’inégalité de Schwarz entraîne que −1 ≤ ρ(X, Y ) ≤ 1.
(1). Sauf cas particulier, les variables aléatoires considérées dans la suite sont réelles. Toutefois les définitions concernant
la moyenne et la covariance se généralisent sans exception en considérant une v.a. complexe et en conjuguant la deuxième
variable. C’est ce que nous indiquons par une étoile (∗) dans le cas scalaire et par l’exposant H dans le cas vectoriel.
142 Annexes
Définition A.13 Soit {X1 , . . ., Xn } n v.a. de moyennes respectives E {Xi }. On appelle vecteur moyenne
le vecteur de dimension n dont les composantes sont les moyennes E {Xi }. On appelle matrice de cova-
riance la matrice C de dimension n × n dont l’élément générateur est Cij = cov(Xi , Xj ) pour 1 ≤ i ≤ n
et 1 ≤ j ≤ n.
Notation matricielle : si on note :

 
X1
 .. 
X= . 
Xn
le vecteur aléatoire dont les n composantes sont les variables aléatoires Xk , le vecteur-moyenne s’écrit :
 
E {X1 }
 
E {X} =  ... 
E {Xn }
et la matrice de covariance :
{ } { }
H
C = E (X − E {X})(X − E {X})H = E XX H − E {X} E {X} (A.19)
Notons que les éléments diagonaux d’une matrice de covariance représentent les variances respectives des
n v.a. ; ils sont donc positifs. Si les n v.a. ne sont pas corrélées, leur matrice de covariance est diagonale.
Propriété A.4 Toute matrice de covariance est positive, ce qui signifie que, quel que soit le vecteur a,
on a aH Ca ≥ 0.
∑N { 2}
En effet considérons la v.a. Y = k=1 ak (Xk − E {Xk }). On a bien entendu
{ 2 } E |Y | ≥ 0 (en tant
qu’espérance mathématique d’une v.a. positive). Exprimons maintenant E |Y | . Il vient :
{N }
{ 2} ∑ ∑
N
∗ ∗
E |Y | = E ak (Xk − E {Xk }) am (Xm − E {Xm })
k=1 m=1
∑
N ∑
N
= ak E {(Xk − E {Xk })(Xm − E {Xm })∗ } a∗m
k=1 m=1
∑
N ∑
N
= ak ck,m a∗m = aH Ca ≥ 0
k=1 m=1
Propriété A.5 Soit {X1 , . . . , Xn } n v.a. de vecteur moyenne E {X} et de matrice de covariance C X et
soit {Y1 , . . . , Yq } q v.a. obtenues par la transformation linéaire :
   
Y1 X1
 ..   .. 
 .  = A .  + b
Yq Xn
où A et b sont respectivement une matrice et un vecteur non aléatoires de dimension ad hoc. Alors :
E {Y } = AE {X} + b
CY = AC X AH
La première expression est une conséquence directe de la linéarité de l’intégrale. On en déduit que
Y − E {Y } = A(X − E {X}). Etablissons la deuxième expression :
{ }
C Y = E (Y − E {Y })(Y − E {Y })H
{ }
= AE (X − E {X})(X − E {X})H AH = AC X AH
Définition A.14 Soit {X1 , . . . , Xn } n v.a.. On dit qu’elles forment une suite blanche si var (Xi ) = σ 2
et si cov(Xi , Xj ) = 0 pour i ̸= j. Leur matrice de covariance s’écrit donc :
C = σ2 I n
où I n est la matrice identité n × n.
Propriété A.6 Si les variables aléatoires {X1 , . . . , Xn } sont indépendantes, elles ne sont pas corrélées
et donc leur matrice de covariance est diagonale. En général la réciproque est fausse.
A.2 Quelques indications sur les exercices

A.2.1 Exercices dans le corps du texte
A.2.1 (Méthode de Jacobi) (texte p. 43)
function [x,rho,k]=jacobimethod(A,b,x0,stcr0,maxit)
//=================================================!
// [x,rho,eltime]=JACOBIMETHOD(A,b,x0,stcr0,maxit) !
// Systeme Ax+b !
// x0 = initial state !
// stcr0 = critere d’arret |x(n+1)-x(n)|>stcr0 !
// maxit = max. iteration number !
// x = solution of Ax=b !
// rho = spectral radius !
// k = loop number !
//=================================================!
n=size(A,1);
U=-triu(A,1); L=-tril(A,-1); N=U+L;
D=diag(A); Dm1=1 ./ D; Mm1=diag(Dm1);
rho=max(abs(spec(Mm1*N)));
if rho>=1 then error(’the method is not convergent’); end
//===== loop
x=x0; stcr=1; k=0;
while stcr>stcr0 & k<maxit
xp=(N*x+b).*Dm1;
stcr=max(abs(xp-x));
x=xp; k=k+1;
end
endfunction
-->a=1/4; A=[1 a a;a 1 a;a a 1]; b=[1;2;3]; stcr0=%eps; maxit=200;
-->[x,rho,k]=jacobimethod(A,b,x0,stcr0,maxit)
k =
53.
rho =
0.5
x =
0.
1.3333333
2.6666667
-->A*x
ans =
1.
2.
3.
La vitesse de convergence est définie par la plus grande valeur propre (en module) :
144 Annexes
-->U=-triu(A,1); L=-tril(A,-1); N=U+L;
-->D=diag(A); Dm1=1 ./ D; Mm1=diag(Dm1);
-->rho=max(abs(spec(Mm1*N)));
-->format(’v’,17); [rho^53; %eps; rho^52]

ans =
10^(-15) *
0.11102230246252
0.22204460492503
0.22204460492503
A.2.2 (Méthode de Cholesky et factorisation) (texte p. 44)
Appel de la fonction :
//===== tstCHOfact.sce =====

A=rand(4,4,’uniform’); A=A*A’;
N0=size(A,1); L=[];
L=CHOfact(A,L,N0);
disp(A,L*L’)
Fonction :
function L=CHOfact(A,L,N0)
//===== CHOfact.sci ===========================!
// LUREC stores in L a lower triangular matrix !
// so that A=L*L^H (Cholesky factorization) !
// with A hermitian definite positive !
//=============================================!
// SYNOPSIS: L=CHOFACT(A,L,N0) !
// N0=size(A,1) !
// A = symmetric definite positive !
// L = used as an input allows !
// the recursivity (initial value []) !
// EXAMPLE: A=rand(4,4,’normal’); A=A*A.’; !
// N0=size(A,1); L=[]; !
// L=CHOfact(A,L,N0); !
//=============================================!
N=size(A,1); if N==0, return, end
Lp=zeros(N,1); Lp(1)=sqrt(A(1,1));
Lp(2:N)=A(2:N,1)/Lp(1); vec=Lp(2:N);
L=[L,[zeros(N0-N,1);Lp]];
B=A(2:N,2:N)-(vec * vec’);
L=CHOfact(B,L,N0);
endfunction
A.2.3 (Opérateurs logiques) (texte p. 44)
1. le « OU » est donné par la fonction max :
//===== opelog1.sce
N=4; // dimensions des vecteurs v1 et v2
v1=grand(N,1,"uin",0,1);
v2=grand(N,1,"uin",0,1);
x=max(v1 .* v2); // attention: ce n’est pas un produit scalaire
xlog=x==1;
disp([v1,v2]), disp(x), disp([v1==1,v2==1]), disp(xlog)
2. avec des booléens :

//===== opelog2.sce
N=4; // dimensions des vecteurs v1 et v2
v1=grand(N,1,"uin",0,1); v1=v1==1;
v2=grand(N,1,"uin",0,1); v2=v2==1;
x=or(v1 & v2);
disp([v1,v2]), disp(x)
3. produit de matrices :
function C=boolmatrixmul(A,B)
[nla,nca]=size(A); [nlb,ncb]=size(B);
C=zeros(nla,ncb); C=C==0;
for ml=1:nla
for mc=1:ncb
C(ml,mc)=or(A(ml,:)’ & B(:,mc));
end
end
endfunction
-->A=[%t %f %t;%f %f %f;%t %t %t], B=[%t %f;%f %t;%t %t]

A =
T F T
F F F
T T T
B =
T F
F T
T T
-->funcprot(0), getd(), C=boolmatrixmul(A,B)
ans =
1.
C =
T T
F F
T T
A.2.4 (Coloriage) (texte p. 45)

Programme principal :
//===== tstng.sce =====
clear
verbose=%f;
funcprot(0); getd()
nbc=10; nbr=12; cc=6; cr=3;
nbf=1;scf(nbf); clf;
plot([1 1 nbc nbc],[1 nbr nbr 1],’.’)
//========== test sur une pseudo image
pixc=ones(nbr,nbc); pixc(3:8,2:6)=0; pixc(3:8,2:6)=0; pixc(9:12,6:7)=0;
[idl0,idc0]=find(pixc==0); [idl1,idc1]=find(pixc==1); pixc0=pixc;
plot(idc0,idl0,’or’), plot(idc1,idl1,’x’), plot(cc,cr,’*r’)
set(gca(),’axes_reverse’,["off","on","off"])
valc0=3; valc=pixc(cr,cc);
pixc=colorfill(pixc,cr,cc,nbr,nbc,valc,valc0,verbose,nbf);
if ~(verbose) then
disp(pixc0), disp(pixc)
//========== avec une image
scf(2);
146 Annexes
aa=gca(); aa.data_bounds=[0 0;2*nbc+1 nbr+1]; aa.box=’on’;

Matplot1(pixc0+1,[1 1 nbc nbr])
Matplot1(pixc+1,[nbc+1 1 2*nbc nbr])
end
valc est la valeur lue au point cc=6; cr=3;, soit 0. Chaque zéro de la zone « connexe » est ensuite
remplacé par un « trois » (valc0).
Fonction de coloriage :
function pixcs=colorfill(pixc,cr,cc,nbr,nbc,valc,valc0,verbose,nbf)
pixc(cr,cc)=valc0; pixcs=pixc;
ng=neighbours(cr,cc,nbr,nbc);
indng=ng(:,1)+(ng(:,2)-1)*nbr; pv=pixc(indng); // pixels voisins
idx=find(pv==valc); // voisins de meme couleur
if verbose
scf(1); plot(cc,cr,’*b’), xpause(100000)
end
if isempty(idx) then return, end
for n=1:length(idx)
k=idx(n); alpha=fix((indng(k)-1)/nbr); cc=alpha+1;
cr=indng(k)-nbr*alpha;
pixcs=colorfill(pixc,cr,cc,nbr,nbc,valc,valc0,verbose,nbf);
pixc=pixcs;
end
endfunction
Détermination des voisins d’un point :

function ng=neighbours(cr,cc,nbr,nbc)
vbool=[(cr==1)&(cc==1); (cr==1)&(cc==nbc);...
(cr==nbr)&(cc==1); (cr==nbr)&(cc==nbc);...
(cr==1)&(1<cc)&(cc<nbc); (cr==nbr)&(1<cc)&(cc<nbc);...
(1<cr)&(cr<nbr)&(cc==1); (1<cr)&(cr<nbr)&(cc==nbc)];
idx=find(vbool);
if isempty(idx) then idx=9; end
//=====
select idx
case 1 then
ng=[1,2; 2,2; 2,1]; // HG
case 2 then
ng=[1,nbc-1; 2,nbc-1; 2,nbc]; //HD
case 3 then
ng=[nbr-1,1; nbr-1,2; nbr,2]; //BG
case 4 then
ng=[nbr,nbc-1; nbr-1,nbc-1; nbr-1,nbc]; //BD
case 5 then
ng=[1,cc-1; 2,cc-1;2,cc; 2,cc+1; 1,cc+1]; //H
case 6 then
ng=[nbr,cc-1; nbr-1,cc-1;nbr-1,cc; nbr-1,cc+1; nbr,cc+1]; //B
case 7 then
ng=[cr-1,1; cr-1,2;cr,2; cr+1,2; cr+1,1]; //G
case 8 then
ng=[cr-1,nbc; cr-1,nbc-1;cr,nbc-1; cr+1,nbc-1; cr+1,nbc]; //D
case 9 then
ng=[cr-1,cc; cr-1,cc-1;cr,cc-1; cr+1,cc-1; cr+1,cc;..
cr+1,cc+1;cr,cc+1; cr-1,cc+1;];
else
ng=0;
end
endfunction
A.2.5 (Loi de Poisson) (texte p. 85)
1. La moyenne est donnée par

∑+∞ k
E {X} = k=0 ke−a ak! = a
{ }
et la variance par var (X) = E X 2 − E2 {X}. On part de E {X(X − 1)} :
∑+∞ ∑+∞ k ∑+∞ k−2
E {X(X − 1)} = k=0 kpX (k) = k=0 k(k − 1)e−a ak! = k=0 e−a a2 (k−2)!
a
= a2
{ }
on déduit que E X 2 = E {X(X − 1)} + E {X} = a2 + a. Par conséquent, var (X) = a.
2. FX (k) = Pr (X ≤ k) s’écrit FX (k) = FX (k − 1) + pX (k) et, pour éviter le calcul de la fonction
factorielle, on utilise pour calculer pX (k) la forme récurrente pX (k) = apX (k − 1)/k.
3. Pour engendrer une variable de Poisson de paramètre a, on peut procéder de la façon suivante :
(a) engendrer la suite U par U = rand(1,N,’uniform’) en notant la valeur maximale Umax ;
(b) construire le tableau des probabilités cumulées FX (k) = Pr (X ≤ k) inférieures à Umax ;
(c) déterminer, pour chaque U (k), le plus grand entier X(k) tel que FX (X(k)) ≤ U (k). On peut
utiliser find((X>=λ)&(X<µ)) qui extrait les indices des valeurs de X comprises entre λ et µ.
0
1 2 3
Figure A.2 – Construction des tirages à partir de FX (k)
//===== Cpoisson.sce
clear, clf
//===== echantillon de loi uniforme
N=2000; U=rand(1,N,’uniform’); Umax=max(U);
//===== Construction fonction de repartition
a=5; pX(1)=exp(-a); // proba(X=0)
FX(1)=pX(1); k=1;
while ((FX(k)<Umax)&(k<N))
pX(k+1)=a * pX(k) / k; // calcul de pX(x)
FX(k+1)=FX(k) + pX(k+1); k=k+1;
end
nmax=k;
//===== Generation de X
X=zeros(1,N);
for n=1:nmax-1, ind=find((FX(n)<=U)&(U<FX(n+1))); X(ind)=n; end
//===== Valeurs extremes
ind=find(U<FX(1)); X(ind)=zeros(1,length(ind));
ind=find(U>=FX(nmax)); lind=length(ind);
X(ind)=nmax * ones(1,length(ind));
//===== Verification
subplot(211), plot(FX,’o’), set(gca(),’grid’,[1 1])
//===== Estimation de pX
for k=0:nmax-1, pXe(k+1)=length(find(X==k))/N; end
subplot(212), plot((0:nmax-1),pXe,’o’), set(gca(),’grid’,[1 1])
plot((0:nmax-1),pX,’:’,(0:nmax-1),pX,’xr’)
A.2.6 (Loi exponentielle) (texte p. 85)

148 Annexes
0,8
0,6
0,4
0,2
0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
0,15
0,1
0,05
0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Figure A.3 – Fonction de répartition et densités de probabilité théorique et

estimée à partir de l’échantillon construit
∫ +∞ { }
1. En intégrant par parties, on trouve E {X} = λ 0
xe−λx dx = 1/λ. De même E X 2 = 2/λ2 . Et
donc var(X) = 1/λ2 .
∫x
2. La fonction de répartition de X a pour expression u = 0 λe−λt dt = 1 − e−λx . En « inversant" on
obtient x = − log(1−u)/λ. Par conséquent la variable X = − log(1−U )/λ suit une loi exponentielle
si U suit une loi uniforme sur (0, 1). Comme U et (1 − U ) ont même loi, on peut aussi prendre tout
simplement X = − log(U )/λ.
3. Le pas lk, pour estimer la densité de probabilité, est déterminé à partir de la moyenne.
Taper (figure A.4) :

//===== loiexp.sce
clear; getd(), clf
N=3000; lambda=2; Nc=15; U=rand(N,1,’uniform’); X=-log(U)/lambda;
moyX=1/lambda; lk=moyX/Nc; maxx=max(X);
[nn,xx]=myhist(Nc,X,%t,%t);
//===== Loi exponentielle theorique
pointsx=linspace(0,maxx,Nc+1);
pth=lambda*exp(-lambda*pointsx); plot(pointsx,pth,’r’)
1,6
1,2
0,8
0,4
0
0 0,5 1 1,5 2 2,5 3 3,5 4 4,5 5
Figure A.4 – Loi exponentielle et histogramme

A.2.7 (Loi de Rayleigh) (texte p. 85)
1. On a :
∫ +∞ ( ) ∫ +∞ ( ) √
x2 x2 x2 π
E {X} = exp − dx = exp − dx = σ
0 σ2 2σ 2 0 2σ 2 2
2. Il vient :
∫ x ( ) ( )
t t2 x2
u= exp − 2 dt = 1 − exp − 2
0 σ2 2σ 2σ
√
En résolvant par rapport √ à x, on obtient x = σ −2 log(1 − u). Par conséquent, si U suit une loi
uniforme sur (0, 1), X = σ −2 log(1 − U )√suit une loi de Rayleigh. Comme U et 1 − U ont la même
loi, il revient au même de prendre X = σ −2 log(U ).
3. Taper le programme :
//===== Crayleigh.sce
clear; clf, getd()
N=3000; U=rand(1,N); X=sqrt(-2*log(U));
//===== histogramme
Nc=20; [ni,xcc]=myhist(Nc,X,%t,%t);
//===== Loi de Rayleigh theorique
lk=(max(X)-min(X))/Nc; maxx=max(X);
pointsx=(0:lk:maxx); pth=pointsx .* exp(-pointsx .* pointsx /2);
plot(pointsx,pth,’-r’); set(gca(),’grid’,[1 1])
La figure A.5 montre la courbe théorique d’une densité de probabilité d’une loi de Rayleigh et
l’histogramme des valeurs obtenues par le générateur.
0,6
0,5
0,4
0,3
0,2
0,1
0
0 0,5 1 1,5 2 2,5 3 3,5 4
Figure A.5 – Loi de Rayleigh : densité de probabilité (trait continu) et histo-

gramme de l’échantillon simulé de longueur 3000 (◦)
A.2.8 (Loi de Bernoulli) (texte p. 85)
{ }
1. E {Bn } = 1 × Pr(Bn = 1) + 0 × Pr(Bn = 0) = p. De même E Bn2 = p et donc var (Bn ) = p − p2 =
p(1 − p).
2. Les variables aléatoires étant supposées indépendantes, elles sont a fortiori non corrélées et on a,
pour k ̸= n, E {Bk Bn } = E {Bk } E {Bn } = p2 .
150 Annexes
3. Par linéarité E {S} = E {B{n } =

} p. Pour obtenir la variance il nous faut tout d’abord calculer le
moment du second ordre E S 2 :
{ } 1 ∑∑ 1 ∑ { 2} 1 ∑
N N N
E S2 = 2
E {B B
n k } = 2
E Bn + 2 E {Bn Bk }
N n=1 N n=1 N
k=1 n̸=k
1 N (N − 1) 2 p(1 − p)
= p+ p = p2 +
N N2 N
{ }
En conclusion m = E {S} = p et σ 2 = var (S) = E S 2 − E2 {S} = pq/N .
4. On a successivement ε2r = 4σ 2 /m2 = 4(1−p)/N p ≃ 4/N p si on suppose que p ≪ 1, soit N ≈ 4/(pε2r ).
Pour εr = 0,1, on obtient N = 400/p.
5. Les inégalités 6.12 montrent que pour obtenir une variable aléatoire B qui suit une loi de Bernoulli
de paramètre p, à partir d’une variable aléatoire U uniforme sur (0, 1), il faut prendre B = 0 si
0 ≤ U < (1 − p) et 1 sinon. Ce résultat est obtenu, dans le programme qui suit, par l’instruction
B=(U>q) où q = 1 − p.
//===== Cbernou.sce
p=0.1; q=1-p;
epsilon=.1; N=fix(q/(p*epsilon^2));
U=rand(1,N,’uniform’); B=(U>q);
disp(mean(double(B),2))
On remarquera la conversion de type (double(B)) pour pouvoir faire le calcul de la moyenne (mean).
A.2.9 (Ellipse de confiance) (texte p. 86)
1. En utilisant le changement de variable indiqué Y = C−1/2 (X−m) puis, en passant aux coordonnées
polaires, il vient successivement :
∫ ( )
1 1
α = √ exp − (x − m)T C −1 (x − m) dx1 dx2
∆(s) 2π det(C) 2
∫ ( )
1 1 2
= exp − (y1 + y2 ) dy1 dy2
2
{(y1 ,y2 )∈R2 :y12 +y22 <s} 2π 2
∫ √s ∫ 2π ∫ s/2
1
e−r /2 rdrdθ = e−u du = 1 − e−s/2
2
=
2π 0 0 0
dont on tire s = −2 log(1 − α).

2. Taper :
//===== Cellconf.sce
clear, getd(), clf()
N=200; alpha=0.95; s=-2*log(1-alpha); Nth=fix((1-alpha)*N);
C=[2.3659 -0.3787;-0.3787 0.6427];
y=rand(2,N,’normal’); x=sqrtm(C)*y;
//===== trace
ellipse([0 0],inv(C),s); set(gca(),’grid’,[1 1])
plot(x(1,:),x(2,:),’+’); set(gca(),’data_bounds’,[-6 -4;6 4]);
//===== affichage
normy = ones(1,2) * (y .* y);
nb=length(find(normy>s));
xstring(2,3,msprintf(’Nth=%g N=%g’,Nth,nb))
A.2.10 (Chaîne de Markov) (texte p. 87)

−1
−2
−3
−4
−6 −5 −4 −3 −2 −1 0 1 2 3 4 5 6
Figure A.6 – Ellipse de confiance
1. Etant donné le caractère markovien de la suite obtenue on peut écrire :
pcN = P { XN = ℓN | XN −1 = ℓN −1 } ...P { X1 = ℓ1 | X0 = ℓ0 } P {X = ℓ0 }
∏
N
= aℓ(N −1),ℓ(N ) ...aℓ(0),ℓ(1) pℓ0 (0) = pℓ0 (0) aℓ(k−1),ℓ(k)
k=1
La log-vraisemblance est alors :
∑
N ∑
n ∑
n
log pcN = log aℓ(k−1),ℓ(k) + log pℓ0 (0) = Nα,β log aα,β + log pℓ0 (0)
k=1 α=1 β=1
où Nα,β est le nombre de fois où la transition α → β apparaît dans la suite observée.

2. En notant a∗α,β et λ∗ la solution du problème, les dérivées de L par rapport aux aα,β et à λ
donnent :
∂ Nα,β Nα,β
L = + λ∗ = 0 ⇒ a∗α,β = −
∂aα,β a∗α,β λ∗
∂ ∑
n
1 ∑
n ∑
n
L = a∗α,β − 1 = 0 ⇒ − Nα,β = 1 ⇒ λ∗ = − Nα,β
∂λ λ∗
β=1 β=1 β=1
On en déduit :
N
a∗α,β = ∑n α,β
β=1 Nα,β
L’estimation de la matrice de transition revient donc à faire du comptage pour chacun des couples
(α, β). L’estimateur du maximum de vraisemblance est un estimateur par moyenne.
Le programme tstmarkov.sce effectue l’estimation de la matrice A, estimation notée Ae :
//===== tstmarkov.sce
A=[0 , 1 , 0 , 0 , 0;
3/4 , 0 , 1/4 , 0 , 0;
0 , 1/3 , 1/3 , 1/3 , 0;
1/4 , 1/4 , 1/4 , 0 , 1/4;
1/3 , 0 , 0 , 2/3 , 0];
//===== generation suite des etats
N=10001; initstate=1;
152 Annexes
B=zeros(A); //matriec de comptage

ye=grand(N,"markov",A,initstate);
//tic
for k=1:N-1
B(ye(k),ye(k+1))=B(ye(k),ye(k+1))+1;
end
//disp(toc())
sB=sum(B,’c’) * ones(1,size(A,1));
Ae=B ./ sB;
--->A
A =
0. 1. 0. 0. 0.
0.75 0. 0.25 0. 0.
0. 0.3333333 0.3333333 0.3333333 0.
0.25 0.25 0.25 0. 0.25
0.3333333 0. 0. 0.6666667 0.
->Ae
Ae =
0. 1. 0. 0. 0.
0.7414731 0. 0.2585269 0. 0.
0. 0.3417861 0.3241455 0.3340684 0.
0.2246879 0.2676838 0.2496533 0. 0.2579750
0.3817204 0. 0. 0.6182796 0.
Le rapidité du programme peut être améliorée lors de la construction de la matrice de comptage B.

Dans le programme qui suit, la matrice M joue le rôle de B.
//===== tstmarkov2.sce
// ye est deja calcule
idx=[ye(1:N-1);ye(2:N)]; n=size(A,1); n2=n*n; M=zeros(n,n);
//tic() // pour evaluer les performances
idxl=idx(1,:)+(idx(2,:)-1)*n;
CC=zeros(1,n2);
for k=1:n2
CC(k)=length(find(idxl==k))
end
M(:)=CC;
//disp(toc())
A.2.11 (Etude d’un troisième ordre) (texte p. 98)

1. réponse impulsionnelle :
1/6 1/2 1/3

G(p) = − +
p−1 p+1 p+2
et e−t e−2t
g(t) = − +
6 2 3
2. réponse indicielle à conditions initiales nulles : on peut intégrer chaque terme :

∫ t
G(p) et e−t e−2t 1
⇒ g(u)du = + − −
p 0 6 2 6 2
( )
1 et e−t e−2t
y(t) = u(t) − + + −
2 6 2 6
On aurait pu aussi décomposer en éléments simples :

1
Y (p) =
− 1)(p + 2)
p(p2
1/2 1/6 1/2 1/6
= − + + −
p p−1 p+1 p+2
Figure A.7 – Diagramme de Bode, obtenu sous Scilab, les fréquences étant
données en Hz
3. diagramme de Bode (figure A.7) :

La difficulté provient de la phase. Les termes p + 1 et p − 1 en dénominateur donnent respectivement
les phases −atan(ω) et +atan(ω) qui s’annulent. Le diagramme asymptotique de phase part de 180˚
(ou −180˚), et passe à 90˚ à la pulsation ω = 2.
4. diagramme de Nyquist (figure A.8) :
Figure A.8 – Diagramme de Nyquist, les fréquences indiquées sont données en

Hz
Les tracés des diagrammes de Bode et Nyquist peuvent être obtenus par un programme Scilab tel que
exercice.sce.
//===== exercice.sce
clear
s=poly(0,’s’);
G=[1/(s^3 + 2*s^2 - s - 2)];
monsysteme=syslin(’c’,G);
figure(0); clf(), nyquist(monsysteme)
figure(1); clf(), bode(monsysteme)
154 Annexes
A.2.12 (Paramètres du compensateur PD) (texte p. 106)
√
1. ωm = 1
aτ × 1
τ = τ
1
√
a
;
2. en ωm la phase est maxima. On peut obtenir sa valeur géométriquement.
1 + aτ p
K(p) = ka
1 + τp
1 − a + a + aτ p
= ka
1 + τp
( )
1−a
= ka +a
1 + τp
Lorsque p parcourt l’axe imaginaire, le lieu obtenu est un cercle. (1 − a)/(1 + τ p) est en effet un
cercle que l’on translate de a (figure A.9).
Figure A.9 – Construction du diagramme de Nyquist du compensateur PD
a−1 1 + sin(φmax )
sin(φmax ) = ⇒a=
a+1 1 − sin(φmax )
1√
3. Connaissant ωm et a, τ = ωm a
.
A.2.13 (Réglage de PID) (texte p. 106)
A.2.14 (Projection sur un écran) (texte p. 127)
1. Projection : les valeurs minima et maxima données dans lm sont utilisées pour cadrer la projection
sur l’écran (figure A.10 obtenue par le programme tstproj3D.sce).
function [pos2D,lm]=projconique(Ds,Dr,tb3N)
//!===================================================!
//! Dr = distance object reference origin - observer !
//! Ds = distance from the screen to the observer !
//! tb3N = array(3,N) [[x1;y1;z1],...,[xN;yN;zN]] !
//! pos2D = coordonnees de la projection dans le plan !
//!===================================================!
delta=Ds ./ (Dr-tb3N(1,:,:));
pos2D = [tb3N(2,:,:) .* delta ; tb3N(3,:,:) .* delta];
minxp=min(pos2D(1,:)); maxxp=max(pos2D(1,:));
minyp=min(pos2D(2,:)); maxyp=max(pos2D(2,:));
lm=[minxp,minyp;maxxp,maxyp];
endfunction
−1
−8 −7 −6 −5 −4 −3 −2 −1 0 1 2 3 4 5 6 7 8
Figure A.10 – Projection simple sur le plan orthogonal à Ox
2. Les rotations autour des axes d’un angle φx , φy ou φz sont représentées par les trois matrices :
     
1 0 0 cos φy 0 sin φy cos φz − sin φz 0
Rx = 0 cos φx − sin φx  , Ry =  0 1 0  , Rz =  sin φz cos φz 0
0 sin φx cos φx − sin φy 0 cos φy 0 0 1
qui donnent les coordonnées des points transformés dans le système d’axes choisi.
Fonctions de rotation :
function vxp=rotx(vp,phix)
//!=========================================!
//! phix = rotation around x-axis (degrees) !
//! vp=(3,N)-matrix, vxp=(3,N)-matrix !
//!=========================================!
phix=phix * %pi / 180;
Rx=[1 0 0;...
0 cos(phix) -sin(phix);...
0 sin(phix) cos(phix)];
vxp=Rx*vp;
endfunction
function vyp=roty(vp,phiy)
//!=========================================!
//! phiy = rotation around y-axis (degrees) !
//! vp=(3,N)-matrix, vyp=(3,N)-matrix !
//!=========================================!
phiy=phiy * %pi / 180;
Ry=[cos(phiy) 0 sin(phiy);...
0 1 0;...
-sin(phiy) 0 cos(phiy)];
vyp=Ry*vp;
endfunction
function vzp=rotz(vp,phiz)
//!=========================================!
//! phiz = rotation around z-axis (degrees) !
//! vp=(3,N)-matrix, vzp=(3,N)-matrix !
//!=========================================!
phiz=phiz * %pi / 180;
Rz=[cos(phiz) -sin(phiz) 0;...
sin(phiz) cos(phiz) 0;...
0 0 1];
vzp=Rz*vp;
endfunction
3. Programme de test (figure A.11) :

156 Annexes
//===== tstproj3D.sce
xrate=2.5; sapert=12;
//===== image manipulee
[tx,ty,tz,xx,yy]=newimg();
L=length(tx);
figure(0), surf(tx, ty, tz)
a=gca(); a.axes_reverse=["on","on","off"];
//==========
pos2D=[]; txm=max(tx); Dr=xrate*txm; Ds=sapert;
tb3=zeros(3,L,L); tb3(1,:,:)=xx; tb3(2,:,:)=yy; tb3(3,:,:)=tz;
tb3N=matrix(tb3,3,L*L);
//===== projection conique
figure(1)
[pos2D,lm]=projconique(Ds,Dr,tb3N);
hh=plot(pos2D(1,:),pos2D(2,:),’.’);
a=gca(); a.data_bounds=lm; a.grid=[1 1];
//===== translation + rotation autour de Ox
vxp=rotx(tb3N-2,30);
[pos2D]=projconique(Ds,Dr,vxp);
figure(2)
plot(pos2D(1,:),pos2D(2,:),’.’)
−1
−2
−3
−4
−5
−6
−8 −7 −6 −5 −4 −3 −2 −1 0 1 2 3 4 5 6
Figure A.11 – Projection après translation et rotation
A.2.15 (Méthode de Newton) (texte p. 111)
1. relation de récurrence ;
yn
xn+1 = xn −
yn′
2. Programme :
// ----- exonewton.sce
function xnp1=recn(xn,mp,mpdot)
yn=horner(mp,xn);
ydotn=horner(mpdot,xn);
xnp1=xn-yn/ydotn;
endfunction
myrts=[1,sqrt(2),3]; mypol=poly(myrts,’x’);
mycoef=coeff(mypol); mdeg=length(mycoef);
mycoefd=mycoef(2:mdeg).*[1:mdeg-1];
mpoldot=poly(mycoefd,’x’,’c’)
xt=linspace(0.5,3.5);
plot(xt,horner(mypol,xt)); a=gca(); a.grid=[1 1];
//... en cours
A.2.16 (Méthode de Newton-Raphson) (texte p. 112)
function [xc,yc,cErr,poss,k,dv]=CalcXY(pol,x0,y0,teps,nblps,verbose)
deg=length(pol)-1; P=zeros(1,deg+1); P(:)=pol;
pp=poly(P,’z’,"coeff"); ppd=poly([1:deg] .* P(2:$),’z’,"coeff");
df=1; dv=1; poss=zeros(nblps,4);
k=1; xk=x0; yk=y0;
Pz=horner(pp,x0+%i*y0); Uk=real(Pz); Vk=imag(Pz);
if verbose then
poss(k,:)=[x0,y0,Uk,Vk];
end
while (dv>teps) & (k<nblps)
Pk=horner(ppd,xk+%i*yk); dUsdx=real(Pk); dVsdx=imag(Pk);
den2=dUsdx * dUsdx + dVsdx * dVsdx;
Dxk=-(Uk * dUsdx + Vk * dVsdx)/den2; Dyk=(Uk * dVsdx - Vk * dUsdx)/den2;
dv=abs(Dxk)+abs(Dyk);
xk=xk+Dxk; yk=yk+Dyk; // x(k+1), y(k+1)
Pz=horner(pp,xk+%i*yk); Uk=real(Pz); Vk=imag(Pz); // U(k+1), V(k+1)
k=k+1;
if verbose then poss(k,:)=[xk,yk,Uk,Vk]; end
end
xc=xk; yc=yk;
if (dv<teps) then
cErr=0; // no error
else
cErr=1; // max counter reached
end
endfunction
Evidemment, en termes de rapidité de traitement, il y certainement mieux à faire. Un interpréteur

n’est pas ce qu’il y a de mieux pour mettre en œuvre ce type de calcul. C’est cependant un excellente
façon de « prototyper » une écriture dans un autre langage.
//===== tstCalcXY.sce
getd()
pol=[2 -3 1];
[xc,yc,cErr,poss,k,dv]=CalcXY(pol,%pi,exp(1),10^(-5),100,%t)
figure(0)
subplot(211); plot(poss(1:k,1),poss(1:k,2),’-’),
plot(poss(1:k,1),poss(1:k,2),’x’), set(gca(),’grid’,[1 1])
subplot(212); plot(poss(1:k,3),poss(1:k,4),’-’)
plot(poss(1:k,3),poss(1:k,4),’x’), set(gca(),’grid’,[1 1])
A.2.17 (Codage/décodage sur un canal de communication) (texte p. 128)
La séquence {bk } et la séquence {sk } construites lors du codage (programme tsttierencode.sce)

sont sauvegardées dans le fichier codedseq.sod.
1. Programme de codage :
//===== tsttierencode.sce
clear, getd()
N=1000;
158 Annexes
y
3
2,5
2
1,5
1
0,5
0
−0,5 x
1,8 1,9 2 2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8 2,9 3 3,1 3,2
V
8
2
0
U
−5 −4,5 −4 −3,5 −3 −2,5 −2 −1,5 −1 −0,5 0
Figure A.12 – Evolution de z et P (z) pendant le calcul
bn=grand(1,N,"uin",0,1);
Rnt = tierencode(bn);
save(’codedseq.sod’,’bn’,’Rnt’)
Fonction de codage :
function Rnt=tierencode(bn)
//===== transitions
prcodes=[[0;0;0],[1;1;0],[1;0;0],[0;1;0],[1;1;1],[0;0;1],[0;1;1],[1;0;1]];
N=length(bn); Rn=zeros(3,N); // coded sequence
Sn=zeros(1,N); // numero etat
for k=1:N-1
kn=4*bn(k)+Sn(k);
Rn(:,k)=prcodes(:,kn+1);
Sn(k+1)=floor(kn/2); // transition
end
Rnt=matrix(Rn,1,3*N);
endfunction
2. Programme de décodage :
//===== decoderexple.sce
clear, load(’codedseq.sod’)
P=3; Nc=length(Rnt); N=Nc/P;
nberr=10; // nombre d’erreurs
idxerr=grand(1,nberr,"uin",1,Nc);
serr=zeros(1,Nc); serr(idxerr)=1;
Rnte=modulo(Rnt+serr,2); // received seq. with errors
//=====
for k=1:N-P+1
idxd=P*(k-1)+1; idxf=idxd+P*P-1;
bl=matrix(Rnte(idxd:idxf),P,P)’;
b0=bl(1,3); //===== b(n|n)
b1=modulo(bl(2,1)+bl(2,2),2); //===== b(n|n+1)
b2=modulo(bl(3,2)+bl(3,3),2); //===== b(n|n+2)
b(k)=max([b0*b1,b0*b2,b1*b2]); //===== majority function
end
Vérification :
-->max(b-bn(1:N-2)’)
ans =
0.
A.2.18 (Algorithme de Viterbi) (texte p. 130)
//===== decoderv.sce
clear
verbose=%f; ptest=%f;
//==== Test sequence
if ptest,
Rnte=[0 0 0 1 1 0 1 1 1 0 1 0 0 0 0];
else
Ns=189; Rnte=grand(1,Ns,"uin",0,1);
end
P=3; N=length(Rnte)/P;
prcodes=[[0;0;0],[1;1;0],[1;0;0], [0;1;0],[1;1;1],[0;0;1], [0;1;1],[1;0;1]];
pstate=[1 3 1 3;2 4 2 4];
ostate=zeros(4,N-P+2); wght=zeros(4,1); st=[];
//===== level 1
idxd=1; idxf=3;
bl=Rnte(idxd:idxf)’*ones(1,2);
delta=sum(modulo([[0;0;0] [1;1;1]]+bl,2),’r’);
wght=wght+[delta(1);0;delta(2);0];
ostate(:,1)=[1;0;1;0]; st=[st wght];
//===== level 2
idxd=4; idxf=6;
bl=Rnte(idxd:idxf)’*ones(1,4);
delta=sum(modulo([[0;0;0] [1;0;0] [1;1;1] [0;1;1]]+bl,2),’r’);
wght=[wght(1)+delta(1); wght(3)+delta(2); wght(1)+delta(3); wght(3)+delta(4)];
st=[st wght]; ostate(:,2)=[1;3;1;3];
//===== level 3 et autres
for k=3:N
idxd=P*(k-1)+1; idxf=idxd+2; bl=Rnte(idxd:idxf)’ * ones(1,8);
delta=sum(modulo(prcodes+bl,2),’r’); // distance/transition
[td,ti]=min(matrix(delta+[wght’ wght’],2,4),’r’);
wght=td’; st=[st wght]; ostate(:,k)=pstate(ti+[0:2:6]);
end
//===== backtracking...
mpath=zeros(1,N+1); rseq=mpath; mbits=zeros(1,N);
[mmin,idx]=min(st(:,$));
idxm=idx(1); mpath(N+1)=idxm;
for k=N:-1:1
mpath(k)=ostate(idxm,k); mbits(k)=floor((idxm-1)/2); idxm=ostate(idxm,k);
end
if verbose,
disp(st,’st=’), disp(ostate,’ostate=’)
disp(mpath,’mpath=’), disp(mbits,’mbits=’)
end
L’exécution de decoderv.sce donne :

st=
0. 2. 5. 4. 4.
0. 4. 3. 2. 4.
3. 1. 2. 5. 3.
0. 5. 2. 3. 5.
ostate=
1. 1. 1. 2. 1.
0. 3. 3. 4. 4.
1. 1. 1. 2. 2.
0. 3. 3. 3. 4.
160 Annexes
mpath=
1. 1. 3. 4. 2. 3.
mbits=
0. 1. 1. 0. 1.
− st(i,k), i = 1 à 4, k = 1 à N , donne les distances entre l’état (0, 0) à l’état courant i au pas k sur
le chemin le plus court entre (0, 0) et i ;
− ostate(i,k) , i = 1 à 4, k = 1 à N , donne l’état précédent sur le plus court chemin entre (0, 0) et
i au pas k (0 s’il n’y en a pas) ;
− mpath donne la suite des états sur le chemin le plus court ;
− mbits donne la séquence reconstruite.
A.2.19 (Calcul d’intégrale) (texte p. 133)
1. On a :
∫ +∞ ∫ +∞
1
1[α,+∞) √ e−u /2 du
2
I(α) = = (A.20)
α −∞ 2π
(a) Valeur théorique calculée par Scilab : on rappelle que la fonction d’erreur erf(x) et la fonction
d’erreur complémentaire erfc(x) ont pour expression :
∫ x
2
e−u du
2
erf(x) = √ (A.21)
π 0
∫ +∞
2
e−u du
2
erfc(x) = 1 − erf(x) = √ (A.22)
π x
∫ +∞ √
1 1
e−u
2
⇒ I(α) = √ /2
du = erfc(α/ 2) (A.23)
2π α 2
∑
(b) Calcul direct : si on fait un tirage de variables aléatoires normales de loi N (0, 1), i f (ξi )
est égal au nombre NX>α d’échantillons qui sont > α. Si α est grand, ce dernier n’est plus
suffisant pour assurer une bonne précision.
NX>α
I(α) ≈ (A.24)
N
//===== IS_direct.sce
clear, getd()
alpha=3; N=10000;
Ialphath=0.5 * erfc(alpha/sqrt(2)); // valeur theorique
scr=msprintf(’Valeur theorique I(alpha) = %15.6g’,Ialphath); disp(scr)
Lruns=200; P1_direct=zeros(Lruns,1);
for ii=1:Lruns
x=grand(N,1,"nor",0,1);
P1_direct(ii)=sum(x>alpha)/N; // valeur integrale
end
clf, myboxplot(P1_direct,1.5)
scr=msprintf(’Valeur mesuree I(alpha) = %15.6g’,mean(P1_direct)); disp(scr)
-->exec(’IS_direct.sce’, -1)
Valeur theorique I(alpha) = 0.0013499
Valeur mesuree I(alpha) = 0.0013295

0,0022 outliers
0,002
0,0018
0,0016
(75%)
0,0014
médiane
0,0012
(25%)
0,001
0,0008
0,0006
0,0004
outliers
Figure A.13 – boxplot des calculs de I(α)
2. f (x) est la fonction de Heaviside retardée 1[α,+∞) . Moyenne et variance sont données par :
E {f (X1 )} = I(α)
{ } 2
γ2 = var(f (X1 )) = E f 2 (X1 ) − E {(f (X1 )}
∫ +∞
= f 2 (u)p(u)du − I 2 (α) = I(α) − I 2 (α)
α
I(α)−I 2 (α)
La variance de l’erreur commise sur le calcul de l’intégrale est alors v 2 = N .
γ2 I(α) − I 2 (α) 1 − I(α)

ε2 = = =
I 2 (α) I 2 (α) I(α)
√
La quantité ε/ N peut être vue comme une erreur relative. Cette erreur est d’autant plus grande
que α est grand.
3. Utilisation d’une loi de Cauchy :
(a) Le tirage suivant la loi de Cauchy se fait à partir d’une loi uniforme sur −π/2, +π/2 par :
X = tan(π(U − 1/2)) (A.25)
function X=genecauchy(N,verf,nh,xn)
// verf = booleen. Si %t, trace histogramme et densite theorique
// trace de -xn a +xn avec nh classes
if argn(2)<4, xn=30; end
if argn(2)<3, nh=max(10,N/100); end
if argn(2)<2, verf=%f; end
//===== generation de la suite
U=rand(N,1); X=tan(%pi*U-(%pi/2));
if verf then
//===== histogramme
idx=find((X>-xn) & (X<xn)); N=length(idx);
[ni,xh] = myhist(nh,X(idx),%t,%t);
//===== densite theorique
px=1 ./ (1+xh .*xh)/%pi; plot(xh,px,’xr’);
end
endfunction
162 Annexes
(b) Valeur (ξi obtenue selon la loi de Cauchy) :

√
1 ∑ p(ξi ) 1 π∑
f (ξi )e−ξi /2 (1 + ξi2 )
2
I(α) ≈ f (ξi ) = (A.26)
N q(ξi ) N 2
//===== IS_cauchy.sce
//===== Importance sampling =======================
// Calcule \int_{\alpha}^{+\infty} p(x)dx avec p(x)=N(0,1)
// a l’aide d’une distribution de Cauchy
//=================================================
clear, getd()
alpha=3; N=10000; dpitdemi=sqrt(2/%pi);
Ialphath=0.5 * erfc(alpha/sqrt(2)); // valeur theorique
scr=msprintf(’Valeur theorique I(alpha) = %15.6g’,Ialphath); disp(scr)
//=====
Lruns=200; P1_direct=zeros(Lruns,1);
P1_IS_with=zeros(Lruns,1); P1_IS_cauchy=zeros(Lruns,1);
for ii=1:Lruns
xi=genecauchy(N);
//===== poids d’importance p(xi)/q(xi)
pimport=exp(-xi.*xi/2) .* (1+xi.*xi);
P1_IS_cauchy(ii)= (xi>alpha)’ * pimport; // sum(f(xi)*p(xi)/q(xi))
end
P1_IS_cauchy=P1_IS_cauchy/N/dpitdemi; clf, myboxplot(P1_IS_cauchy,1.5)
scr=msprintf(’Valeur mesuree I(alpha) = %15.6g’,mean(P1_IS_cauchy));
disp(scr)
0,0022
0,002
0,0018
0,0016
0,0014
0,0012
0,001
0,0008
0,0006
0,0004
Figure A.14 – Superposition pour pour L = 200 essais et pour α = 3 : les

valeurs P̄n (α) sont obtenues avec n = 10 000 échantillons (a) en utilisant des
échantillons gaussiens i.i.d., (b) en utilisant l’IS et une loi intrumentale qui est
une loi de Cauchy.
A.2.20 (Equation de d’Alembert) (texte p. 135)
//===== equdalembert.sce
lambda=1/sqrt(2*%pi); // pour information
c=10; // idem
tpause=50000;
X=0.003; xmax=.75; l1=round(xmax/X);
x=[-l1:l1]*X; Lx=length(x);
fg0=zeros(1,Lx); fd=fg0; fg=fg0;
T=1/10000; t=[-l1:l1]*T; Lt=Lx;
//===== DoG initialization
xcmax=0.3; l2=round(xcmax/X);
xc=[-l2:l2]*X; Lxc=length(xc); xc2=xc .* xc;
sigma1=10*X; sigma2=15*X;
f1=lambda*exp(-xc2/sigma1/sigma1/2)/sigma1;
f2=lambda*exp(-xc2/sigma2/sigma2/2)/sigma2;
yd=f1-f2; yg=yd;
//=====
ad1=l1+1-l2:l1+1+l2; fg(ad1)=yg;
ad2=l1+1-l2:l1+1+l2; fd(ad2)=yd;
plot(x,fg+fd); hh=gce(); xpause(tpause), delete(hh)
a=gca(); a.grid=[1 1];
fd=fg0; fg=fg0;
//=====
for idxg=-1:-1:-l1+l2+1
idxd=-idxg;
ad1=l1+1+idxg-l2:l1+1+idxg+l2; fg(ad1)=yg;
ad2=l1+1+idxd-l2:l1+1+idxd+l2; fd(ad2)=yd;
plot(x,fg+fd); hh=gce(); xpause(tpause), delete(hh)
fd=fg0; fg=fg0;
end
A.2.2 Exercices divers avec indications

Exercice .1 (Equations différentielles linéaires à coefficients constants) (indications p. 164)
On considère l’équation différentielle linéaire à coefficients constants :
d2 y(t) dy(t)
+3 + 2y(t) = x(t) (A.27)
dt2 dt
On note X(p) et Y (p) les transformées de Laplace de x(t) et y(t). On se donne y(0+ ) et ẏ(0+ ) les
conditions initiales sur y et sa dérivée ẏ respectivement.
1. rappeler la transformée de Laplace de dy/dt ;
2. en déduire que la transformée de Laplace de d2 y/dt2 est :
p2 Y (p) − py(0+ ) − ẏ(0+ )
3. en appliquant la transformée de Laplace à l’équation A.27, faites apparaître le terme correspondant à la

solution particulière et le terme dû aux conditions initiales ;
4. ce système est-il stable ? Quelles en sont la pulsation propre et la valeur du coefficient d’amortissement ?
Exercice .2 (Circuit électrique) (indications p. 165)

On considère le circuit de la figure A.15.
Figure A.15 – Circuit étudié
1. Donner l’expression de l’impédance Z(p) = U (p)/I(p). En déduire que :
LCp2 + RCp + 1
G(p) = I(p)/U (p) =
(RCp + 1)Lp
2. On suppose que R = 10, L = 10−2 et C = 10−4 . Donner l’allure du diagramme de Bode.

164 Annexes
fermeture ? fermeture ?
−9 Hz
1,5
1
−15,8
0,5
−58,1
0
58,1
−0,5
−1 15,8
−1,5
9
−0,06 −0,04 −0,02 0 0,02 0,04 0,06 0,08 0,1 0,12
Figure A.16 – Diagramme de Nyquist
3. Le diagramme de Nyquist est donné par la figure A.16. Expliquer précisément son tracé.
4. Préciser la fermeture du diagramme de Nyquist “à l’infini” en expliquant votre choix de contour de

Bromwich au voisinage de p = 0.
Exercice .3 (Stabilité) (indications p. 165)

On considère la fonction de transfert :
k(1 − p)
G(p) =
(1 + 2p)p
1. Ce système est-il stable ?
2. Donner l’expression de la fonction de transfert H(p) en boucle fermée correspondant à la figure A.17.
Figure A.17 – Boucle fermée
3. Discuter la stabilité du système en fonction de k.
4. Vérifier le résultat précédent en utilisant le diagramme de Nyquist.
A.2.21 (Equations différentielles linéaires à coefficients constants) (texte page 163)

On considère l’équation différentielle linéaire à coefficients constants :
d2 y(t) dy(t)
+3 + 2y(t) = x(t) (A.28)
dt2 dt
On note X(p) et Y (p) les transformées de Laplace de x(t) et y(t). On se donne y(0+ ) et ẏ(0+ ) les
conditions initiales sur y et sa dérivée ẏ = dy/dt respectivement.
1. ẏ → pY (p) − y(0+ ) ;
2. on pose x(t) = dy
dt . On a dx/dt → pX(p) − x(0+ ). Or, X(p) = pY (p) − y(0+ ) et x(0+ ) = dy
dt (0+ ).
On en déduit :
d2 y
→ p2 Y (p) − py(0+ ) − ẏ(0+ )
dt2
3. en appliquant la transformée de Laplace à l’équation A.28 ;
p2 Y (p) − py(0+ ) − ẏ(0+ ) + 3(pY (p) − y(0+ )) + 2Y (p) = X(p)

X(p) py(0+ ) + ẏ(0+ ) + y(0+ )
⇒ Y (p) = 2 +
p + 3p + 2 p2 + 3p + 2
√
4. Lest pôles√sont en −1 et −2. Le système est stable. La pulsation propre est ωN = 2 et 2zωN = 3
→ z = 3/ 2/2.
A.2.22 (Circuit électrique) (texte page 163)
1. Impédance Z(p) ;
1
(R + Cp )Lp (RCp + 1)Lp
Z(p) = 1 =
Lp + R + Cp LCp2 + RCp + 1
U (p) = Z(p)I(p) et la fonction de transfert I(p)/U (p) :
LCp2 + RCp + 1
G(p) = (A.29)
(RCp + 1)Lp
2. Avec les valeurs données (R = 10, L = 10−2 et C = 10−4 ), on a :
10−6 p2 + 10−3 p + 1
G(p) = (A.30)
(10−3 p + 1)10−2 p
5
0
−5
−10
−15
−20
−25
(Hz)
0
−20
−40
−60
−80
Figure A.18 – Diagramme de Bode
A.2.23 (Stabilité) (texte p. 164)
1. instable car pôle en p = 0 ;

166 Annexes
−9 Hz
1,5
1
−15,8
0,5
−58,1
0
58,1
−0,5
−1 15,8
−1,5
9
−0,06 −0,04 −0,02 0 0,02 0,04 0,06 0,08 0,1 0,12
2. Expression de la fonction de transfert H(p) en boucle fermée :
k(1 − p) G(p) k(1 − p)

G(p) = ⇒ H(p) = =
(1 + 2p)p 1 + G(p) k(1 − p) + (1 + 2p)p
3. La stabilité dépend des pôles du dénominateur :
D(p) = 2p2 + p(1 − k) + k
Le produit des racines est égal à k/2 > 0 et la somme (k − 1)/2. Si k > 1, les racines sont à partie
réelle positive et le système est instable.
4. Diagramme de Nyquist (figure A.20).
0,5
80 252
119
0
−2,59 point critique
−0,5
40
−4,52
−1,2 −1 −0,8 −0,6 −0,4 −0,5 0
20
44,6 73,4 119 252 Hz
0
−20
4,52
−40
2,59
−80
−3,5 −3 −2,5 −2 −1,5 −1 −0,5 0 0,5
Si on choisit le contours de Nyquist indiqué figure A.20, la fermeture se fait “à gauche”. Le pôle
en p = 0 est considéré comme instable et il est unique. Pour n’avoir qu’un tour autour du point
critique, il faut que k < 1.
A.3 Exemples divers

A.3.1 Diagrammes de gain et réponses impulsionnelles
Programme principal :
//===== ordre2anim.sce
// exec(ordre2anim.sce,-1)
clear, clf
global a
getd()
ieff=%t;
wn=1; z=[.01 .05 [.1:.1:.6] sqrt(2)/2 [1:4]];
z=z($:-1:1);
// creation interface
[myf,hsl,hpb,htxt,hcbx]=createIF(z);
calculs(jw,z,wn,hcbx)
Création de l’interface :
function [f,hsl,hpb,htxt,hcbx]=createIF(z)
global a
bl=550;
f=figure(0); f.visible=’off’;
f.position=[20,40,650,450]; f.children.visible=’off’;
f.figure_name="SecondOrdre"; f.Background=7;
hsl=uicontrol(f,’style’,’slider’,’position’,[620 50 16 370],...
’min’,z($),’max’,z(1),’sliderstep’,[.01 .1],...
’callback’,"traitsl(hsl,htxt,wn,jw)");
hsl.value=0;
a=newaxes(); a.box=’on’; a.grid=[1 1];
a.axes_bounds=[0 0 .85 .95]; a.margins=[.05 .05 .05 .05];
hpb(1)=uicontrol(f,’style’,’pushbutton’,...
’position’,[bl 20 50 20],...
’string’,’close’,’callback’,"close()");
’position’,[bl 45 50 20], ’string’,’draw’,...
’callback’,"calculs(jw,z,wn,hcbx)"); //
’position’,[bl 70 50 20], ’string’,’clear’,...
’callback’,"c=a;delete(a.children);a=c;");
htxt=uicontrol(f,’style’,’text’,...
’position’,[bl 95 50 20], ’string’,’’);
hcbx=uicontrol(f,’style’,’checkbox’,...
’position’,[bl 120 20 20],’value’,0);
f.visible=’on’;
endfunction
Calcul et affichage animé des caractéristiques :

function calculs(jw,z,wn,hcbx)
global a
lz=length(z); k=1;
wlog=abs(jw);
if ~isempty(a.children) then
delete(a.children);
end
while k<=lz
mp=calcul(wn,z(k),jw);
sca(a);
plot2d(’ln’,wlog,20*log10(abs(mp)));
a=gca();
a.data_bounds=[.1,-45;10,35];
a.grid=[1 1];
168 Annexes
hh=gce();
xpause(200000) // microsecondes
if (hcbx.value==0) & (k~=lz), delete(hh), end
k=k+1;
end
endfunction
Calcul et affichage d’une caractéristique :

function [mp]=calcul(wn,z,jw)
mcof=[wn*wn,2*z*wn,1];
den=poly(mcof,’s’,"coeff");
endfunction
Traitement du curseur de défilement (slider) :

function traitsl(hsl,htxt,wn,jw)
global a
if ~isempty(a.children) then
delete(a.children);
end
slval=hsl.value; wlog=abs(jw);
[mp]=calcul(wn,slval,jw);
sca(a)
str=msprintf(’%3.2f’,slval);
htxt.String=str
endfunction
A.3.2 Loi binomiale

La génération de probabilité se fait par pr=binomial(p,N) et la génération de variables par
x=grand(m,n,’bin’,N,p).
La fonction de répartition théorique utilisée dans la fonction cdfbin est calculée par :
∑ (n)
ps (1 − p)n−s = Ip (a, n − a + 1)
s
s=a
∫ p
1
avec Ip (a, b) = ta−1 (1 − t)b−1 dt
B(a, b) 0
∫ 1 ∫ π/2
et B(a, b) = ta−1
(1 − t) dt = 2
b−1
sin(t)2a−1 cos(t)2b−1 dt
0 0
//===== testbinomial.sce
clear
N=1000; p=0.3; //P(X=0)=q, P(X=1)=p=1-q
Nt=100; // nombre de tirages
xn=rand(Nt,N,’u’); xb=zeros(Nt,N);
idxp=find(xn<p); xb(idxp)=1;
Lones=sum(xb,2); // nbre de 1 pour chaque tirage
//===== histogramme
clf, subplot(211);
nc=20; // nombre de classes de l’histogramme
histplot(nc,Lones), // ()normalization=%t)
title(’normalisé’), set(gca(),’grid’,[-1 1])
//===== repartition estimee
mx=max(Lones); mn=min(Lones); S=[mn:(mx-mn)/nc:mx];
[ind,occ]=dsearch(Lones,S);
subplot(212); plot2d2(S(2:$),cumsum(occ)/Nt)
title(’Fonction de répartition estimée’)
//===== loi théorique
ons=ones(S);
[p1,p0]=cdfbin(’PQ’,fix(S),N*ons,p*ons,(1-p)*ons)
plot(S,p1,’r’), plot(S,p1,’or’)
legend(’estimé’,’théorique’)
normalisé
0.035
0.03
0.025
0.02
0.015
0.01
0.005
0
270 280 290 300 310 320 330 340 350
Fonction de répartition estimée
1
estimé
théorique
0.8
0.6
0.4
0.2
0
270 280 290 300 310 320 330 340 350
Figure A.21 – Fonctions de répartition estimée et théorique
A.3.3 Diagramme électrique

On condifère le filtre passe-bas RC de la figure A.22.
Figure A.22 – Circuit RC
Paramètres :
1. configuration (menu simulation/configurer, figure A.23) des paramètres de calcul (résolution d’équa-
tion différentielle, figure A.24) :
2. source de tension sinusoïdale : amplitude = 1, phase = 0, fréquence = 2, offset de tension = 0,

offset de temps = 0 ;
3. composants : résistance = 10KΩ, condensateur = 10µF et tension initiale = −2V ;
4. horloge : période = 0.01 s, temps d’initialisation 0.1 ;

170 Annexes
Figure A.23 – Configuration
Figure A.24 – Paramètres de configuration
5. oscilloscope : ymin = −1.5, Ymax = 1.5, période de rafraîchissement = 3, buffer size = 100.
L’exécution donne lieu à un certain nombre de messages. La boîte de dialogue de la figure A.25 donne
des informations sur le système différentiel résolu par Xcos.
Un certain nombre de messages sont fournis dans la fenêtre de commande indiquant une « édition de
liens » avec une bibliothèque dynamique. Il faut donc que Scilab puisse trouver un compilateur C et les
outils associés... si ceux-ci ne sont pas installés, il ne pourra pas y avoir exécution. Sur Mac OS X, cela
marche avec Xcode installé.
Figure A.25 – informations sur le système différentiel
1.5
0.5
−0.5
−1
−1.5
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2 2.2 2.4 2.6 2.8 3
Figure A.26 – Réponse à une sinusoïde

172 Annexes
Bibliographie
[1] M. Matsumoto and T. Nishimura. Mersenne twister : A 623-dimensionally equidistributed uniform

pseudorandom number generator. ACM Trans., Modeling and Computer Simulations, 1998.
[2] Consortium Scilab. Introduction to discrete probabilities with Scilab. Digiteo, Domaine de Voluceau -
Rocquencourt - BP 105 - 78153 Le Chesnay Decex France.
[3] Consortium Scilab. Introduction to Scilab. Digiteo, Domaine de Voluceau - Rocquencourt - BP 105 -
78153 Le Chesnay Decex France.
[4] Consortium Scilab. Optimization in Scilab. Digiteo, Domaine de Voluceau - Rocquencourt - BP 105
- 78153 Le Chesnay Decex France.
[5] Consortium Scilab. Scilab is not naive. Digiteo, Domaine de Voluceau - Rocquencourt - BP 105 -
78153 Le Chesnay Decex France.
[6] Jean-Philippe Chancelier Stephen L. Campbell and Ramine Nikoukhah. Modeling and Simulation in
Scilab/Scicos. Springer Science, Springer Science+Business Media, Inc., 233 Spring Street, New York,
NY 10013, US, 2006.
173
174 Annexes
Index
activation (Xcos), 67, 68 démarrage (scilab.ini), 12

addition (de matrices), 21
aguments EC, 59
nombre de, 48 editable text, 59
auto_clear (propriété), 30 EDLCC, 91
ellipse de confiance, 86, 150
Black-Nichols, 98 Elément de contrôle, 59
blanc eps (postscript encapsulé), 34
suite aléatoire, 143 équation
bloc (Xcos), 67 de d’Alembert, 134
Bode, 93 erreurs
bouton radio (radiobutton), 59 errcatch, 51
bouton-poussoir (pushbutton), 59 execstr, 51
Bromwich, 100 Excel, 40
exemple
cadre (frame), 59 calcul.sci, 168
case, 27 calculs.sci, 167
case à cocher (checkbox), 59 createIF.sci, 167
cellule, 20 ordre2anim.sce, 167
chargement des fonctions, 12 testbinomial.sce, 168
checkbox, 59 traitsl.sci, 168
coefficients de corrélation, 141
comparaisons, 26 factorisation
constantes lu, 44
%eps, 18 qr, 44
%i, 18 fonction
%inf, 18 abort, 50
%nan, 18 abs, 23
%pi, 18 acos, 23
mtlb_realmax, 18 argn, 48
mtlb_realmin, 18 asin, 23
contexte (Xcos), 70 atan, 23
contour de Bromwich, 100 atan2, 23
conversion binomial, 81
functions de, 37 boolmatrixmul.sci (produit matriciel lo-
corde vibrante, 134 gique), 145
corrélation, 141 CalcXY.sci (calcul d’une racine), 157
covariance, 141 callback, 63
caractéristique, 140
deff (définition locale de fonction), 47 case, 27
définition cat, 20
de fonction locale deff, 47 CHOfact.sci (Cholesky), 144
diagramme clearclear, 16
de Black-Nichols, 98 color, 62
de Bode, 93 colormap, 62
de Nyquist, 96 comet, 36
diagramme de Bode, 31 comet3d, 36
domaine de convergence, 89 conv2 (image), 55
175
176 Annexes
convol2d (image), 55 min, 29

cos, 23 mopen, 39
csim (simulation de syst. lin.), 113 mprintf, 38
csvRead, 40 mput, 39
de répartition, 84, 137, 138, 148 msprintf, 37, 38
de transfert, 92 myboxplot.sci, 133
delete, 36 myfilter2.sci, 56
disp, 38 myfuncx.sci, 131
ellipse.sci, 32 myhist.sci, 79
ellipse, 87 newaxes, 59
ellipse2.sci, 48 newimg.sci, 127
erf (fonction d’erreur), 133 ode (système différentiel), 115
erfc (fonction d’erreur complémentaire), 133 ones, 18
error, 48, 51 param3d, 34
execstr, 49 part, 17
exp, 23 pause, 50
expm, 24 plot, 30
d’exportation, 42 polarplot, 32
eye, 18 poly, 25
figure, 30, 59 procheader.sci, 54
find, 29 projconique.sci, 154
findobj, 63 rand (normal), 18
for, 28 rand (uniform), 18
format d’affichage, 16 repmat, 20
fsolve (équ. non linéaires), 112 resume, 50
function, 47 roots, 25
gce, 36 rotx.sci, 155
genecauchy.sci, 161 roty.sci, 155
genmarkov, 82 rotz.sci, 155
getd(), 12 save, 39
getd, 33 sdf, 62
global, 65 sin, 23
graycolormap, 24 spec, 25
grayplot (images), 55 sqrt, 23
hypermat, 19 sqrtm, 24
if, 27 strcat, 17
image (Matlab), 53 string, 37
input, 38 strsplit, 17
IS_cauchy.sce, 162 struct, 21
isalphanum, 28 subplot, 30
isascii, 28 surf, 34
iscell, 28 tan, 23
ishigami, 118 testmatrix, 18
isinf, 28 tierencode.sci, 158
isnan, 28 trtcomment.sci, 55
jetcolormap, 24 uicontrol, 59
link, 118 uimenu, 59, 65
load, 39 warning, 51
log, 23 where, 50
logm, 24 whereami, 50
Matplot (images), 53 while, 27
matrix, 16 xpause, 36
max, 29 xs2eps, 34
mclose, 39 xsetech, 31
median, 29 xstringb, 37
mesh, 34 zeros, 18
mget, 39 fonction audio
loadwave, 42 menu déroulant (popupmenu), 59

playsnd, 43 méthode
wavread, 42 de Jenkins-Traub, 111
fonction caractéristique de Newton-Raphson, 111
loi marginale, 140 MIMO, 100
fonction caractéristique (gaussienne), 75 minimum de phase, 91
fonction logique moyenne, 141
isalphanum, 28 multiplication (de matrices), 21
isascii, 28
iscell, 28 Newton-Raphson, 111
isinf, 28 Nyquist, 96
isnan, 28
fonctions (chargement des), 12 ode, 113
for, 28 ordinary differential equation, 113
format
d’affichage, 16 palette, 53
eps (postscript encapsulé), 34 paramètres
frame, 59 implicites (Xcos), 70
partie
gain complexe, 92 forcée (EDLCC), 91
gca() 30 libre (EDLCC), 91
gda() (get default axes), 70 point critique, 101
glissière (slider), 59 points d’arrêt
grid (propriété), 30 delbpt, 50
dispbpt, 50
histogramme, 75 setbpt, 50
popupmenu, 59
if, 27
postscript encapsulé (eps), 34
image
probabilité
indexée, 53
conjointe, 137
image (UICONTROL), 59
programme
intervalle de confiance, 76
boucles, 28
inverse de matrice, inv(A), 22
builder.sce (ishigami), 121
inégalité de Tchebischev, 141
calcule.sce, 27
listbox, 59 cardioide.sce, 32
liste statique (listbox), 59 Cbernou.sce (loi de Bernoulli), 150
loi Cellconf.sce (ellipse de confiance), 150
gaussienne complexe, 77 colorfill.sci (coloriage), 146
de Bernoulli, 85, 149 Cpoisson.sce, 147
de Poisson, 85 Crayleigh.sce (loi de Rayleigh), 149
de Rayleigh, 85 création, 12
exponentielle, 85 decoderexple.sce, 158
gaussienne, 75 decoderv.sce, 159
gaussienne complexe, 77 ellaxes.sce, 33
normale, 75 ellipsecom.sce, 37
normale complexe, 77 ellipsetst.sce, 47
de Poisson, 146 esthistog1d.sce, 79
de Rayleigh, 149 exercice.sce, 153
uniforme, 74 exonewton.sce, 156
loi marginale explenyquist51.m, 101
fonction caractéristique, 140 histoG1d.sce, 76
histoGC1d.sce, 77
Markov integfunc.sce (intégrale)), 131
classe, 82 interface1.sce, 59
état transitoire, 82 interface2.sce, 63
matrice interface3.sce (exemple de callback), 63
de covariance, 142 interface4.sce (exemple de uimenu), 64
178 Annexes
IS_direct.sce, 160 script, 12

ishigami.c, 117, 119 simulation (Xcos), 67
loiexp.sce (loi exponentielle), 148 SISO, 100
makedynlib.sce, 124 SLI, 89
myanim.sce, 36 slider, 59
mybezier.sce, 35 solution
neighbours.sci (coloriage), 146 générale, 91
nyquiststab.sce, 101 particulière, 91
opelog1.sce (produit scalaire sur GF(2)), 144 startup, 12
opelog2.sce (produit scalaire sur GF(2)), 144 static text, 59
ordre1.m, 93 structures, 20
ordre1.sce, 93 suive de consigne, 100
ordre2.m, 95 super-bloc (Xcos), 70
ordre2nyq.m, 96 système
ordre2.sce, 95 strictement propre, 92
repcren.sce (créneau sur filtre RC), 114 systèmes linéaires invariants (SLI), 89
RK4.sce, 115 séquence de test (longueur), 86
sci_mafonction.c, 123
table
scilab.ini, 12
de couleurs, 24, 62
sphere.sce, 34
des erreurs, 51
step2order.sce, 107
table (UICONTROL), 59
testbode.sce, 31
Tchebischev, 141
testode05.sce, 115
tests, 26
tests, 26
texte
testsolve01.sce, 112 modifiable (editable text), 59
testsolve02.sce, 113 statique (static text), 59
testtry.sce, 51 TL, 89
tpsc2tpsd.sce (temps cont. → discret), 113 transformée de Laplace, 89
trace2D.sce, 34
traitcsv.sce, 40 v.a. (indépendance), 139
trtseuil.sce, 57 v.a. (variable aléatoire), 73
tstCalcXY.sce (calcul d’une racine), 157 variable aléatoire
tstCHOfact.sce (Cholesky), 144 gaussienne complexe, 77
tstgamma.sce, 81 gaussienne, 75
tstimage0.sce, 53 gaussienne complexe, 77
tstmarkov.sce, 151 moyenne, 141
tstmarkov2.sce, 152 uniforme, 74
tstng.sce (coloriage), 145 variance, 141
tstproj3D.sce (projection 3D), 155 écart-type, 141
tsttierencode.sce, 157 variance, 141
veriffft2.sce (filtrage image), 55 vecteur aléatoire, 141
veriffft3.sce, 56 vecteur moyenne, 142
waitclick.sce, 38
propriété while, 27
callback, 59
Xcos, 67
pushbutton, 59
zéros, 91
radiobutton, 59
rejet des perturbations, 100 équation différentielle linéaire à coefficients
résonance, 92 constants, 91
Runge-Kutta, 115
règle des 3 sigma, 76
réponse
impulsionnelle, 92
indicielle, 92
résolution de système linéaire (\), 22

Doc

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Doc

Transféré par

Droits d'auteur :

Formats disponibles

LIESSE - Initiation à Scilab

Notations and Abréviations 9

2 Ecriture des programmes et mise au point 47

3 Eléments sur les images 53

7 Eléments d’automatique linéaire à temps continu 89

8 Résolution d’équations 111

9 Les extensions 117

10 Exercices divers 127

2. un chapitre sur l’écriture des programmes et la mise au point ;

8. un chapitre traite de la résolution d’équations, dont les équations différentielles ;

Ce document a été rédigé sous (TeXShop 2.47) avec :

Quelques liens et documents utiles :

E {X} valeur moyenne de X

Quelques petites choses à retenir :

Le terme Scilab pourra faire référence dans ce qui suit :

− ou le langage défini par un vocabulaire et des règles syntaxiques.

Figure 1.1 – La fenêtre de commande de Scilab-5.4.0 dans Mac OS X

L’utilisation de Scilab peut se faire de deux façons :

Figure 1.2 – La fenêtre de commande de Scilab-5.3.3 avec le résultat de l’in-

//===== scilab.ini dans SCIHOME (Mac OS)

Figure 1.3 – Répertoire courant ou « de travail »

Figure 1.4 – « Mon » répertoire SCIHOME

1.1 Variables et constantes

Définition du contenu des matrices

Figure 1.6 – Définition d’une matrice

Exemple 1.3 (Enumération implicite) Taper a=(0:1:10) ou a=(0:10). Scilab donne :

Exemple 1.5 (Extension d’une matrice) Taper :

Références aux éléments d’un tableau

Scilab retourne toujours un vecteur colonne.

Exemple 1.6 (Suite alternée) Taper :

1.1.2 Les chaînes de caractères

On aurait pu taper strsplit(chc) au lieu de strsplit(chc,(1:length(chc)-1)). Le résultat reste

La concaténation des chaînes de tabl donne :

1.1.3 Matrices prédéfinies

− zeros(L,C) donne une matrice de L lignes et C colonnes ne contenant que des « 0 » ;

− rand(L,C,"normal") donne une matrice (L × C) contenant un échantillon de variables aléatoires

− rand(L,C,"uniform") ou rand(L,C) donne une matrice (L × C) contenant un échantillon de va-

1.1.4 Constantes et initialisations

Exemple 1.7 (Constante prédéfinie et format d’affichage) Taper :

%eps, mtlb_realmin (émulation de realmin de Matlab) et mtlb_realmax (émulation de realmax) sont

Exemple 1.8 Taper :

-->a=[0 %inf %nan 2]

0. Nan Nan 0.6666667

Les constantes %s et %z sont les monômes s et z de type polynôme (équivalents à poly(0,’s’) et

Exemple 1.9 Taper :

1.1.5 Tableaux multidimensionnels

Exemple 1.10 Taper :

B=zeros(2,2,2) définit un tableau B (2 × 2 × 2) rempli de 0. L’instruction B(:)=C indique que l’on

1.1.6 Cellules et structures

-->langcell(2).entries=[6 5;2 3];

Exemple 1.11 (Conversion) Taper :

-->mycell=makecell([3,1],’SCILABxy’,[6 5;2 3],2013);

-->a=mycell(1), size(a), length(a)

-->b=cell2mat(a), size(b), length(b)

La deuxième instruction affiche le contenu de langstruc.Year. Une structure de dimension (1 × 1)

1.2 Opérations et fonctions

1. les opérations (+, ×), somme et multiplication de deux matrices :

Exemple 1.12 (Multiplication

La commande size(a) délivre « 2. 1. », soit les nombres de lignes et colonnes de a ;

Exemple 1.13 (Résolution de système linéaire) Taper :

-->A=[1 2;2 3]; b=[1;1];

3. l’opération A/B revient à exécuter l’opération (B’\A’)’ ;

Exemple 1.14 (Transposition et transconjugaison) Taper :

-->sig = exp(2%i%pitims’fq);//===== signal complexe

L’instruction sig = exp(2%i%pitims’fq); applique l’exponentielle à chaque élément de la ma-

-->for k=1:3, subplot(2,3,k), plot(tps,sin(2%pif0*tps)), end