TP2 - Vecteurs, Matrices Et Tracés Sous Scilab

Faculté des Sciences et Techniques
Département d’Informatique
MST SIDI – Module: TSN – A.U 2022/2023
TP n° 2 : Vecteurs, matrices et tracés 2D/3D sous Scilab

Objectifs du TP :
1. Création et manipulation des vecteurs et des matrices sous Scilab
2. Utilisation des opérateurs et fonctions prédéfinies pour la manipulation des matrices.
3. Création et manipulation des tracés 2D et 3D sous Scilab.
4. Dessin des représentation discrètes de quelques signaux élémentaires sous Scilab
Vecteurs et matrices sous Scilab
Dans Scilab, le type de données de base est la matrice, qui est définie par :
•Le nombre de lignes,
•Le nombre de colonnes,
•Le type de données.
Le type de données peut être réel, entier, booléen, chaîne et polynomial. Lorsque deux matrices ont le
même nombre de lignes et de colonnes, on dit que les deux matrices ont la même forme (shape).
Dans Scilab, les vecteurs sont un cas particulier de matrices, où le nombre de lignes (ou le nombre de
colonnes) est égal à 1. Les variables scalaires simples n’existent pas dans Scilab : une variable scalaire
est une matrice avec 1 ligne et 1 colonne.
Il est juste de dire que Scilab a été conçu principalement pour des matrices de variables réelles. Cela
permet d’effectuer des opérations d’algèbre linéaire avec un langage de haut niveau.
Par conception, Scilab a été créé pour pouvoir effectuer des opérations matricielles le plus rapidement
possible. Le bloc de construction de cette fonctionnalité est que les matrices Scilab sont stockées dans
une structure de données interne qui peut être gérée au niveau de l’interpréteur. La plupart des opérations
d’algèbre linéaire de base, telles que l’addition, la soustraction, la transposition ou le produit scalaire,
sont effectuées par un code source compilé et optimisé. Ces opérations sont effectuées avec les
opérateurs communs "+", "-", "*" et le guillemet simple "’", de sorte que, au niveau de Scilab, le code
source est à la fois simple et rapide.
Des tâches plus complexes d’algèbre linéaire, comme la résolution de systèmes d’équations linéaires,
des calculs de valeurs propres / vecteurs propres, sont également effectuées par des codes source
compilés et optimisés. Ces opérations sont effectuées par des opérateurs communs comme le slash "/"
ou backslash ou avec des fonctions comme spec, qui calcule les valeurs propres et les vecteurs propres.
Créer une matrice de valeurs réelles
Il existe une syntaxe simple et efficace pour créer une matrice avec des valeurs données. Voici la liste
des symboles utilisés pour définir une matrice :
• Les crochets "[" et "]" marquent le début et la fin de la matrice,
• Les virgules "," séparent les valeurs dans différentes colonnes,
• Points-virgules " ;" séparent les valeurs des différentes lignes.
La syntaxe suivante peut être utilisée pour définir une matrice, où les espaces sont facultatifs (mais
rendent la ligne plus facile à lire) et "..." indique des valeurs intermédiaires :
A = [a11, a12, ..., a1n; a21, a22, ..., a2n; ...; an1, an2, ..., ann]
Dans l’exemple suivant, nous créons une matrice 2 × 3 de valeurs réelles.

-->A = [1 , 2 , 3 ; 4 , 5 , 6]
A=
1. 2. 3.
4. 5. 6.
TP1 : Vecteurs, matrices et tracés 2D/3D sous Scilab Pr. Ahmed ELABBASSI/Pr. Abdelaaziz HESSANE
Une syntaxe plus simple est disponible, qui ne nécessite pas d’utiliser les virgules et les points-virgules.
Lors de la création d’une matrice, l’espace vide sépare les colonnes tandis que la nouvelle ligne sépare
les lignes, comme dans la syntaxe suivante :
A = [a11 a12 ... a1n
a21 a22 ... a2n
...
an1 an2 ... ann]
Cela permet d’alléger considérablement la gestion des matrices, comme dans l'exemple suivant.
-->A = [1 2 3
-->4 5 6]
A=
1. 2. 3.
4. 5. 6.
Plusieurs commandes Scilab permettent de créer des matrices à partir d’une taille donnée, c’est-à-dire à
partir d’un nombre donné de lignes et de colonnes. Les plus utilisées sont les eye, linespace, zeros, ones,
etc. Ces commandes prennent deux arguments d’entrée, le nombre de lignes et de colonnes de la matrice
à générer.
Exemples :
--> eye(4,4) --> linspace(0,1,6) --> ones(2,3) --> zeros(2,3)
ans = ans = ans = ans =
1. 0. 0. 0. 0. 0.2 0.4 0.6 0.8 1. 1. 1. 1. 0. 0. 0.
0. 1. 0. 0. 1. 1. 1. 0. 0. 0.
0. 0. 1. 0.
0. 0. 0. 1.
Exercice 1 : Tester et interpréter le résultat des matrice suivantes :

testmatrix('magi',3),
testmatrix('frk',10)
testmatrix('hilb',4)
grand(2, 3, "bin", 1, 0.3)
rand(3,4)
Remarques : Matrice vide

Une matrice vide peut être créée en utilisant des crochets vides, comme ci-dessous, où nous créons une
matrice 0 × 0.
--> M=[]
M =
[]
Cette syntaxe permet de supprimer le contenu d’une matrice, de sorte que la mémoire associée soit
libérée.
--> M=ones(3,3)
--> M=[]
M =
[]
Opérations sur les matrices :

Avec Scilab, on peut interroger ou mettre à jour une matrice à l’aide de quelques fonctions prédéfinies.
La fonction size renvoie les deux arguments de sortie nr et nc, qui sont les nombre de lignes et le nombre
de colonnes.
--> A=[1 4 5;3 7 9]
A =
1. 4. 5.
3. 7. 9.
--> [n,m]=size(A)
m =
3.
n =
2.
Exercice 2 : Tester et interpréter les commandes suivantes :

matrix(A,1,6)
matrix(A,3,2)
resize_matrix(A, -1, 5)
resize_matrix(A, 4, -1)
resize_matrix(A, 6, 6)
La fonction size a une valeur pratique importante lorsque nous concevons une fonction, car le traitement
que nous devons effectuer sur une matrice donnée peut dépendre de sa forme. Par exemple, pour calculer
la norme d’une matrice donnée, différents algorithmes peuvent être utilisés selon que la matrice est un
vecteur colonne de taille nr × 1 et nr> 0, un vecteur ligne de taille 1 × nc et nc> 0, ou une matrice
générale de taille nr × nc et nr, nc> 1.
La fonction size a aussi la syntaxe suivante nr = size(A,sel) qui permet d’obtenir uniquement le nombre
de lignes ou le nombre de colonnes et où sel peut avoir les valeurs suivantes :
• sel = 1 ou sel = "r", retourne le nombre de lignes,
• sel = 2 ou sel = "c", renvoie le nombre de colonnes.
• sel = "*", renvoie le nombre total d’éléments, c’est-à-dire le nombre de colonnes multiplié
par le nombre de lignes.
Exemples :
--> A=ones(5,3)
A =
1. 1. 1.
1. 1. 1.
1. 1. 1.
1. 1. 1.
1. 1. 1.
--> size(A,1)
ans =
5.
--> size(A,2)
ans =
3.
--> size(A,'*')
ans =
15.
Accéder aux éléments d’une matrice

Il existe plusieurs méthodes pour accéder aux éléments d’une matrice A :
• La matrice entière, avec la syntaxe A,
• Elément par élément avec la syntaxe A (i, j),
• Une plage de valeurs d’index avec l’opérateur " :" deux-points.
Un élément d’une matrice peut être accédé directement avec la syntaxe A(i, j), à condition
que i et j soient des valeurs d’index valides.
Nous soulignons que, par défaut, le premier indice d’une matrice est 1. Cela contraste avec d’autres
langages, tels que le langage C par exemple, où le premier indice est 0.
Par exemple, supposons que A est une matrice nr x nc, où nr est le nombre de lignes et nc est le nombre
de colonnes. Par conséquent, la valeur A(i, j) n’a de sens que si les valeurs d’indice i et j satisfont 1≤ i
≤ nr et 1 ≤ j ≤ nc. Si les valeurs d’index ne sont pas valides, une erreur est générée.
a. L’opérateur " :"
Avec un vecteur de valeurs indexées, nous pouvons accéder aux éléments d’une matrice dans un
intervalle donné, comme avec la syntaxe simplifiée suivante A(i : j, k : l) où i, j, k, l sont des valeurs
d’index de début et de fin. La syntaxe complète est A(i : s : j, k : t : l), où s et t sont les étapes.
Par exemple, supposons que A est une matrice 4 × 5, et que nous voulons accéder aux
éléments ai,j pour i = 1, 2 et j = 3,4. Avec le langage Scilab, cela peut être fait en une seule instruction
, en utilisant la syntaxe A(1 : 2, 3 : 4), comme indiqué dans l’exemple suivant :
--> A=testmatrix('magi',5)
A =
17. 24. 1. 8. 15.

23. 5. 7. 14. 16.
4. 6. 13. 20. 22.
10. 12. 19. 21. 3.
11. 18. 25. 2. 9.
--> A(1:2,3:4)
ans =
1. 8.
7. 14.
Exercice 3 : Tester et interpréter les commandes suivantes :

A(1,:)
A(:,3)
A(:,:)
A(:,3:4)
A(1:3,:)
b. L’opérateur dollar "$"

Habituellement, nous utilisons des indices pour faire référence à partir du début d’une matrice. Par
opposition, l’opérateur dollar "$" permet de référencer des éléments à partir de la fin de la matrice.
L’opérateur "$" signifie "l’index correspondant à la dernière" ligne ou colonne, selon le contexte. Cette
syntaxe est associée à une algèbre, de sorte que l’index $-i correspond à l’index l-i, où l est le nombre
de lignes ou de colonnes correspondantes.
Dans l’exemple suivant, nous considérons une matrice 3 × 3 et nous accédons à l’élément A (2,1) = A
(nr-1, nc-2) = A ($ -1, $ - 2) parce que nr = 3 et nc = 3.
A =
8. 1. 6.
3. 5. 7.
4. 9. 2.
--> A($-1,$-2)
ans =
3.
Ajout dynamique des éléments par l’opératuer $

L’opérateur dollar "$" permet d’ajouter des éléments dynamiquement à la fin des matrices.
A =
8. 1. 6.
3. 5. 7.
4. 9. 2.
--> A($+1,:)=[7 12 30]
A =
8. 1. 6.
3. 5. 7.
4. 9. 2.
7. 12. 30.
Exercice 4 : Evaluer et interpréter les commandes suivantes :

A(:,$+1) = [0,0,3]
A(:,$+1)=ones(1,1)
Opérations élémentaires
Si un point "." Est écrit devant un opérateur, il est associé à un opérateur élémentaire, c’est-à-dire que
l’opération est effectuée élément par élément.
Par exemple,
Avec l’opérateur de multiplication habituel "*", le contenu de la matrice C = A * B est 𝑐𝑖,𝑗 =
∑𝑛𝑘=1 𝑎𝑖,𝑘 𝑏𝑘,𝑗
Avec l’opérateur de multiplication élémentaire ". *", Le contenu de la matrice C = A.* B est 𝑐𝑖,𝑗 =
𝑎𝑖,𝑗 𝑏𝑖,𝑗
Exercice 5 :
Evaluer les opérateurs «Addition », « soustraction » entre deux matrices ou plus. Donner quelques
exemples avec le code Scilab correspondant.
Exercice 6 :
Compléter les lignes 5 et 6 du script de la fonction qmatrix.

Tracés 2D/3D sous Scilab
Les tracés dans le plan se font avec la commande plot. On peut choisir la couleur et l’aspect en mettant
les indications de couleur et de style de points entre guillemets :
Les couleurs :
"b" = bleu (par défaut), "k" = noir, "r" = rouge, "g" = vert, "c" = cyan, "m" = magenta, "y" = jaune,
"w" = blanc.
Les styles de points :
Reliés (part défaut), ou ".", "+", "o", "x", "*"
D’autres options sont disponibles avec : "s", "d", "v", "<", et ">".
Tracés de base
Pour tracer un point
Tracer le point A(1, 2) avec un point rouge :
Editeur Scilab Fenêtre graphique
plot(1,2,".r")
Pour tracer un segment

Tracer le segment [AB] en bleu (par défaut) avec A(1;2) et B(3;5)
plot([1, 3], [2, 5])
Tracés de courbes planes définies par des fonctions y = f(x)

Pour une fonction x→ f(x) on donne d’abord les valeurs de x avec la commande linspace en
écrivant : x = linespace(a,b,n) ; où a est la plus petite valeur de la variable x, b est la plus
grande valeur de x, et n est le nombre de valeurs qui seront calculées entre a et b.
Ne pas oublier le « ; » sinon les n valeurs de x s’afficheront.
Par exemple, soient deux fonctions f et g définies sur [-2 ; 5] par : 𝑓(𝑥) = (𝑥 2 + 2𝑥)𝑒 −𝑥 , et 𝑔(𝑥) =
𝑥
𝑠𝑖𝑛( )
2
Ci-dessous avec ce programme, on obtient le tracé de la courbe de f, en bleu par défaut.

En ajoutant le programme ci-dessous, on obtient le tracé des deux courbes, celle de f en rouge et celle
de g en vert. Le tracé précédent a été effacé grâce à la commande clf.
Tracés des nuages de points

Termes d’une suite
Le cas le plus courant est celui où l’on veut tracer les points M(n, u(n)) après avoir calculé les
coordonnées u(n) d’un vecteur u. On écrit alors plot(u, "*r")en spécifiant la forme (étoile non
reliées) et la couleur (rouge)
Statistiques doubles
Les nuages statistiques sont donnés sous la forme de deux vecteurs : appelons les X et Y, on écrira alors
plot(X, Y, "<") pour tracer le nuage des points M(Xi ; Yi) avec triangles bleus.
Tracés en 3D
Scilab permet de tracer des surfaces et des courbes dans l’espace avec un grand nombre d’options pour
le traitement des faces cachées, la couleur des faces, les points de vue, etc. Nous ne donnerons ici que
deux exemples.
La fonction surf permet de tracer une surface. Cette fonction prend trois variables d’entrée, x, y et
z. x et y sont des vecteurs de taille respective m et n correspondant à des points des axes (0x) et (0y). z
est une matrice de dimension n x m dont l’élément zij est la code du point de la surface d’abscisse xi
et d’ordinées yj.
Pour tracer la surface définie par une fonction de type z = f(x, y), il faut donc :
1. Définir la fonction f
2. Calculer z = feval(x, y, f)’ (feval(x,y,f) retourne la matrice m x n dont l’élément
ij est f(xi,yj) que l’on va transposer en utilisant l’apostrophe "’"
3. Appliquer surf(x, y, z)
Le tracé de la surface 𝑧 = 2𝑥2 + 𝑦2 (paraboloïde elliptique) :

La fonction param3d permet de tracer une courbe dans l’espace. param3d prend trois arguments, x,
y et z, qui sont des vecteurs de même taille correspondant aux points (xi, yi, zi) de la courbe.
Le tracé de l’hélice définie par (x = cos(t), y = sin(t), z= t) :
t=linspace(0,4*%pi,100);
param3d(cos(t),sin(t),t)
Exercice 7 :
Représenter les signaux élémentaires suivants : Impulsion de Dirac, Echelon, Rampe, Exponentiel,
Exponentiel inverse et Sinusoïdal.
TAD 2 :
Répondre aux exercices 1 → 7 ;
Consignes :
1. Utiliser la commande subplot pour afficher les 6 graphiques dans une seule figure.
2. Rédiger un compte rendu de 3 à 5 pages avec le code source des signaux générés
(Seulement le code source des exercices 6 et 7 est demandé, penser à nommer les
fichiers comme suit : exo6.sce et exo7.sce)
3. Le compte rendu concerne tous les exercices !
4. Des captures d’écran des résultats de l’exécution des codes sont envisagées.
5. Envoyer le rapport avant le 12/11/2022.
Bon courage !

TP2 - Vecteurs, Matrices Et Tracés Sous Scilab

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

TP2 - Vecteurs, Matrices Et Tracés Sous Scilab

Transféré par

Droits d'auteur :

Formats disponibles

Faculté des Sciences et Techniques

TP n° 2 : Vecteurs, matrices et tracés 2D/3D sous Scilab

Dans l’exemple suivant, nous créons une matrice 2 × 3 de valeurs réelles.

ans = ans = ans = ans =

1. 0. 0. 0. 0. 0.2 0.4 0.6 0.8 1. 1. 1. 1. 0. 0. 0.

Exercice 1 : Tester et interpréter le résultat des matrice suivantes :

Remarques : Matrice vide

Opérations sur les matrices :

Exercice 2 : Tester et interpréter les commandes suivantes :

Accéder aux éléments d’une matrice

a. L’opérateur " :"

17. 24. 1. 8. 15.

Exercice 3 : Tester et interpréter les commandes suivantes :

b. L’opérateur dollar "$"

Ajout dynamique des éléments par l’opératuer $

Exercice 4 : Evaluer et interpréter les commandes suivantes :

Compléter les lignes 5 et 6 du script de la fonction qmatrix.

Pour tracer un segment

plot([1, 3], [2, 5])

Tracés de courbes planes définies par des fonctions y = f(x)

Ci-dessous avec ce programme, on obtient le tracé de la courbe de f, en bleu par défaut.

Tracés des nuages de points

Editeur Scilab Fenêtre graphique

Le tracé de la surface 𝑧 = 2𝑥2 + 𝑦2 (paraboloïde elliptique) :

Vous aimerez peut-être aussi