Découvrir Scilab/Calculs élémentaires

2. Calculs élémentaires

Scilab peut s'utiliser comme une calculatrice scientifique, de type calculatrice graphique. Il suffit de taper une formule dans une syntaxe relativement standard, et d'appuyer sur le retour chariot pour avoir le résultat.

Opérateurs et fonctions classiques

Scilab utilise les fonctions et opérateurs classiques :

+ (addition), - (soustraction), * (produit), / (division), ^ ou ** (élévation à une puissance),
modulo(a, b) : reste entier de a/b, pmodulo(a, b) donne un résultat toujours positif,
sqrt() (racine carrée), nthroot(x, n) (racine n-ième de x)
cos(), sin(), tan() pour les fonctions trigonométriques de base, acos(), asin(), atan() pour leurs réciproques, cotg() pour la cotangente ;
les fonctions trigonométriques hyperboliques cosh(), sinh(), tanh(), acosh(), asinh(), atanh()
log() pour le logarithme népérien (ln), log10() pour le logarithme en base 10 (log₁₀), log2() pour le logarithme en base 2 (log₂),
exp() pour la fonction exponentielle,
floor() pour la partie entière, int() pour la troncature (arrondit à l'entier vers 0, différent de floor pour les nombres négatifs), round() pour l’arrondi au plus proche (0,5 → 1), abs() pour la valeur absolue,
erf() pour la fonction d'erreur de Gauss,
rand pour avoir un nombre aléatoire entre 0 et 1, suivant une loi uniforme ; rand(1, "normal") pour avoir un nombre aléatoire suivant une loi normale centrée réduite (moyenne 0, variance 1) ;
la factorielle de n peut s'obtenir par prod(1:n) ou bien par gamma(n+1) ;
…

Le séparateur décimal est le point.

Les puissances de 10 se notent avec la lettre « e » en minuscule ou en capitale : 5,2·10³ s'écrit 5.2e3 ou 5.2E3, 5,2·10^-3 s'écrit 5.2e-3 ou 5.2E-3. On peut aussi utiliser le « d » minuscule ou capital.

Par défaut, Scilab affiche les résultats avec dix caractères (signe et point décimal inclus). On peut modifier le nombre de caractères avec la fonction format(n) où n est le nombre de caractères.

Mentionnons également la fonction clear qui permet d'effacer toutes les variables (dont les fonctions définies par l'utilisateur). Cela peut être utile lorsque l'on a procédé par essai-erreur et que l'on veut remettre les « compteurs à zéro ».

Vocabulaire: Dans Scilab, une « fonction interne^[1] » est une fonction prédéfinie. Par opposition, les fonctions définies par l'utilisateur sont appelées « fonctions extérieures ».

Constantes particulières

Pour entrer l’imaginaire i, il faut utiliser %i ; il figure simplement sous la forme « i » dans les résultats.

Pour entrer l’infini ∞, il faut utiliser %inf ; il figure simplement sous la forme « inf » dans les résultats.

La valeur de π s’obtient par %pi, et la constante de Neper e par %e.

Lorsqu'une opération invalide se produit, certains programmes retournent un nombre particulier appelé « NaN » pour not a number (littéralement « ceci n'est pas un nombre »)^[2]. Dans Scilab, cette valeur est obtenue par %nan et s'affiche sous la forme Nan.

Variables

On peut définir des variables simplement sous la forme NomVariable=valeur. NomVariable est une chaîne de caractères commençant par une lettre ; Scilab est sensible à la casse, c'est-à-dire que les variables « a » et « A » sont deux variables différentes. Le type de la variable (entier, réel, imaginaire) est géré automatiquement.

La variable ans contient le dernier résultat (pour answer, « réponse » en anglais).

La fonction who affiche les variables déclarées (who? signifie « qui ? » en anglais). On remarque que dès l'ouverture, Scilab a défini de nombreuses variables, notamment des variables dites « d'environnement », c'est-à-dire des paramétrages de fonctionnement de Scilab.

Exemples

Exemple 1

Vérification de l'équation $\sin {\pi /4}={\sqrt {2}}/2$ (= sin(45°) ≈ sin(0,78) ≈ 0,71) :

-->asin(sqrt(2)/2)
 ans  =

    0.7853982

-->ans/%pi*180
 ans  =

    45

Exemple 2

-->%e^(%i*%pi/2)
 ans  =

    6.1273D-17 + i

Notez que dans l'absolu, on devrait obtenir i.

Exemple 3

Calcul de la pression, en Pa, de 2,5 moles de gaz parfait dans un volume de un litre (10^-3 m³) à une température de 300 K (26,85 °C)

-->n = 2.5; R = 8.314472; T = 300; V = 1e-3;

-->n*R*T/V
 ans  =

    6235854

soit environ 6,2·10⁶ Pa.

Complexes

Les nombres complexes sont entrés sous la forme a + b*%i. On peut utiliser la commande complex(a, b) pour créer ce nombre. Les lignes suivantes sont équivalentes :

z = 1 + 2*%i
z = complex(1,2)

Les commandes real(z) et imag(z) donnent respectivement la partie réelle et la partie imaginaire du nombre complexe. La conjugaison complexe z s'obtient par conj(z).

Le module d'un nombre complexe s'obtient avec la commande abs(z). L'argument complexe de z = a + bi s'obtient par

phi = atan(b, a)
phi = atan(imag(z), real(z))

La commande isreal(z) teste si un nombre est réel, ou bien si une matrice ne contient que des réels.

Pour multiplier par l'imaginaire pur i, il vaut mieux utiliser la commande imult(a) que %i*a.

Booléens

Lorsque l’on assigne une valeur booléenne, on utilise %t pour « vrai » (true) et %f pour « faux » (false). Le résultat de l’opération affiché est respectivement T ou F.

L’opérateur ou (OR) est noté « | » (tube), et (AND) est noté « & » (esperluette), non (NOT) est noté « ~ » (tilde). Le ou exclusif (XOR) s'obtient avec ~=.

Exemple

-->(%t & %f) | %f
ans =

F

On peut également utiliser les fonctions and() et or() qui appliquent les opérateurs respectifs et et ou à tous les éléments d'une matrice. L'exemple ci-dessus devient :

-->or([and([%t, %f]), %f])
ans =

F

Un booléen s’obtient en général en comparant deux valeurs, avec les relations d’égalité == et de différence <> ou ~=, et les relations d'ordre <, <=, > et >=.

Exemple

-->a = 3
 a  =

    3.

-->a == 3
 ans  =

  T

-->a < 2
 ans  =

  F

Sur des matrices de même dimension, ou bien entre un scalaire et une matrice, l'égalité s'évalue élément par élément. Si l'on savoir si deux matrices sont égales, on utilise l'opérateur and(). Si l'on veut savoir si un scalaire est dans un ensemble, on peut écrire l'ensemble sous la forme d'un vecteur ou d'une matrice et utiliser l'opérateur or().

Exemple

[1 2 ; 3 4] == [1 3 ; 2 4]
 ans  =

  T F
  F T

--> and([1 2 ; 3 4] == [1 3 ; 2 4])
 ans  =

  F

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

  F T F F

--> or(2 == [1 2 3 4]) // 2 ∈ {1 ; 2 ; 3 ; 4} ?
 ans  =

  T

Il existe également un certain nombre de commandes de test renvoyant un booléen, par exemple :

isempty(a) : renvoie « vrai » si c'est la variable vide, « faux » sinon^[3] ;
isnan(a) : vérifie si la variable a la valeur NaN (not a number, résultat d'une opération invalide) et renvoie « vrai » dans ce cas ;
isinf(a) : vérifie si la variable a une valeur infinie et renvoie « vrai » dans ce cas ;
isequal(a, b, …) : vérifie si les variables a, b, … sont toutes égales ;
isreal(a) : vérifie si a est une matrice de réels.

Si la variable x est un booléen, la commande bool2s(x) (boolean to standard) transforme la valeur « faux » en « 0 » et la valeur « vrai » en « 1 ». Si c'est un nombre, la commande transforme toute valeur réelle non nulle en « 1 », et une valeur nulle en « 0 ». Les valeurs NaN (%nan) et ∞ (%inf) ne sont pas nulles et donc sont transformées en « 1 ».

À l'inverse, les opérateur booléens — &, |, and() et or() — s'appliquent aux réels et aux complexes : toute valeur non nulle est considérée comme vraie, la valeur nulle (0 ou 0 + 0⋅i) est considérée comme fausse.

Polynômes et fractions rationnelles

Scilab manipule les polynômes et fractions rationnelles formels, c'est-à-dire non pas en tant que fonction, mais en tant qu'objets mathématiques, éléments du corps des polynômes ou des fractions rationnelles.

La première opération pour définir un polynôme est de définir le monôme x. Ceci se fait par la commande x = poly(0, "x"). Cette commande indique que la variable x est un polynôme (commande poly()) dont l'indéterminée est notée « x » (le "x" situé à l'intérieur de la parenthèse) et la racine est 0.

Puis, le polynôme ou la fraction rationnelle est définie par une formule contenant ce x.

Exemple de définition de polynôme

-->x = poly(0, "x"); p = x ^ 2 + 2 * x + 1
 p  =

              2
    1 + 2x + x

Exemple de définition de fraction rationnelle

-->x = poly(0, "x"); q = (1 + x) / (1 - x)
 q  = 

    1 + x
    -----
    1 - x

On peut aussi utiliser directement les constantes spéciales %s et %z, qui sont l'équivalent de %s = poly(0, "s") et %z = poly(0, "z") :

-->p = %s^ 2 + 2*%s + 1
 p  =

              2
    1 + 2s + s

Les polynôme et fractions rationnelles se manipulent ensuite de manière formelle comme les autres variables. Voici des exemples à partir des objets définis ci-dessus.

Exemple

-->1/q
 ans  =

    1 - x
    -----
    1 + x

--> p*q
 ans  =

               2    3
    1 + 3x + 3x  + x
    ----------------
         1 - x

La fonction derivat() fait la dérivée formelle du polynôme ou de la fonction rationnelle.

De manière interne, Scilab représente les polynômes et les fractions rationnelles comme des listes typées. Ainsi, avec les exemples précédents,

p(1) va nous renvoyer 1 + 2x + x² ;
q(1) renvoit la liste des noms des champs de la liste ;
q(2) (ou q("num"), q.num) donne 1 + x ;
q(3) (ou q("den"), q.den) donne 1 - x ;

et p(a) donne une erreur quelle que soit la valeur de a (sauf 1), q(a) donne une erreur quelle que soit la valeur de a (sauf 1, 2, 3 et 4).

On ne peut donc pas utiliser un polynôme ou une fraction rationnelle comme une fonction classique. L'évaluation, c'est-à-dire l'utilisation du polynôme ou de la fraction rationnelle comme fonction numérique, se fait avec la fonction horner :

horner(f,val) calcule ƒ(val).

Exemple

-->horner(p, 2)

 ans  =

    9.

Fonctions spécifiques aux polynômes

La fonction roots(p) donne les racines du polynôme p. La fonction factors(p) donne la décomposition en facteurs irréductibles.

La fonction coeff(p) donne une matrice dont les coefficients sont les coefficients du polynôme p. ; on peut extraire le coefficient de degré n avec coeff(p, n).

La fonction varn(p) renvoie le nom de l’indéterminée de p (ici, x).

En fait, la commande x = poly(0, "x") définit que x est le polynôme le plus simple dont l’indéterminée est le caractère « x » et dont la racine est 0, c’est-à-dire le monôme x. La commande A = poly(2, "x") définit de même le polynôme le plus simple ayant pour racine 2, c’est-à-dire x - 2.

Note: Si l'on écrit x = poly(2, "x"), alors la variable x sera le polynôme « x - 2 ». Il faut bien distinguer la notion d'indéterminée (chaîne de caractère attachée au polynôme) et la variable x. Si l'on écrit A = poly(2, "x") puis x = 1, A sera toujours le polynôme « x - 2 », l'indéterminée ne sera pas remplacée par la valeur de la variable x.

Cette fonction permet de définir un polynôme ayant plusieurs racines, en utilisant une matrice ligne au lieu d’un simple nombre. Par exemple, A = poly([1 2], "x") définit le polynôme le plus simple ayant pour racines 1 et 2, soit le polynôme x² - 3x + 2.

On peut aussi utiliser cette fonction pour générer un polynôme dont les coefficients sont contenus dans une matrice ligne, en ajoutant le caractère "c" à la fin des arguments. Par exemple, A = poly([a0, a1, …, an], "x", "c") définit le polynôme a0 + a1·x + … + an·xⁿ.

Fonctions spécifiques aux fractions rationnelles

La fraction rationnelle q est le rapport de deux polynômes, notés q.num (numérateur) et q.den (dénominateur), qui peuvent se manipuler comme des polynômes normaux.

Exemple

-->q.num
 ans  =

    1 + x

-->q.num^2
 ans  =

              2
    1 - 2x + x

La fonction simp() fait la simplification de la fraction rationnelle.

Chaînes de caractères

Créer une chaîne

Comme indiqué précédemment, une chaîne de caractères est simplement délimitée par des guillemets simples ou doubles :

'a', "a"

Nous recommandons l'utilisation des guillemets doubles : en effet, le guillemet simple sert aussi à la transposition des matrices, ce qui peut porter à confusion.

Rappelons que pour faire figurer une apostrophe ou un guillemet dans la chaîne de caractères, il faut le doubler, '' ou "" (voir Interface utilisateur > Chaînes de caractère).

Mais une chaîne de caractères peut aussi être obtenues à partir des codes ASCII^[4]. La fonction ascii() renvoit :

si on lui donne un caractère ou une chaîne : le code ASCII du caractère ou le vecteur contenant les codes ASCII de chaque caractère de la chaîne ;
si on lui donne un entier ou un vecteur d'entiers : le caractère dont le code ASCII est l'entier, ou la chaîne de caractères.

Exemple

--> ascii("a")
 ans  =
 
    97.
 
--> ascii(65)
 ans  =
 
 A

La fonction char() crée un vecteur colonne de caractères à partir d'une matrice de nombres, par exemple

-->char([64, 65])
 ans  =
 
 @A

Notons que @A est une chaîne de caractères.

-->char([64, 65 ; 66, 67])
 ans  =
 
!@A  !
!    !
!BC  !

Par contre, appliquée à une matrice de chaînes de caractères, cette fonction concatène les lignes.

-->char(["a", "b" ; "c", "d"])
 ans  =
 
!ab  !
!    !
!cd  !

Rappelons quelques caractères ASCII spéciaux utiles :

9 : tabulation (horizontal tabulation, HT) ;
10 : saut de ligne (line feed, LF) ;
13 : retour de chariot (carriage return, CR) ;
les caractères affichables/imprimables vont du code 32 au code 126 :
- les chiffres vont de 48 (pour 0) à 57 (pour 9),
- les lettres capitales vont de 65 (A) à 90 (Z),
- les lettres minuscules vont de 97 (a) à 122 (z).

Pour plus de détails voir : w:fr:American Standard Code for Information Interchange#Table des 128 caractères ASCII .

Rechercher, remplacer, découper une chaîne

La commande strsubst() fait un « rechercher/remplacer » dans une chaîne. Par exemple, pour remplacer une virgule par un point dans la chaîne de caractères X :

strsubst(X, ",", ".")

La commande length(X) indique la longueur de la chaîne X.

La commande part permet d'extraire des caractères d'une chaîne. Les positions des caractères sont décrites dans un vecteur. Par exemple, pour extraire les cinq premiers caractères d'une chaîne X :

part(X, 1:5)

D'autres commandes sont présentées dans le chapitre Programmation > Analyse et construction de chaînes de caractères.

Utiliser une chaîne

L'opérateur « + » permet la concaténation de deux chaînes de caractère : "a" + "b" → "ab". La fonction strcat() concatène une matrice de chaînes.

-->a = strcat(["a", "b" ; "c", "d"])
 a  =
 
 "acbd"

elle permet d'ajouter un séparateur, une chaîne intercalaire :

-->a = strcat(["a", "b" ; "c", "d"], "|")
 a  =
 
 "a|c|b|d"

On peut aussi faire une concaténation par ligne ou par colonne, avec un troisième paramètre "r" (row) ou "c" (column), mais il faut alors nécessairement indiquer une chaîne intercalaire, quitte à ce que ce soit la chaîne vide :

--> strcat(["a", "b" ; "c", "d"], "", "r")
 ans  =

  "ac"  "bd"

La fonction string() permet de transformer un nombre, un booléen, un vecteur, une matrice… en une chaîne de caractères, par exemple pour permettre son utilisation par une fonction d'affichage (avec la fonction xstring(), input()…) ou bien pour fabriquer un nom de fichier.

La fonction evstr() permet de transformer une chaîne en une expression Scilab (on parle « d'évaluation de la chaîne »). La fonction execstr() permet d'exécuter le contenu de la chaîne.

Exemple

-->a = "1";
 
-->evstr(a)*2
 ans  =
 
    2.
 
-->b = "x"; c = "=5"; execstr(b + c)
 
-->x^2
 ans  =
 
    25.

la chaîne b + c est "x=5", cette chaîne est exécutée, ce qui signifie que la valeur 5 est attribuée à la variable x, ce que confirme le calcul fait par la suite.

La commande evstr() permet donc de transformer une chaîne de caractères — ou une matrice de chaînes — ne contenant que des chiffres en un nombre — ou une matrice de nombres. Si la chaîne de caractères mélange des chiffres et d'autres caractères, on peut alors utiliser la commande strtod() (string to double).

Variable chaîne comme matrice

Une variable contenant une chaîne de caractères peut être utilisée pour générer une matrice. Pour cela, on fait comme si la variable était elle-même une matrice acceptant une matrice rectangulaire ne contenant que des uns (ones()) en indice. Par exemple :

-->chaine = "a"
 chaine  =
 
 a   
 
-->chaine([1, 1 ; 1, 1])
 ans  =
 
!a  a  !
!      !
!a  a  !
 
-->chaine(ones(1, 5))
 ans  =
 
!a  a  a  a  a  !

La concaténation d'un vecteur ligne avec une chaîne permet alors d'intercaler des caractères.

-->strcat(chaine(ones(1, 5)), "b")
 ans  =
 
 ababababa

Cela permet de fabriquer des chaînes particulières de manière rapide.

Matrices

Scilab a été conçu pour le calcul matriciel. Les éléments des matrices peuvent être de tout type (nombre réel, nombre complexe, booléen, polynôme, fraction rationnelle, chaîne de caractères…).

Définir une matrice

Pour définir une matrice à partir de ses coefficients, on les place entre deux crochets […]. Les éléments d’une ligne sont séparés d’un espace ou d’une virgule, les lignes sont séparées retour à la ligne ou d’un point-virgule. À l’affichage, une matrice de nombres est représentée comme un tableau sans encadrement ; une matrice de chaînes de caractères est encadré par des points d’exclamation.

Exemple

-->[1,0,0;0,1,0;0,0,1]
ans =
 
1.    0.    0.
0.    1.    0.
0.    0.    1.

La matrice vide est notée par [].

L’expression M(i,j) désigne l’élément (i, j) de la matrice M (ligne i, colonne j).

Exemple

--> A = [1,0,0;0,1,0;0,0,1]
ans =
 
1.    0.    0.
0.    1.    0.
0.    0.    1.

--> A(1, 2)
 ans  =

   0.

--> A(1, 1) = 2
 A  = 

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

On peut directement « appliquer les parenthèses aux crochets » :

--> [1, 2, 3 ; 4, 5, 6](2, 1)
 ans  =

   4.

Le caractère : (deux-points) signifie « tous les indices », par exemple M(1, :) est la première ligne de la matrice (c’est un vecteur ligne). Le caractère $ (dollar) désigne le dernier indice (ligne ou colonne) d’une matrice. L'expression i1:i2 désigne tous les indices entre i₁ et i₂. Par exemple, si l'on veut effectuer l'opération M(i + 1, j) – M(i, j) pour tous les indices, on peut écrire simplement

difference = M(2:$, :) - M(1:$-1, :)

(note que la fonction diff(M) donne le même résultat).

Par ailleurs, l’expression N1:N2 permet aussi de générer une matrice-ligne dont le premier coefficient est N₁, le dernier est inférieur ou égal à N₂, et le pas entre les coefficients est 1. L’expression N1:pas:N2 permet de générer une matrice-ligne en choisissant le pas. Par exemple

-->1.1:5.2
ans = 

1.1    2.1    3.1    4.1    5.1

--> 1:2:5
ans =

1    3    5

-->"a":"d"
ans =

abcd

On notera que dans le dernier exemple, "a":"d" ne crée pas une matrice mais une chaîne de caractères.

On peut aussi utiliser la fonction

linspace(x1, x2, n)

pour générer une matrice ligne de n valeurs espacées régulièrement entre x₁ et x₂.

La fonction

zeros(m,n) crée une matrice m×n remplie de 0 ;
emptystr(m, n) crée une matrice m×n de chaînes de caractère vides ;
ones(m,n) crée une matrice m×n remplie de 1 ;
eye(n,n) crée une matrice unité n×n ;
diag(V), ou V est une matrice ligne ou une matrice colonne, crée la matrice diagonale : matrice carrée dont les termes de la diagonale sont les éléments de V et les autres termes sont nuls.

On peut aussi passer une matrice M en paramètre de ces fonctions ; elles créent alors une matrice de même dimension que la matrice M. Par exemple, M = zeros(M) met tous les coefficients de M à zéro.

Par défaut, une matrice numérique est de type « double précision ». Si l'on n'a pas besoin d'une telle précision, c'est un gaspillage de mémoire. Pour créer une matrice m×n d'entiers non signés codés sur 8 bits (soit des valeurs allant de 0 à 255), on peut utiliser la fonction uint8() (unsigned integer) sur une matrice existante :

uint8(zeros(m, n))

Mais cela revient à créer une énorme matrice (m × n × 8 octets) pour ensuite la réduire (à m × n × 1 octets). Or, nous supposons ici que la taille de la matrice m × n est important.

L'idéal est donc de :

partir du nombre en double précision 0 (zéro) et le transformer en entier non signé, avec la fonction uint8() ;
redimensionner cette matrice 1×1 avec la fonction resize_matrix()

ce qui initialise la matrice avec des zéros :

resize_matrix(uint8(0), m, n)

Si ƒ est une fonction extérieure (c’est-à-dire par définie par deff ou par function, voir Calcul numérique > Définition de fonctions extérieures), et que x et y sont des vecteurs, alors la fonction feval permet de bâtir une matrice z = ƒ(x, y)

z = feval(x, y, f) : on a z(i, j ) = ƒ(x(i ), y(j ))

Ajouter ou supprimer des lignes, des colonnes

Considérons une matrice M. Comme indiqué précédemment, M(i, :) crée le vecteur ligne composé des coefficients de la ligne i, et M(:, j) crée le vecteur colonne composé des coefficients de la colonne j.

Si la matrice M est une matrice par blocs composée de quatre blocs A, B, C et D (eux-même des matrices), on peut créer M simplement par

M = [A, B ; C, D]

Si l'on veut insérer un vecteur ligne L après la ligne i de la matrice, on peut écrire

M = [M(1:i, :) ; L ; M(i+1:$, :)]

et si l'on veut supprimer la ligne i, en faisant remonter les lignes suivantes, il suffit d'y mettre la matrice vide :

M(i, :) = []

On peut procéder de même avec les colonnes.

Fonctions et opérateurs sur les matrices

Toutes les fonctions numériques s’appliquent à des matrices ; par exemple si M est une matrice, alors cos(M) sera la matrice dont les coefficients sont les cosinii des coefficients de M.

La fonction exp(M) calcule l'exponentielle de chaque terme. L'exponentielle de la matrice (∑(1/k!)M^k) s'obtient avec la fonction expm(M).

La fonction size(M) renvoie la taille de la matrice sous la forme d’une matrice 2×1 contenant le nombre de lignes puis le nombre de colonnes. La fonction size(M, "*") renvoie le produit des deux valeurs, soit le nombre total d'éléments dans la matrice. On peut avoir le nombre de lignes avec size(M, "r") (row), et le nombre de colonnes avec size(M, "c").

Les opérations spécifiques aux matrices classiques sont :

la transposition : il suffit de mettre un point suivi d'une apostrophe .’ après la matrice ; l'utilisation de l'apostrophe seule, ', fait la transposition de la matrice conjuguée (opérateur adjoint) ;
somme, différence et produit de matrices : +, - et * ;
produit, rapport et élévation à la puissance élément par élément : .*, ./ et .^ ;
le produit tensoriel .*. ;
le déterminant d’une matrice carrée M : det(M) (determ() pour une matrice de polynômes et detr() pour une matrice de fractions rationnelles) ;
la trace d’une matrice carrée M : trace(M) ;
l’inverse d’une matrice inversible M : inv(M) ;

Vecteur

Un vecteur est une matrice ligne ou colonne (matrice 1 × n ou n × 1) ; l’expression V(i) désigne la composante i du vecteur V.

Si l'on veut avoir la taille d'un vecteur v sous la forme d'un entier, on peut utiliser

vecteur ligne : size(v, "r")

vecteur colonne : size(v, "c")

dans les deux cas : max(size(v)) ou bien size(v, "*")

La norme d'un vecteur v s'obtient simplement par

nv = norm(v);

Si V1 et V2 sont des vecteurs colonnes, alors le produit scalaire est

V1' * V2;

si ce sont des vecteurs lignes, le produit scalaire est

V1 * V2'

Il n'existe pas de fonction « toute faite » pour calculer le produit vectoriel (cross product).

Vecteurs ou matrices utilisés comme suite de nombres

Un vecteur peut être utilisé pour stocker une suite de nombre. cela peut être les valeurs successives d'une suite, au sens mathématique du terme, ou bien des données recueillies expérimentalement. Quelques fonctions sont relatives à ces applications.

On peut faire :

la somme de tous les éléments de la matrice : sum(M) ;
le produit de tous les éléments de la matrice : prod(M).

La fonction max(M) renvoie la plus grand élément de la matrice, et la fonction min(M) renvoie le plus petit.

Si l'on tape [m,k]=max(A), alors Scilab met la valeur du maximum dans la variable m et sa position dans la matrice (sous la forme d'un vecteur ligne [i,j]) dans la variable k — on peut utiliser d'autres noms de variable que m et k. De même pour [m,k]=min(A).

On peut ajouter un paramètre après la matrice, sous la forme d'une caractère :

max(A, "c") et min(A, "c") renvoient les extrema de chaque colonne de la matrice ;
max(A, "r") et min(A, "r") renvoient les extrema de chaque ligne de la matrice (« r » pour row).

On peut mettre une suite de matrices de même taille dans min et max. Alors, Scilab renvoit une matrice m de taille identique dont chaque élément m(i, j ) est l'extremum des éléments (i, j ) des matrice, et éventuellement une matrice k dont chaque élément k(i, j ) contient le numéro d'ordre de la matrice (dans la liste) qui contient ce maximum.

Exemple

--> A = [1,2;3,4], B = [4,3;2,1]
  A  =

     1.    2.
     3.    4.
  B  =

     4.    3.
     2.    1. 

-->[m,k] = max(A,B)
 k  =

    2.    2.
    1.    1.
 m  =

    4.    3.
    3.    4.

La matrice m(1,1) contient « 4 » qui est le maximum entre A(1,1) et B(1,1), et k(1,1) contient « 2 » ce qui indique que c'est la seconde matrice (donc B) qui contient ce maximum.

La fonction cumsum(A) fait la somme cumulée des valeurs de la matrice A. Si A est un vecteur de dimension n, cela correspond à la somme de la série, la fonction renvoie un vecteur de dimension n contenant

{\begin{pmatrix}\mathrm {A} (1),&\mathrm {A} (1)+\mathrm {A} (2),&\ldots ,&\sum _{i=1}^{n}\mathrm {A} (i)\end{pmatrix}}

.

Si A est une matrice rectangulaire m×n, la somme se fait par colonne, de haut en bas, le résultat est une matrice de même dimension contenant

{\begin{pmatrix}\mathrm {A} (1,1)&\mathrm {S} _{1}+\mathrm {A} (1,2)&\cdots &\sum _{j=1}^{n-1}\mathrm {S} _{j}+\mathrm {A} (1,n)\\\mathrm {A} (1,1)+\mathrm {A} (2,1)&\mathrm {S} _{1}+\mathrm {A} (1,2)+\mathrm {A} (2,2)&\cdots \\\vdots &\vdots &&\vdots \\\mathrm {S} _{1}=\sum _{i=1}^{m}\mathrm {A} (i,1)&\mathrm {S} _{1}+\mathrm {S} _{2}&\cdots &\sum _{j=1}^{n}\mathrm {S} _{j}\end{pmatrix}}

La fonction cumprod() fait le produit cumulé, selon la même démarche.

La fonction gsort() effectue un tri :

gsort(A) # tri par ordre décroissant
gsort(A, 'i') # tri par ordre croissant

Pour plus de détails voir : Découvrir Scilab/Programmation#Tri, recherche et sélection.

Si l'on effectue des comparaisons sur des matrices de même dimensions, cela donne une matrice de booléens de même dimensions, correspondant à la comparaison terme à terme. Par exemple

-->A = ones(2,2)
 A  =
 
    1.    1.  
    1.    1.  
 
-->B = [1, 2 ; 3, 4]
 B  =
 
    1.    2.  
    3.    4.  
 
-->A == B
 ans  =
 
  T F  
  F F  
 
-->A < B
 ans  =
 
  F T  
  T T

On peut ainsi utiliser les opérateurs ~=, <>, <, <=, > et >=.

Les fonctions and() et or() appliquent les opérateurs respectivement ET et OU à la totalité des éléments de la matrice. Par exemple, si l'on veut déterminer si deux matrices sont différentes, on peut utiliser and(A ~= B) ou and(A <> B).

Importance des matrices dans Scilab

Les matrices sont très utilisées dans Scilab pour définir les paramètres. Ainsi, pour tracer une courbe, il utilise un nuage de point sous forme de matrice, ou encore, pour effectuer une boucle itérative, il prend les indices dans une matrice ligne ou colonne.

La syntaxe propre aux matrices se retrouve dans de nombreux endroits.

Date et heure

Pour certaines applications, il est nécessaire de manipuler les dates et heures. Scila fournit les commandes suivantes :

datenum() ou now : indique le numéro du jour actuel, le premier jour étant le 1^er janvier de l'an 0 s'il avait existé (en fait, l'an -1, puisque le calendrier grégorien passe de l'an -1 à l'an 1) ; la partie décimale correspond à l'heure ;
getdate() : idem, mais avec un format différent : année, mois, numéro de la semaine dans le mois, numéro du jour d'ans l'année, numéro du jour dans la semaine (1 pour dimanche, 2 pour lundi, …), numéro du jour dans le mois, heure, minutes, secondes (entier), millisecondes ;
datenum([aaaa, mm, jj]) indique le numéro du jour jj du mois mm de l'année aaaa ; on peut aussi ajouter l'heure pour avoir la partie décimale : datenum([aaaa, mm, jj, hh, mm, ss]) ;
clock donne directement la date et l'heure au format [aaaa, mm, jj, hh, mm, ss] ;
datevec(numjour) : convertit le numéro du jour en un vecteur contenant l'année, le mois, le jour, l'heure, les minutes et les secondes (opération inverse de la commande précédente) ;
weekday(numjour) indique le jour de la semaine du jour numjour : 1 pour dimanche, 2 pour lundi, … Avec la syntaxe [N, S] = weekday(numjour), Scilab indique le numéro du jour de la semaine, dans N, ainsi que le nom du jour selon l'abréviation anglaise, dans S ;
eomday(année, mois) : donne le nombre de jours du mois (indiquer sous forme de nombre, de 1 à 12) et de l'année indiqué ;
calendar() : donne le calendrier du mois en cours ;
calendar(aaaa, mm) : donne le calendrier du mois mm de l'année aaaa.

Par exemple :

aujourdhui = datenum()
datevec(aujourdhui)
clock
calendar()
[N, S] = weekday(aujourdhui)
datenum([1969, 07, 21])
eomday([1969, 07])

Si l'on s'intéresse à l'intervalle entre deux dates :

etime(t1, t2) : indique le nombre de secondes écoulées (elapsed time) entre les dates t₁ et t₂, sous la forme de vecteurs [aaaa, mm, jj, hh, mm, ss] ;
getdate("s") : indique le nombre de secondes écoulée entre le 1^er janvier 1970 et l'instant actuel ;
getdate(numsec) : indique le jour et l'heure, au format getdate(), à partir du nombre de secondes écoulées depuis le 1^er janvier 1970 ;
tic() déclenche un chronomètre, et toc() renvoie le nombre de secondes écoulées depuis ce déclenchement.

Précision des calculs

Dans Scilab, les nombres sont stockés sour la forme de nombre décimaux de double précision (doubles), selon la norme IEEE 754^[5]. Ce sont des nombres à virgule flottante (floating point) codés sur 64 bits (8 octets). Il s'ensuit que :

la précision d'un résultat est au mieux de 10^-16 ; cette précision est indiquée par la variable %eps ;
la valeur absolue la plus petite que l'on puisse représenter est environ 10^-307 ; un nombre ayant une valeur absolue plus petite sera considéré comme nul, 0 (soupassement, underflow) ;
la valeur absolue la plus grande que l'on puisse représenter est environ 10³⁰⁸ ; un nombre ayant une valeur absolue plus grande sera considéré comme infini, inf (dépassement, overflow).

Un certain nombre de fonction internes de Scilab utilisent des méthodes qui minimisent l'erreur de calcul, et font donc mieux qu'une codage « naïf » de ces méthode. Par exemple, pour résoudre une équation du second degré, il vaut mieux utiliser la commande roots() que calculer le résultat à partir du discriminant ; la différence ne sera pas visible pour la plupart des cas, mais peut être flagrante pour des cas extrêmes.

Lire les valeurs dans un fichier

Il existe plusieurs manières de lire des données écrites dans un fichier. Nous nous limitons ici à deux cas :

fichier CSV, par exemple créé avec un tableur comme LibreOffice Calc ou Microsoft Office Excel : M = csvRead("nom_du_fichier.csv") ;
fichier de texte pur (ASCII ou Unicode) dans lequel les données sont sous forme de tableau : M = fscanfMat("nom_du_fichier.txt").

Dans les deux cas, les donées sont placées dans la matrice M.

Pour plus de détails voir : Découvrir Scilab/Gestion des fichiers.

Voir aussi

Notes

↑ la documentation utilise le terme de « primitive » ; il y a une ambiguité en français que nous avons décidé de lever dans le présent ouvrage en changeant le terme (en anglais, le problème ne se pose pas puisque la primitive d'une fonction est appelée « antiderivative »)
↑ dans la représentation des nombres à virgule flottante IEEE 754, un NaN est un nombre dont l'exposant ne contient que des 1 et la mantisse n'est pas nulle
↑ En particulier, il faut éviter le test a == [], car la notion de « variable vide » peut évoluer. Par exemple, on peut envisager qu'il existera un jour un tableau de n lignes et 0 colonne, qui est équivalent à la variable vide d'un point de vue mathématiques mais pas à [] d'un point de vue informatique. La commande isempty() est donc plus robuste aux évolutions du logiciel [1].
↑ les commandes code2str() et str2code() permettent aussi de passer de nombres aux caractères et vice versa (il s'agit par contre d'une table de conversion propre à Scilab), mais sont déclarées obsolètes et ont été supprimées dans la version 6
↑ voir Scilab is not naive, Scilab Enterprises, décembre 2010

Interface < ↑ > Calcul numérique

[1] umentation utilise le terme de « primitive » ; il y a une ambiguité en français que nous avons décidé de lever dans le présent ouvrage en changeant le terme (en anglais, le problème ne se pose pas puisque la primitive d'une fonction est appelée « antiderivative »)

[2] s la représentation des nombres à virgule flottante IEEE 754, un NaN est un nombre dont l'exposant ne contient que des 1 et la mantisse n'est pas nulle

[3] En particulier, il faut éviter le test a == [], car la notion de « variable vide » peut évoluer. Par exemple, on peut envisager qu'il existera un jour un tableau de n lignes et 0 colonne, qui est équivalent à la variable vide d'un point de vue mathématiques mais pas à [] d'un point de vue informatique. La commande isempty() est donc plus robuste aux évolutions du logiciel [1].

[4] s commandes code2str() et str2code() permettent aussi de passer de nombres aux caractères et vice versa (il s'agit par contre d'une table de conversion propre à Scilab), mais sont déclarées obsolètes et ont été supprimées dans la version 6

[5] voir Scilab is not naive, Scilab Enterprises, décembre 2010

[1]

[2]

[3]

[4]

[5]