Date: 28 décembre 2004 (dernière date de mise à jour)
Pour ces travaux pratiques d'introduction à Scilab, il vous
faut lancer le logiciel Scilab et disposer ainsi d'une fenêtre de travail permettant
de saisir et d'exécuter des instructions.
Attention : Toute saisie dans cette fenêtre est temporaire et sera perdue à la fermeture
de la session. Pour sauvegarder vos saisies il faut utiliser un éditeur de texte
(par exemple l'éditeur intégré de Scilab).
Dans ces premiers travaux pratiques, vous trouverez une série
de lignes de commandes Scilab précédées du signe -->.
Pour commencer, il vous suffit de les recopier ou de les saisir par copier-coller
(sans -->) pour les exécuter immédiatement
dans la fenêtre Scilab.
Toute ligne débutant par // est une ligne de commentaires.
La première étape consiste à choisir le système de codage des nombres flottants. Scilab utilise la norme IEEE-754 double précision, mais il dispose de trois modes d'utilisation. Pour étudier ce point taper d'abord, dans la fenêtre Scilab, la commande
-->help ieee
Ensuite faire les expériences suivantes :
-->ieee(0)
-->1/0
-->ieee(1)
-->1/0
-->ieee(2)
-->1/0 // Rappel : Inf est un NaN.
En fonction des résultats obtenus, vous pouvez choisir, en connaissance de cause, le mode à utiliser.
On présente les objets de base qu'on manipule en Scilab. Pour des informations complémentaires se référer au poly, §2.1.
-->5
// en tapant le chiffre 5, Scilab attribue la valeur 5 à la variable ans (pour answer)
-->ans^2
// ans élevé au carré donne 25
-->abs(-5) // valeur absolue
-->m=10^6
-->sqrt(m) // racine carrée
-->y=%e
-->log(y)
// %e est la constante e et elle est une variable prédéfinie de Scilab.
// Chaque variable précédée de % est une variable prédéfinie de Scilab et elle ne peut pes être redéfinie.
-->sin(%pi)
// noter que le résultat n'est pas exactement zéro
-->1+%eps
// %eps est la précision de la machine eps.
// eps est le plus petit flottant positif tel que 1+eps est différent de 1.
Pour la liste complète des varaibles prédéfinies de Scialb, se reporter au poly,§2.1.2. De même pour les opérations arithmétiques, §2.1.3 et les fonctions élémentaires, §2.1.4.
-->%i // %i désigne la varaible imaginaire
-->%i^2
-->x=3-4*%i // Le nombre complexe 3-4i
-->abs(x) // module
-->v=[3.8,-4,%pi/6] // Vecteur ligne
-->v=[3.8 -4 %pi/6] // On peut remplacer les virgules par un blanc
// Attention aux pièges
-->v=[3.8 -4 +%pi/6] // + est un opérateur unaire (comme d'ailleurs -)
-->v=[3.8 -4 *%pi/6] // * est toujours un opérateur binaire
-->v=[3.8;-4;%pi/6] // Vecteur colonne
-->size(v) // dimensions de v
-->w=v' // transposition
// construction d'un vecteur par blocs
-->x=[1,2]; y=[3,4,5]
-->z=[x,y];
-->t=[4:9] // vecteur des réels entre 4 et 9 par pas de 1 (pas implicite)
-->t=[4:1:9] // vecteur des réels entre 4 et 9 par pas de 1 (pas explicite)
-->t=[0:0.1:1] // vecteur des réels entre 0 et 1 par pas de 0.1
-->t=linspac(0,1,11) // même résultat que précédement
-->t=logspace(1,2,10) // vecteur contenant 10 valeurs logarithmiquement espacés entre 101 et 102
-->u=sqrt(2)*[1:2:8]'
-->size(u)
-->s=ones(u) // vecteur de même dimension que u et ne contenant que des 1
-->zeros(u) // vecteur de même dimension que u et ne contenant que des 0
-->t=rand(1,5) // Vecteur contenant des nombres au hasard dans [0, 1]
-->v=rand(s)
-->F=[1,2;3,4]
// dans une instruction trop longue pour tenir dans une ligne,
// mettre ... avant de passer à la ligne
-->G=[11,12;13,...
-->14;15,16]
// création d'une matrice diagonale
-->diag([5 4 3])
// création d'un vecteur colonne qui contient la diagonale de la matrice F
-->diag(F)
// création d'une matrice diagonale qui contient la diagonale d'une autre matrice
-->diag(diag(F)))
// des 0 et des 1
-->eye(6,6)
-->B=eye(6,7)
-->A=ones(3,7)
-->C=[A;(-6)*B]
-->D=zeros(2,5)
// et un peu de hasard
-->E=rand(D)
-->rand(2,5)
Pour les foncions vectorielles et matricielles se reporter au poly, §2.2.
|
Question 1
|
// La fonction norm
-->u=2*%pi*rand()
// un nombre au hasard dans [0,2*pi]
-->w=[cos(u) sin(u)]
-->norm(w)
-->norm(w,1)
// Les fonctions maxi, mini et sign
-->t=[0:%pi/2:2*%pi]
-->v=sin(t)
-->[m,k]=maxi(v)
// la valeur maximale des éléments du vecteur v est m
// et elle est atteinte pour l'élément d'indice k : m=v(k)
-->[m,k]=mini(v)
-->sign(v)
// signe 1 (+) ou -1 (-) et sign(0)=0
-->1==0
// la réponse à l'assertion ``1 égale 0'' est F false
-->1~=0
// la réponse à l'assertion ``1 différent de 0'' est T true
-->1==0 & 1~=0
// et : la réponse est F false
-->1==0 | 1~=0
// ou : la réponse est T true
-->t=[0:%pi/2:2*%pi]
-->v=sin(t)
-->v>0
// renvoie un vecteur de T (true) ou F (false) selon que
// l'élément correspondant de v est ou non >0
-->v>=0
-->bool2s(v>=0)
// convertit les T et F en 1 et 0
-->v(v>=0)
// extrait les élément positifs ou nuls de v
-->w=1:9
-->sum(w)
// somme de tous les éléments de w
-->cumsum(w)
// vecteur donnant les sommes cumulées
-->A=rand(2,3)
-->B=sin(A)
-->A+B
-->G=[ones(1,4); 2*ones(1,4)]
-->sum(G,'c')
// somme sur les lignes : le résultat est un vecteur colonne ('c' pour column)
-->sum(G,'r')
// somme sur les colonnes : le résultat est un vecteur ligne ('r' pour row)
-->A'
-->rank(A)
-->A'*A
-->A*A'
-->C=eye(A)
-->A'*C
-->A=[1,2;3,4]
-->det(A)
-->u=%pi/4 -100*%eps
-->det([cos(u) sin(u); sin(u) cos(u)])
-->D=rand(3,3)
-->expm(D) // exponentielle de matrice
-->exp(D) // attention : exponentielle terme à terme
-->w=1:2:9
-->w(2)
-->w($) // dernier élément
-->w($-1) // avant-dernier élément
-->E=[11:19;21:29;31:39;41:49;51:59;61:69]
-->E(1,1) // l'élément de la ligne 1 colonne 1
-->E(3,4) // l'élément de la ligne 3 colonne 4
-->E(1, : ) // la ligne 1
-->E(:,5) // la colonne 5
-->E(2:4, : )
// la sous-matrice formée des lignes allant de 2 à 4
-->E(2:3,7:9)
// la sous-matrice formée des éléments appartenant
// aux lignes allant de 2 à 3 et aux colonnes de 7 à 9
-->E([1,3,5],[2,4,6,8])
// la sous-matrice formée des éléments appartenant
// aux lignes 1 3 5 et aux colonnes 2 4 6 8
-->E(:,$) // dernière colonne
-->E(:,$-1) // avant-dernière colonne
-->E(2:$, : ) // les lignes de la deuxième à la dernière
-->E(2: ($-1), : ) // les lignes de la deuxième à l'avant-dernière
-->A=int(20*rand(1,10))
// partie entière
-->[sa,ia]=sort(A)
// tri : sa est le résultat du tri, ia les indices correspondants
|
Question 2
|
-->x=[1 2 3]
-->x.*x
-->y=[-6 12 8]
-->x.*y
-->A=rand(2,3);
-->B=ones(A);
-->A.*B
-->x=[1 2 3]
-->y=1 ./x
// un blanc suit le 1, car sinon 1. serait interprété en 1.0 et
// l'opération serait de calculer un vecteur colonne y tel que x*y = 1.
-->x.*y
-->A=rand(2,3);
-->B=rand(A);
-->A./B
-->x=[1 2 3]
-->y=x.^2
-->z=x.^[5 10 -2]
-->A=rand(2,3);
-->A.^3
-->B=rand(A);
-->A.^B
-->A=eye(2,2)
-->B=[1 2;3 4]
-->C = A .*. B // ".*." désigne le produit de Kronecker
// Ici on construit une matrice diagonale par blocs
|
Question 3
Question 4
Question 5
|