Table des matières

I Algorithmique 3
1 Introduction à scilab 3
1.1 Démarrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Variables, constantes, opérations élémentaires . . . . . . . . . 3
1.2.1 Scalaires (réels et complexes) . . . . . . . . . . . . . . 4
1.3 Les constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4 Les chaînes de caractères ou string . . . . . . . . . . . . . . . 7
1.5 Les variables logiques ou booléennes . . . . . . . . . . . . . . . 7

2 Les matrices 9
2.1 Opérations sur les matrices . . . . . . . . . . . . . . . . . . . . 13
2.2 Les matrices prédéfinies . . . . . . . . . . . . . . . . . . . . . 15
2.3 Extraction, insertion de matrices . . . . . . . . . . . . . . . . 16

3 Les polynômes 21
3.1 Polynômes simples . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2 Matrices des polynômes . . . . . . . . . . . . . . . . . . . . . 22

4 Fichiers de données, scripts et fonctions 23

4.1 Fichiers de données . . . . . . . . . . . . . . . . . . . . . . . . 23
4.2 Écrire et exécuter un script . . . . . . . . . . . . . . . . . . . 24
4.3 Fichiers de fonctions . . . . . . . . . . . . . . . . . . . . . . . 25

5 Programmation en scilab 28
5.1 Les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.1.1 La boucle for . . . . . . . . . . . . . . . . . . . . . . . 29
5.1.2 La boucle while . . . . . . . . . . . . . . . . . . . . . 30
5.2 L’instruction conditionnelle if . . . . . . . . . . . . . . . . . . 31

6 Représentations graphiques en scilab 32

6.1 Les fenêtres Graphiques . . . . . . . . . . . . . . . . . . . . . 32
6.2 Graphiques 2D . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6.3 Introduction à plot3d . . . . . . . . . . . . . . . . . . . . . . . 35
6.4 Sauvegarde d’un graphe . . . . . . . . . . . . . . . . . . . . . 36

1
 Cours de calcul numérique
Mr Diakhaté : Fac Sciences Ucad

Résumé
L’analyse numérique s’attache à fournir des moyens pour donner
des solutions approchées à des problèmes mathématiques dont la ré-
solution explicite est généralement impossible ou impraticable. les so-
lutions approchées sont le plus souvent calculées sur ordinateur au
moyen d’un algorithme convenable. Idéalement, elles devraient s’ac-
compagner d’une majoration de l’écart avec les solutions réelles. Les
méthodes numériques développées étant destinées à être vraiment uti-
lisée et les calculs étant faits sur ordinateur, se posent les questions de
la précision finie sur un ordinateur, des erreurs d’arrondis, des opéra-
tions arithmétiques (+, −, ×, /) inexactes, · · ·
Exemple1 : à six chiffres significatifs 1 + 10−7 = 1.
Exemple2 : trouver x tel que x3 + x + 1 = 0.
Un algorithme ne sera donc jamais “exactement” calculé dans un or-
dinateur. Il est donc primordial d’étudier l’influence de tous les types
“d’erreurs” et des perturbations de toute nature sur les algorithmes.
Deux notions sont fondamentales en analyse numérique :
1. La stabilité qui est la capacité d’une méthode à “bien” se com-
porter en présence “d’imprécisions”
2. La précision qui mesure la capacité d’une méthode à approcher
la solution “vite et bien”.

2
Première partie
Algorithmique
1 Introduction à scilab
Scilab est un logiciel libre de calcul numérique développé par l’I.N.R.I.A
(Institut de Recherche en Informatique et en Automatique), disponible gra-
tuitement pour tout type d’ordinateur (pc, window, linux, unix, · · · ) à
l’adresse http ://www.scilab.org. Scilab est à la fois un language de pro-
grammation et (surtout) une bibliothèque très riche d’algorithme de calcul
numérique. Nous d’écrirons une partie des possibilités de scilab, essentielle-
ment celles qui permettent la mise en pratique de notions d’analyse numé-
rique comme :
1. La manipulation des matrices et vecteurs de nombres flottants ;
2. Les fonctions (macros),
3. La programmation en scilab ;
4. quelques commandes graphiques ; etc · · ·

1.1 Démarrage
On suppose que scilab est déjà installé sur l’ordinateur qui peut se faire
soit à partir d’un CD Room, soit par téléchargement depuis le site web de
l’I.N.R.I.A. Le lancement de scilab se fait sous window en double cliquant
sur l’icône scilab, sous Unix/Linux taper "scilab". La fenêtre scilab apparaît
alors à l’écran. Notons la zone située dans le bas de la fenêtre après le prompt
(signe − − →) permet à l’utilisateur d’entrer les commandes scilab. C’est
aussi dans cette zone que le logiciel affiche les résultats des instructions à
l’exception des graphiques qui sont affichés dans une autre fenêtre. On peut
se déplacer sur les commandes déjà validées par les flèches directionnelle
↑ et ↓.

1.2 Variables, constantes, opérations élémentaires

Nous allons passé en revue quelques types de variables scilab ainsi que
des opérations élémentaires sur ces variables.

3
1.2.1 Scalaires (réels et complexes)
Scilab est un langage qui possède une syntaxe simple dont l’instruction
d’affectation prend la forme :

variable = expression

ou simplement
expression
ou dans ce dernier cas la valeur de expression est affectée à une variable, par
√
défaut ans. Voici par exemple les déclarations
√ des nombres réels x = 1 + 5
−3
et y = 10 et le nombre z = 3 − i 5 ainsi que quelques opérations élémen-
taires sur ces nombres.

-->x=1+sqrt(5)
x =

3.236068

-->y=10^(-3)
y =

0.001

-->y=1.e-3
y =

0.001

z=3-sqrt(5)*%i
√ // %i désigne le nombre complexe i
z =3−i 5

− → h = z + %i ∗ x // h = z + ix

h=
3.+i

Notons le rôle des // qui indique à scilab que tout ce qui se trouve à droite
de ce signe ne doit pas être lu, il servira alors pour écrire des commentaires.

4
Signalons aussi l’effet de ”; ” à la fin d’une instruction signifiant que l’ins-
truction est effectuée, mais le résultat n’est pas affiché comme le montre les
exemples ci-dessous :

-->a=1+3^2
a =

10. // le résultat est affiché

-->a=1+3^2; // le résultat n’est pas affiché

--> c=2*a
c=
20 // le résultat est affiché; il en est de même si
l’instruction se terminait par une virgule.

On peut continué une instruction sur la ligne suivante en terminant la ligne

courante par trois points de suspensions "· · ·".
−→

a=20; c=2*7- ...

−→a
(c = 2 ∗ 7 − a)

c=
-6

On peut écrire plusieurs instructions sur un même ligne. Elles doivent être
séparées par des virgules ou des points virgules.
− → z = 3 + 2 ∗ %i, x = real(z); y = imag(z); w = y − %i ∗ x, h = w/abs(z)

z= // z=x+iy
3. + 2.i

w= // w=y-ix
2. - 3.i

h= // h=w/||z||
0.5547002 - 0.8320503i

5
abs étant la valeur absolue d’un réel ou le module d’un complexe. On peut
aussi utiliser la commande norm. Notons aussi la variable ans crée par sci-
lab à chaque fois que l’évaluation d’une expression n’est pas assignée à une
variable.
−→2+3
ans=
5
− → x = 12
x=
12
− → ans
ans=
5
sqrt(ans)

ans=
2.236068

− → ans ∗ ans
ans=
5

1.3 Les constantes

Les variables précédées d’un % sont des constantes ou variables protégées.
Elles ne peuvent être ni effacées, ni modifiées. exemple %pi, %e, %eps, %inf
%i etc, · · ·.
-->%pi
%pi =

3.1415927

-->clear %pi
!--error 13
Redefinition d’une variable permanente.

6
-->%eps
%eps =

2.220D-16

-->%inf-%inf
ans =

Nan

1.4 Les chaînes de caractères ou string

Exemple de définition de chaînes de caractères ou string.

-->s=’sujet’, v=’verbe’, c=’complémént d’’objet’

s =

sujet
v =

verbe
c =

complément d’objet
La concatenation des chaînes de caractères se fait par le symbole +
-->S=s+" "+v+" "+c
S =

sujet verbe complément d’objet

1.5 Les variables logiques ou booléennes

Les constantes booléennes sont %t et %f . Elles correspondent à des ex-
pressions logiques vrai pour %t ou faux pour %f . Exemples
-->a=2>3, b=2<3, c=%t
a =

F // la variable a est fausse

7
 b =

T // les variables b et c sont vraies

c =

T
La négation d’un booléen est obtenue par $~a$
-->~a
ans =

T
Le et logique est donné le signe &, le ou logique correspond au signe |
(touche ALT et 6 ) comme le montre les exemples suivants:
-->a&b, ~a&b, a&~b
ans =

F
ans =

T
ans =

-->a|b, ~a|b, a|~b

ans =

T
ans =

T
ans =

F
Tout nombre réel a est assimilé à un booléen par scilab vrai si a
est non nul et faux sinon.
-->a=125; b=0.0;c=-1.23; ~a, a&b, b|c
ans =

F
ans =

8
 F
ans =

Donnons quelques opérateurs de comparaison, utiles pour définir des boo-

léens.
= = égal à
<> ou = n’est pas égal à
< inférieur à
> supérieur à
<= inférieur ou égal à
>= supérieur ou égal à

2 Les matrices
Une matrice est un tableau de données à n lignes et m colonnes. On note
M = (mij ), i et j parcourant respectivement les ensembles {1, · · · , n} et
{1, · · · , m}. mkl est appelé élément de la k−ème ligne et de la l−ème colonne
de la matrice M .
1. Si n = 1, M est une matrice 1 ligne et m colonnes. C’est donc un
vecteur ligne.
2. Si m = 1, M est une matrice n lignes et 1 colonne. C’est donc un
vecteur colonne.
Une vecteurs est donc une matrice particulière. Commençons par étudier
les vecteurs.
La syntaxe suivante permet de définir un vecteur :

-->v=[2,-3+%i,7] // vecteur ligne

v =

2. - 3. + i 7.

-->v’ // vecteur transposé conjugué

ans =

2.
- 3. - i
7.

9
-->v.’ // vecteur transposé
ans =

2.
- 3. + i
7.

-->w=[-3;-3-%i;2] // vecteur colonne

w =

- 3.
- 3. - i
2.
-->v’+w //somme de deux vecteurs
ans =

- 1.
- 6. - 2.i
9.

-->v*w //produit scalaire euclidien

ans =

18.

-->w’.*v // produit des composantes

ans =

- 6. 8. - 6.i 14.
-->w’./v // division des composantes
ans =

- 1.5 1. 0.2857143
-->w’.^v // puissance des composantes

Les composantes des vecteurs lignes sont séparées par des virgules ou des
blancs, tandis que celles des vecteurs colonnes sont séparées par des points
virgules. Des messages d’erreur sont affichées si une opération impossible est
tentée.

10
Une autre syntaxe permettant de définir un vecteur est la suivante :

v = a : h : b.

Ainsi v est un vecteur de première composante a, de dernière composante

“éventuellement” b et de pas égal à h,

v = [a, a + h, a + 2 ∗ h, · · · , ].

-->v=1:5.1:23 // vecteur à incrément constant h=5.1

v =

1. 6.1 11.2 16.3 21.4

notons que la valeur b=23 n’est pas atteinte.
-->u=13:-3:4 // vecteur à incrément constant h=-3
u =

13. 10. 7. 4.

La valeur de la dernière composante du vecteur est atteinte ou pas selon le

pas h.
Il est aussi possible d’utiliser la commande linspace pour définir un vecteur.
Sa syntaxe est la suivante : x=linspace(a,b,n). Dans ce cas x est un vecteur
ligne de première composante a de dernière composante b et de nombre de
composantes n (n est optionnel et vaut par défaut 100). Les composantes de
x sont équidistantes.

-->x=linspace(0.25,1,5) // vecteur à 5 composantes

x =

0.25 0.4375 0.625 0.8125 1.

Passons au cas général.

Un matrice peut être définie explicitement en énumérant ses éléments : Les
lignes sont séparées par des ”; ” et les élément d’un même ligne sont séparés
par des ”, ” ou des blancs. Enfin [] désigne la matrice vide. Exemples :

11
-->M=[1 2 3;4 5 6], N=[1+2*%i, 3; %i, 5], C=[],...
-->D=[sin(1) %pi; 3*%pi cos(%pi)]
M =

1. 2. 3.
4. 5. 6.
N =

1. + 2.i 3.
i 5.
C =

[]
D =

0.8414710 3.1415927
9.424778 - 1.
-->E=[’scilab’ ’est un’; ’logiciel’ ’de calcul’] // matrice de string
E =

!scilab est un !
! !
!logiciel de calcul !
On peut accéder à un élément de la matrice M en désignant les deux indices
ligne et colonne.
-->M(2,1), M(1,1),M(1,2)
ans =

4.
ans =

1.
ans =

2.

-->E(2,2)
ans =

de calcul

12
Les dimensions d’un matrice c’est à dire le nombre de lignes et le nombre de
colonnes sont données par la commande size
-->size(M)
ans = // deux lignes et trois colonnes

2. 3

2.1 Opérations sur les matrices

Soient a et b deux matrices de même dimensions n.m. Les instructions
a + b, a − b ont leur sens mathématique usuel. Les instructions c = a. ∗ b,
d = a./b et e = a.b sont définies respectivement par
b
ci,j = ai,j ∗ bi,j , di,j = ai,j /bi,j , ei,j = ai,ji,j ,
la division n’étant définie que si les composantes bi,j ne sont pas nulles. Si a
et b sont deux matrices de dimensions respectives n.m et m.p, l’instruction
a ∗ b a son sens usuel, la multiplication matricielle. Toutes ces instructions
ne sont acceptées par scilab que quand elles sont bien définies.
-->a=[1 2; 3 4];b=[5 6 ;7 8];c=[1 2 3;4 5 6];

-->a+b
ans =

6. 8.
10. 12.

-->a+c
!--error 8
Addition incohérente.
-->c*b // la taille de c et b ne sont pas compatibles
!--error 10
Multiplication incohérente.
-->a=[1 2 3 ;4 5 6];

-->a-4
ans =

- 3. - 2. - 1.
0. 1. 2.

13
Les commandes sum et prod renvoient respectivement la somme et le pro-
duit des éléments d’une matrice donnée. Exemple :
-->a=[1 2 3;4 5 6;7 8 9]
a =

1. 2. 3.
4. 5. 6.
7. 8. 9.

-->s=sum(a)
s =

45.

-->p=prod(a)
p =

362880.
Scilab dispose des fonctions mathématiques usuelles, quelques unes sont don-
nées dans le tableau suivant :
Ecriture mathématique Ecriture scilab
sin(x) sin(x)
tg(x)
√ tan(x)
x sqrt(x)
exp(x) exp(x)
ln(x) log(x)
log à base 10 de x log 10(x)

Si f est une fonction définie dans scilab, l’instruction f (a) où a est une
matrice, définit une matrice, de même taille que a, dont les composantes
sont obtenues en appliquant f aux composantes de a :

(f (a))i,j = f (ai,j ).

-->a=[1 2 3 ;4 5 6]
a =

1. 2. 3.
4. 5. 6.

14
-->sin(a) // f=sin dans ce cas
ans =

0.8414710 0.9092974 0.1411200

- 0.7568025 - 0.9589243 - 0.2794155
-->b=[4 9; 16 25]
b =

4. 9.
16. 25.

-->sqrt(b)
ans =

2. 3.
4. 5.

2.2 Les matrices prédéfinies

Il existe dans scilab un certain nombre de matrices prédéfinies. Quelques
unes sont données dans le tableau suivant :

zeros(n, m) matrice nm dont les coefficients sont nuls

ones(n, m) matrice nm dont les coefficients sont égaux à 1
eye(n, m) matrice nm dont les coefficients diagonaux sont égaux à 1
rand(n, m) les coefficients sont compris entre 0 et 1, obtenus de façon aléatoire
diag(a) vecteur contenant les élément diagonaux de la matrice a
diag(u) matrice carrée dont la diagonale est u et le reste des éléments 0
diag(u, i) matrice carré dont la sur-diagonal (i>0) de numéro i est u, et le reste 0

Exemples :

->c=eye(2,3)
c =

1. 0. 0.
0. 1. 0.

-->u=[1 2 3 4]
u =

15
 1. 2. 3. 4.

-->u=[1 2 3 ]; diag(u)
ans =

1. 0. 0.
0. 2. 0.
0. 0. 3.

-->diag(u,-1)+10*diag(u,1)
ans =

0. 10. 0. 0.
1. 0. 20. 0.
0. 2. 0. 30.
0. 0. 3. 0.

2.3 Extraction, insertion de matrices

Si a est une matrice, la commande

a(i1 : i2 , j1 : j2 )

renvoie une matrice dont les éléments sont les éléments de la matrice a dont
l’indice de la ligne est compris entre i1 et i2 et l’indice de la colonne entre j1
et j2 . La commande
a(:, j1 : j2 )
renvoie les colonnes de j1 à j2 . De même, la commande

a(i1 : i2 , :)

renvoie les lignes de i1 à i2 . Exemples : Soit

 
21 −5 10 20
 26 12 −26 −18 
a= 
 −7 11 −38 −64 
5 5 −4 6

16
-->a=[21 -5 10 20; 26 12 -26 -18; -7 11 -38 -64; 5 5 -4 6]
a =

21. - 5. 10. 20.

26. 12. - 26. - 18.
- 7. 11. - 38. - 64.
5. 5. - 4. 6.

-->a(2:3,1:3) // sous matrice de a

ans =

26. 12. - 26.

- 7. 11. - 38.
-->a(:,2:4) // extraction des colonnes de 2 à 4.
ans =

- 5. 10. 20.
12. - 36. - 18.
11. - 38. - 64.
5. - 4. 6.
-->a(1:2,:)// extraction des lignes 1 et 2
ans =

21. - 5. 10. 20.

26. 12. - 36. - 18.

-->a(:,2) //deuxième colonne de a

ans =

- 5.
12.
11.
5.

-->a(3,:) //troisième ligne de a

ans =

- 7. 11. - 38. - 64.

17
Le symbole $ est utilisé pour indiquer la dernière ligne ou la dernière colonne
d’une matrice.Exemple

-->a(:,$) // dernière colonne

ans =

20.
- 18.
- 64.
6.
-->a($,:) // dernière ligne
ans =

5. 5. - 4. 6.

-->a($-2,:)
ans =

26. 12. - 36. - 18.

-->a(2:$,3:$)
ans =

- 36. - 18.
- 38. - 64.
- 4. 6.

Plus généralement si u et v sont deux vecteur et a une matrice, l’instruction

a(u, v)

renvoie une matrice formée des intersections des lignes de a dont les indices
appartiennent à u et à des colonnes de a dont les indices appartiennent à v.

-->u=[1 3]; v=[2 4];

-->a(u,v)
ans =

- 5. 20.
11. - 64.
-->a=[21 -5 10 20; 26 12 -26 -18; -7 11 -38 -64; 5 5 -4 6]
a =

18
 21. - 5. 10. 20.
26. 12. - 26. - 18.
- 7. 11. - 38. - 64.
5. 5. - 4. 6.

-->a(2:3,:)=[] // suppression de la 2ème et la 3ème ligne

a =

21. - 5. 10. 20.

5. 5. - 4. 6.
-->a(:,1:3)=[] // dernière colonne
a =

20.
- 18.
- 64.
6.

Exercice 1
1- Définir la matrice d’ordre n (carrée) suivante sans boucle (Voir le détail de
la commande diag à l’aide du Help)
 
2 −1 0 ... 0
. .. .. .
 −1 . . . . ..
 

A=
 ... ... ... 
 0 0 

 . . .. ..
 .. ..

. . −1 
0 ··· 0 −1 2
2- En déduire la matrice B, obtenue à partir de A en remplaçant sa dernière
colonne par
-->v=[1;2;3;4;5]
v =

1.
2.
3.
4.
5.

19
3- Extraire la sous-matrice
 
2 −1 0
C=
−1 2 −1

4- On reprend la matrice A de la première question. Que font les instructions :

[n1, n2] = size(A)?,diag(diag(A))? ,det(A)?, inv(A)?, spec(A)?

20
3 Les polynômes
3.1 Polynômes simples
L’Objet polynôme existe en scilab on peut le définir directement de deux
manières :
1. à partir des racines
-->p=poly([1 2],’x’) // polynôme en x dont les racines sont 1 et 2,
p =

2
2 - 3x + x //puissances croissantes de x

ou bien:

-->p=poly([1 2],’x’,’r’) // polynôme en x dont les racines sont

1 et 2, r=root.
p =

2
2 - 3x + x // puissances croissantes de x
2. à partir des coefficients
-->q=poly([1 2],’x’,’c’) // polynôme en x dont les coefficients
sont 1 et 2.
q =

1 + 2x
Les opérations usuelles avec les polynômes sont prévues par scilab :
-->p+q // addition
ans =

2
3 - x + x

-->p*q // multiplication
ans =

2 3
2 + x - 5x + 2x

21
-->p/q // division
ans =

2
2 - 3x + x
----------
1 + 2x
On peut définir la variable x comme un polynôme égale à x:
-->poly(0,’x’) // polynôme en x de racine zéro.
-->x=poly(0,’x’) // x est un polynôme
on peut alors saisir directement les polynômes
exemple p=216-7*x^17+3*x^250.

3.2 Matrices des polynômes

Exemple : Taper les commandes suivantes

-->p=poly([1 2 3 4],’x’,’c’);

-->H=[p,derivat(p);p-1,derivat(p)*p/(p^2+1)];

-->H(’num’);

-->H(’den’);

-->derivat(H);

Evaluation d’un polynôme en un point ou un un ensemble de points. Exemples

-->p=poly([2 3 4 5],’x’,’r’)
p =

2 3 4
120 - 154x + 71x - 14x + x

-->p12=horner(p,12) // calcul de p(12)

p12 =

5040.

-->v=[6 7 8]; pv=horner(p,v)// calcul p(v) avec v vecteur

22
 pv =

24. 120. 360.

-->x=2:0.3:3; px=horner(p,x)// calcul p(x) avec x vecteur
px =

0. - 0.9639 - 0.8064 - 0.2079

Exercice 2 1o ) Écrire de deux manières différentes le polynôme

P (x) = x7 + 3x2 + 8x − 12.

2o ) Donner une évaluation de ce polynôme au point

x = linspace(1, 7, 12).

4 Fichiers de données, scripts et fonctions

4.1 Fichiers de données
Il est possible de sauvegarder des données dans un fichier. Supposons
qu’on ait crée deux matrices A et B et qu’on veuille les sauvegarder. La com-
mande save permet d’enregistrer ces deux données sur un fichier nommé par
exemple ’sauvegarde’. Ces matrices peuvent être récupérées ultérieurement
par la commande load . Exemple
-->A=12*eye(5,3)+rand(5,3)
A =

12.28065 0.6856896 0.4094825

0.1280058 12.153122 0.8784126
0.7783129 0.6970851 12.113836
0.2119030 0.8415518 0.1998338
0.1121355 0.4062025 0.5618661

-->B=[1 2 3 4;7 5 4 12]

B =

23
 1. 2. 3. 4.
7. 5. 4. 12.

-->save(’sauvegarde’,A,B)

-->clear
-->A
!--error 4
Variable non définie: A
-->load(’sauvegarde’,’A’,’B’)
-->A
A =

12.211325 0.6283918 0.5608486

0.7560439 12.849745 0.6623569
0.0002211 0.6857310 12.726351
0.3303271 0.8782165 0.1985144
0.6653811 0.0683740 0.5442573

Jusqu’à présent, scilab a été utilisé de manière conventionnelle, c’est à dire

que les résultats des commandes apparaissent au fur et à mesure qu’on les
validait. Il est possible d’écrire ces suites d’instructions dans des fichiers qui
pourront être appelés durant une session. On distingue deux types de fichiers :
les “scripts” et les “fonctions”.

4.2 Écrire et exécuter un script

On peut écrire dans un fichier appelé par exemple "nomfich" une suite de
commandes dans l’éditeur texte intégré à scilab nommé scipad (en clinquant
sur le premier item de la fenêtre scilab), le nommé par l’instruction file puis
save as dans un répertoire et les faire exécuter par l’instruction :
Execute puis load into scilab.
Dans le cas ou le fichier existe, il est possible de le chargé à partir d’une
fenêtre scipad vierge. On obtient alors un menu qui permet de sélectionner le
fichier en question, en cliquant sur l’item file (éventuellement en changeant
le répertoire courant) et il ne reste plus qu’à cliquer sur le bouton Execute
puis load into scilab.
Remarque 1 Pour s’y retrouver dans les fichiers Scilab, il est recommandé
de suffixer le nom des fichiers scripts par la terminaison .sce (alors qu’un
fichier contenant des fonctions sera suffixé en .sci).

24
 Exemples :
i Ouvrir un éditeur scipad et taper les suites d’instructions scilab (script)
suivantes dans un fichier nommé "statist" :
xi=[1 ,2 ,3 ,4 ,5 ,12, 21 ,34];
ni=[2 ,4 ,1 ,9 ,5 ,2, 2 ,3];
n=length(xi);
moy_pond=sum(ni.*xi)/n
var=sum(ni.*xi.^2)/n -moy_pond^2
ecar_type=sqrt(var)
ii Créer un script contenant les instructions suivantes :
a = input(" Rentrer la valeur de a : ");
b = input(" Rentrer la valeur de b : ");
n = input(" Nb d’’intervalles n : ");
x = linspace(a,b,n+1); // calcul des abscisses
y = exp(-x).*sin(4*x); // calcul des ordonnées
plot(x,y) // un petit dessin)

4.3 Fichiers de fonctions

Pour définir une fonction en scilab, la méthode la plus courante est de
l’écrire dans un fichier, dans lequel on pourra d’ailleurs mettre plusieurs fonc-
tions( en regroupant par exemple les fonctions qui correspondent à un même
thème ou une même application).
Chaque fonction doit commencer l’instruction :

f unction[y1 , y2 , y3 , · · · , yn ] = nomf onct(x1 , x2 , · · · , xm )

où les xi sont les arguments d’entrée, les yi étant les arguments de sortie et
nomfonct est le nom donné à la fonction. Vient ensuite le corps de la fonc-
tion (qui permet de calculer les arguments de sortie à partir des arguments
d’entrée). La fonction doit se terminer par le mot clé endfunction.

25
 Soit le schémat suivant :

f unction [y1 , y2 , y3 , · · · , yn ] = nomf onct(x1 , x2 , · · · , xm )

y1 = · · · · · ·
y2 = · · · · · ·
·········
yn = · · · · · ·
endf unction

Remarque 2 La tradition est de suffixer les noms des fichiers contenant des
fonctions en .sci d’après la remarque1

Remarque 3 L’appel de la fonction se fait en copiant

[y1 , y2 , y3 , · · · , yn ] = nomf onct(x1 , x2 , · · · , xm ),

de la première ligne et en collant sous endfunction. Ensuite remplacer les

xi , i = {1, · · · , m} par leur valeur numérique. On récupère alors les valeurs
numériques des yi , i = {1, · · · , n}.
Si le nom de la fonction ("nomfonct" ) est f , on a

[y1 , y2 , y3 , · · · , yn ] = f (x1 , x2 , · · · , xm )

ou encore
f : Rm → Rn

Ouvrir un éditeur scipad et taper les suites d’instructions scilab (script) sui-
vantes dans un fichier nommé "facto", puis l’executer avec différentes valeurs
de n.

function [y]=facto(n)
y=prod(1:n);
endfunction
[y]=facto(12) //appel de la fonction en n=12

Ouvrir un éditeur scipad et taper les suites d’instructions scilab (script) sui-
vantes dans un fichier nommé "sodipr", puis l’executer avec différentes valeurs
des arguments d’entrée.

26
function [s,d,p]=sodipr(x,t)
s=x+t;
d=t-x
p=x.*t
endfunction
[s,d,p]=sodipr(2,12)// appel de la fonction en (x,t)=(2,12)

Remarque 4 Si f est une fonction définie dans l’environnement, x un vec-

teur et s une variable scalaire alors : s./f (x) est un vecteur de même taille
que x dont la ième composante est égale à s/f (xi). Ainsi pour calculer le vec-
teur de composante 1/f (xi), il semble que l’on puisse utiliser : 1./f (x) mais
comme 1. est syntaxiquement égal à 1, le résultat n’est pas celui escompté.
La bonne manière d’obtenir ce que l’on cherche est d’entourer le nombre avec
des parenthèses ou de rajouter un blanc entre le nombre et le point :
(1)./f (x) // ou encore 1 ./f (x) ou 1.0./f (x)

Exercice 3 Soit X une matrice (ou un vecteur · · ·)que l’on définie dans
l’environnement. Écrire l’instruction qui permet de calculer la matrice Y (de
même taille que X) dont l’élément en position (i, j) est égal à f (Xi,j ) dans
les cas suivants :
1. f (x) = 2x2 − 3x + 1
2. f (x) = |2x2 − 3x + 1|
1
3. f (x) = 1+x 2

Remarque 5 Une possibilité intéressante de Scilab est que l’on peut définir
directement une fonction dans l’environnement (sans passer par l’écriture
d’un fichier puis le chargement par getf ) par l’intermédiaire de la commande
deff dont voici la syntaxe simplifiée :

def f (0 [y1, y2, ...] = nomf onction(x1, x2, ....)0 , text)

où text est un vecteur colonne de chaînes de caractères, constituant les ins-

tructions successives de la fonction. Par exemple, on aurait pu utiliser :

def f (0 [y] = f (x)0 ,0 y = sin(x). ∗ exp(−abs(x))0 )

Pour définir la fonctions précédentes. En fait cette possibilité est intéressante

dans plusieurs cas :
- dans un script utilisant une fonction simple qui doit être modifiée assez
souvent ; dans ce cas on peut définir la fonction avec deff dans le script ce qui
évite de jongler avec un autre fichier dans lequel on aurait défini la fonction
comme d’habitude ; cette possibilité est moins intéressante que la définition

27
étudiée ci-dessus (function · · ·) endfunction).
- la possibilité vraiment intéressante est de pouvoir définir une partie du code
de façon dynamique :
on élabore une fonction à partir d’éléments divers issus de calculs précédents
et /ou de l’introduction de données (via un fichier ou de façon interactive (cf
Fenêtres de dialogues)).

5 Programmation en scilab
Scilab, en dehors des primitives toutes prêtes (qui permettent avec les ins-
tructions matricielles, une programmation très synthétique proche du langage
mathématique, du moins matricielle) dispose d’un langage de programmation
simple mais assez complet. La différence essentielle par rapport aux langages
habituels (C, C + +, Pascal, ...) est que les variables ne sont pas déclarées :
lors des manipulations précédentes nous n’avons à aucun moment précisé la
taille des matrices, ni même leurs types (réelles, Complexes, ...). C’est l’in-
terpréteur de Scilab qui, lorsqu’il rencontre un nouvel objet, se charge de ce
travail. Cette caractéristique est souvent déconsidérée (avec raison, cf l’ancien
fortran) d’un point de vue génie logiciel car cela peut conduire à des erreurs
difficilement repérables. Dans le cas de langage comme Scilab (ou Matlab)
cela ne pose pas trop de problèmes, car la notation vectorielle/matricielle et
les primitives toutes prêtes, permettent de restreindre considérablement le
nombre de variables et de lignes d’un programme (par exemple, les instruc-
tions matricielles permettent d’éviter un maximum de boucles). Un autre
avantage de ce type de langage, est de disposer d’instructions graphiques (ce
qui évite d’avoir à jongler avec un programme ou une bibliothèque graphique)
et d’être interprété (ce qui permet de chasser les erreurs assez facilement, sans
l’aide d’un débogueur). Par contre l’inconvénient est qu’un programme écrit
en Scilab est plus lent (voire beaucoup plus lent) que si vous l’aviez écrit
en C (mais le programme en C a demandé 50 fois plus de temps d’écriture
et de mise au point · · ·). D’autre part, pour les applications où le nombre
de données est vraiment important (par exemple des matrices 1000 × 1000)
il vaut mieux revenir à un langage compilé. Un point important concernant
la rapidité d’exécution est qu’il faut programmer en utilisant au maximum
les primitives (commandes) disponibles et les instructions matricielles (c’est
à dire : limiter le nombre de boucles au maximum). En effet, dans ce cas,
Scilab appelle alors une routine (fortran) compilée, et donc son interpréteur
travaille
moins · · · .Pour bénéficier du meilleur des deux mondes (c’est dire de la ra-
pidité d’un langage compilé et du confort d’un environnement comme celui

28
de Scilab), nous avons des facilités pour lier à Scilab des sous-programmes
fortran (77) ou C.

5.1 Les boucles

Il existe deux types de boucles : la boucle for et la boucle while.

5.1.1 La boucle for

La boucle for itère sur les composantes d’un vecteur ligne. La syntaxe de
la boucle for est la suivante :

f or var = a : h : b

instructions
end
La variable var prend la valeur a, puis toutes les valeurs de la forme a + k ∗ h
sans jamais dépasser la valeur b et execute les instructions. Exemples :

-->for i=1:5:20
-->instruction=i*i
-->end
instruction =

1.
instruction =

36.
instruction =

121.
instruction =

256.
-->u=[1 3 7 8];

-->for i=u
-->i/2
-->end
ans =

29
 0.5
ans =

1.5
ans =

3.5
ans =

4.
Notons la variante suivante (écriture sur une ligne)
-->for i=1:3:10, i^{3}-4*i, end;
ans =

- 3.
ans =

48.
ans =

315.
ans =

960.

Exercice 4 Utilisation de la boucle for pour définir une matrice. Ouvrir un

éditeur scipad et taper le script suivant :

n=4; a=zeros(n,n);
for i=1:n-1
a(i,i)=2; a(i,i+1)=-1;a(i+1,i)=-1;
end;
a(n,n)=2;
a

5.1.2 La boucle while

La syntaxe de la boucle while est la suivante :

30
| while expression (do) | while expression
| instructions ou | instructions1
| end | else
| instructions2
| end
Les instructions sont exécutées tant que le booléen "expression" est vrai.
Dans la variante avec "else", les instructions "instructions2" sont effectuées
si le booléen "expression" est faux.
Exemple:
-->x=1;

-->while x<4
-->x=3*x
-->end
x =

3.
x =

9.
Écriture sur une ligne:
x=1;while x<4,x=3*x,end
-->x=3
-->x=9
Exemple:
-->x=9;
-->while x-exp(-x)> %eps do
-->x=x-0.001;
-->end
-->x, exp(-x)
x =

0.567
ans =

0.5672246

5.2 L’instruction conditionnelle if

La syntaxe est la suivante

31
| if condition then | if condition then
| instructions ou | instructions1
| end | else
| instructions2
| end

où "condition" est une expression logique (un booléen) ou une expression

numérique. les "instructions" ne sont exécutées que si l’expression logique
"condition" est vraie. Ouvrir un éditeur scipad et taper le script suivant :

a=0.99;
if a>1 then
c=log(a-1);
end;
c
a=0.9;
if a>0 then
if a>1 then
f=1;
else
f=a*a;
end
else
f=0;
end
f

6 Représentations graphiques en scilab

6.1 Les fenêtres Graphiques
Dans ce domaine, Scilab possède de nombreuses possibilités qui vont de
primitives de bas niveau (exemples : tracés de rectangles, de polygones (avec
ou sans remplissage), récupérer les coordonnées du pointeur de la souris), à
des fonctions plus complètes qui permettent en une seule instruction de tracer
toutes sortes de graphiques types. Dans la suite, nous expliquons seulement
une petite partie de ces possibilités. Il faut savoir que scilab dispose, depuis
la version 3.0, d’un nouveau mode graphique ne fonctionnant pas de la même
manière que l’ancien mode (version). Dans ce chapitre on va essayer d’ap-
prendre à utiliser ce nouveau système. Comme dans l’ancien mode on peut
facilement travailler avec plusieurs fenêtres graphiques. Noter que parmi ces

32
fenêtres il y en a une seule, appelée fenêtre courante ou encore fenêtre active,
qui peut recevoir les ordres graphiques. Pour jongler avec plusieurs fenêtres
graphiques on utilise les commandes suivantes :
scf(num) la fenêtre courante devient la fenêtre de numéro num ;
xselect() met en "avant" la fenêtre graphique courante
clf([num]) efface le graphe de la fenêtre graphique de numéro num
xdel([num]) détruit la fenêtre graphique de numéro num

6.2 Graphiques 2D
Pour obtenir une représentation graphique en scilab il faut se donner :
– un vecteur d’abscisses, par exemple à l’aide d’incréments :
x = 0 : 0.1 : 2 ∗ %pi; ou x = linspace(0, 2 ∗ %pi, 101);
(ne pas afficher x ! ! !)
– un vecteur d’ordonnés y. On peut le construire à l’aide d’une fonction
scilab (function · · · endfunction), par la commande poly ou bien utiliser
les fonctions usuelles définies par scilab comme cos, sin,· · ·. On rappelle
que l’image d’un vecteur est un vecteur : si
v = [v1 , v2 , · · · , vn ], f (v) = [f (v1 ), f (v2 ), · · · , f (vn )]
Voici quelques exemples avec plot :
x=linspace(-1,1,61)’;// vecteur colonne
y = x.^2;//vecteur colonne comme x
plot(x, y)
Rajoutons maintenant une autre courbe :
ybis = 1 - x.^2;
plot(x, ybis)
xtitle("Courbes...") // je rajoute un titre
Continuons avec une troisième courbe qui ne tient pas dans
l’échelle précédente :
yter = 2*y;// vecteur colonne
plot(x, yter)
on remarque que Scilab a changé l’échelle pour s’adapter à
la troisième courbe et que les courbes précédentes ont été
redessinées dans cette nouvelle échelle. Il est possible d’afficher
les 3 courbes simultanément, en précisant aussi la couleur utilisée :
clf() // pour effacer le graphe de la fenêtre courante
plot(x, y,"b",x ,ybis, "r", x, yter,"g")
xtitle("Courbes...","x","y") // un titre plus une légende pour les deux axes
legend("x^2","1-x^2","2x^2") // une légende pour les courbes

33
plot2d : C’est la procédure de base pour représenter une courbe dans un
plan. La syntaxe est la suivante :

plot2d (M x, M y, [style, chaîne, légende, rectangle, axesflag])

On ne détaille ici que les principales options. (Consulter l’aide en ligne pour
une liste exhaustive.)
– M x, M y sont respectivement la matrice des abscisses et celle des or-
données, la kème courbe étant constituée par les kèmes colonnes de M x
et M y ; d’autre part, si toutes les courbes ont les mêmes abscisses, on
a pas à dupliquer le vecteur des abscisses : par exemple pour afficher
x, y1 , x, y2 , x, y3 , on utilisera

plot2d(x, [y1 y2 y3 ], · · ·)

si bien sûr tous ces vecteurs sont des vecteurs colonnes. nc=nombre de colonnes de My
est le nombre de courbe.
– style est un vecteur de dimension (1, nc). style(j) définit la manière
de représenter la courbe numéro j : si style(j) < 0 on utilise des mar-
queurs de code −style(j). si style(j) > 0 on utilise des lignes pleines
ou pointillées de couleur style(j)
– chaîne est une chaîne de trois caractères ”xyz” Si x = 1 la légende est
affichée, elle est fournie dans l’argument legende sous la forme

legende1@legende2@....

y gère le cadrage :
si y = 0 les bornes courantes sont utilisées.
si y = 1 l’argument rectangle est utilisé pour redéfinir les bornes

rectangle = [xmin, ymin, xmax, ymax]

si y = 2 les bornes sont calculées à partir des valeurs extrêmes de x et

y
z gère l’entourage du graphique :
z = 1 pour avoir des axes gradués
z = 2 pour avoir un cadre autour du graphique

Ouvrir un éditeur scipad et taper le script suivant :

clf()
x=linspace(-1,1,61)’;
y = x.^2;
ybis = 1 - x.^2;

34
yter = 2*y;
plot2d(x,[y ybis yter], style=[2 5 3],axesflag=5) // faire varier axesflag
axesflag=2,3 6,...
xtitle ("Courbes...","x","y")
legend ("x^2","1-x^2","2x^2")

spécifier l’échelle : Pour choisir le rectangle de visualisation, on utilise la

combinaison rect=val, mais attention, val est ici le vecteur [xmin, ymin, xmax, ymax]
(ne pas mettre de ; entre ymin et xmax comme pour régler la propriété.
Exemple :

m = 1000;
x = rand(1,m);
xm = cumsum(x)./(1:m);
clf();
plot2d((1:m)’,xm’, style=color("blue"), rect=[1,0,m,1])

Quant à l’échelle isométrique, on peut l’obtenir avec la combinaison

frameflag= val où val doit prendre la valeur 4 (échelle iso obtenue à partir
des maxima et minima des données) :

t = linspace(0,2*%pi,60)’;
x1 = 2*cos(t); y1 = sin(t); // une ellipse
x2 = cos(t); y2 = y1; // un cercle
x3 = linspace(-2,2,60)’; y3 = erf(x3); // la fct erreur
clf();
plot2d([x1 x2 x3],[y1 y2 y3],style=[2 5 6],frameflag=4)
legend("ellipse","cercle","fct erreur")
xtitle("Encore des courbes ...","x","y")

6.3 Introduction à plot3d

Si une surface est donnée par une équation du type z = f(x, y), il est
particulièrement simple de la représenter pour un domaine rectangulaire des
paramètres. Dans l’exemple qui suit nous représentons la fonction
f (x, y) = cos(x)cos(y) pour (x, y) ∈ [0, 2π] × [0, 2π] :

x=linspace(0, 2*%pi,31); // la discrétisation en x

(et aussi en y : c’est la même)
z=cos(x)’*cos(x); // le jeu des valeurs en z : une matrice
z(i, j) = f(x(i),y(j))
plot3d(x,x,z) // le dessin (ici y=x)

35
6.4 Sauvegarde d’un graphe
Les commandes xsave et xload permettent respectivement de sauvegar-
der (au format scilab) un graphique dans un fichier et de charger ce fichier.
– l’instruction xsave(’dessin.scg’, i) sauvegarde le dessin de la fenêtre nu-
méro i dans le fichier "dessin.scg". L’argument i est optionnel. L’ex-
tension ".scg" n’est pas obligatoire, mais recommandée car elle permet
de distinguer facilement les différentes type de fichiers scilab :
.sci, .sce, .scg.
– l’instruction xload(’dessin.scg’, i) charge le graphique sauvegardé dans
la fichier "dessin.scg" dans la fenêtre numéro i, ou la fenêtre courante.

Exercice 5 1o ) Écrire de deux manières différentes le polynôme

P (x) = x7 + 3x2 + 8x − 12.

2o ) Donner une évaluation de ce polynôme au point

x = linspace(1, 7, 12).

3o ) Tracer le graphe de ce polynôme sur un intervalle I, ajouter une

couleur,un titre et légende.

Exercice 6 Pour n ≥ 0 on pose

x2 x3 xn
Qn (x) = 1 + x + + + ··· + .
2 3 n
1o ) Écrire une fonction somme qui prend en argument un entier n et
donne comme résultat le polynôme Qn (x).
2o ) Tracer sur un même graphe les courbes représentatives des fonc-
tions
x 7→ Q3 (x), x 7→ Q5 (x), x 7→ log(1 − x),
de couleurs différentes entre x = 0 et x = 0.9, en y ajoutant un titre
(mes courbes) et une légende C3 , C5 , Clog .

36