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 :
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·103 s'écrit codice_38 ou codice_39, 5,2·10-3 s'écrit codice_40 ou codice_41. 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 codice_42 où "n" est le nombre de caractères.
Mentionnons également la fonction codice_43 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 ».
Constantes particulières.
Pour entrer l’imaginaire "i", il faut utiliser codice_44 ; il figure simplement sous la forme « codice_45 » dans les résultats.
Pour entrer l’infini ∞, il faut utiliser codice_46 ; il figure simplement sous la forme « codice_47 » dans les résultats.
La valeur de π s’obtient par codice_48, et la constante de Neper "e" par codice_49.
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 »). Dans Scilab, cette valeur est obtenue par codice_50 et s'affiche sous la forme codice_51.
Variables.
On peut définir des variables simplement sous la forme codice_52.
"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 codice_53 contient le dernier résultat (pour "answer", « réponse » en anglais).
La fonction codice_54 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 formula_1 (= 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 m3) à 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·106 Pa.
Complexes.
Les nombres complexes sont entrés sous la forme codice_55. On peut utiliser la commande codice_56 pour créer ce nombre. Les lignes suivantes sont équivalentes :
z = 1 + 2*%i
z = complex(1,2)
Les commandes codice_57 et codice_58 donnent respectivement la partie réelle et la partie imaginaire du nombre complexe. La conjugaison complexe s'obtient par codice_59.
Le module d'un nombre complexe s'obtient avec la commande codice_60. L'argument complexe de "z" = "a" + "b"i s'obtient par
phi = atan(b, a)
phi = atan(imag(z), real(z))
La commande codice_61 teste si un nombre est réel, ou bien si une matrice ne contient que des réels.
Pour multiplier par l'imaginaire pur codice_45, il vaut mieux utiliser la commande codice_63 que codice_64.
Booléens.
Lorsque l’on assigne une valeur booléenne, on utilise codice_65 pour « vrai » "(true)" et codice_66 pour « faux » "(false)". Le résultat de l’opération affiché est respectivement codice_67 ou codice_68.
L’opérateur "ou" (OR) est noté « codice_69 » (tube), "et" (AND) est noté « codice_70 » (esperluette), "non" (NOT) est noté « codice_71 » (tilde). Le "ou exclusif" (XOR) s'obtient avec codice_72.
Exemple
-->(%t & %f) | %f
ans =
F
On peut également utiliser les fonctions codice_73 et codice_74 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é codice_75 et de différence codice_76 ou codice_77, et les relations d'ordre codice_78, codice_79, codice_80 et codice_81.
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 codice_73. 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 codice_74.
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 :
Si la variable "x" est un booléen, la commande codice_89 "(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 (codice_50) et ∞ (codice_46) ne sont pas nulles et donc sont transformées en « 1 ».
À l'inverse, les opérateur booléens — codice_92, codice_93, codice_73 et codice_74 — 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 codice_96. Cette commande indique que la variable "x" est un polynôme (commande codice_97) dont l'indéterminée est notée « x » (le codice_98 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 codice_99 et codice_100, qui sont l'équivalent de codice_101 et codice_102 :
-->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 codice_103 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,
et codice_115 donne une erreur quelle que soit la valeur de "a" (sauf 1), codice_116 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 codice_117 :
Exemple
-->horner(p, 2)
 ans =
 9.
Fonctions spécifiques aux polynômes.
La fonction codice_119 donne les racines du polynôme "p". La fonction codice_120 donne la décomposition en facteurs irréductibles.
La fonction codice_121 donne une matrice dont les coefficients sont les coefficients du polynôme "p". ; on peut extraire le coefficient de degré "n" avec codice_122.
La fonction codice_123 renvoie le nom de l’indéterminée de "p" (ici, "x").
En fait, la commande codice_96 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 codice_125 définit de même le polynôme le plus simple ayant pour racine 2, c’est-à-dire "x" - 2.
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, codice_129 définit le polynôme le plus simple ayant pour racines 1 et 2, soit le polynôme "x"2 - 3"x" + 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 codice_130 à la fin des arguments. Par exemple, codice_131 définit le polynôme "a0" + "a1"·"x" + … + "an"·"x" "n".
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 codice_132 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"
Rappelons que pour faire figurer une apostrophe ou un guillemet dans la chaîne de caractères, il faut le doubler, codice_133 ou codice_134 (voir "Interface utilisateur > Chaînes de caractère").
Mais une chaîne de caractères peut aussi être obtenues à partir des codes ASCII. La fonction codice_135 renvoit :
--> ascii("a")
 ans =
 97.
--> ascii(65)
 ans =
 A
La fonction codice_136 crée un vecteur colonne de caractères à partir d'une matrice de nombres, par exemple
-->char([64, 65])
 ans =
 @A 
Notons que codice_137 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 :
Rechercher, remplacer, découper une chaîne.
La commande codice_152 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 codice_153 indique la longueur de la chaîne X.
La commande codice_154 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 « codice_1 » permet la concaténation de deux chaînes de caractère. La fonction codice_156 concatène une matrice de chaînes.
-->a = strcat(["a", "b" ; "c", "d"])
 a =
 acbd 
La fonction codice_157 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 codice_158, codice_159, …) ou bien pour fabriquer un nom de fichier.
La fonction codice_160 permet de transformer une chaîne en une expression Scilab (on parle « d'évaluation de la chaîne »). La fonction codice_161 permet d'exécuter le contenu de la chaîne.
-->a = "1";
-->evstr(a)*2
 ans =
 2.
-->b = "x"; c = "=5"; execstr(b+c)
-->x^2
 ans =
 25.
La commande codice_160 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 codice_164 "(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 (codice_165) 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 codice_166. 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 codice_167.
L’expression codice_168 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 codice_169 (deux-points) signifie « tous les indices », par exemple codice_170 est la première ligne de la matrice (c’est un vecteur ligne). Le caractère codice_171 (dollar) désigne le dernier indice (ligne ou colonne) d’une matrice. L'expression codice_172 désigne tous les indices entre "i"1 et "i"2. 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 codice_173 donne le même résultat).
Par ailleurs, l’expression codice_174 permet aussi de générer une matrice-ligne dont le premier coefficient est N1, le dernier est inférieur ou égal à N2, et le pas entre les coefficients est 1. L’expression codice_175 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, codice_176 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"1 et "x"2.
La fonction
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, codice_182 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 codice_183 "(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 :
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 codice_186 ou par codice_187, voir "Calcul numérique > Définition de fonctions extérieures"), et que "x" et "y" sont des vecteurs, alors la fonction codice_188 permet de bâtir une matrice "z" = ƒ("x", "y")
Ajouter ou supprimer des lignes, des colonnes.
Considérons une matrice M. Comme indiqué précédemment, codice_190 crée le vecteur ligne composé des coefficients de la ligne "i", et codice_191 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 codice_192 sera la matrice dont les coefficients sont les cosinii des coefficients de M.
La fonction codice_193 calcule l'exponentielle de chaque terme. L'exponentielle de la matrice (∑(1/"k"!)M"k") s'obtient avec la fonction codice_194.
La fonction codice_195 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 codice_196 renvoie le produit des deux valeurs, soit le nombre total d'éléments dans la matrice. On peut avoir le nombre de lignes avec codice_197 "(row)", et le nombre de colonnes avec codice_198.
Les opérations spécifiques aux matrices classiques sont :
Vecteur.
Un vecteur est une matrice ligne ou colonne (matrice 1 × "n" ou "n" × 1) ; l’expression codice_213 désigne la composante "i" du vecteur V.
Si l'on veut avoir la taille d'un vecteur codice_214 sous la forme d'un entier, on peut utiliser
La norme d'un vecteur codice_214 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 fonction codice_222 renvoie la plus grand élément de la matrice, et la fonction codice_223 renvoie le plus petit.
Si l'on tape codice_224, 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 codice_225.
On peut ajouter un paramètre après la matrice, sous la forme d'une caractère :
On peut mettre une suite de matrices de même taille dans codice_230 et </code>max</code>. 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 codice_231 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
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
La fonction codice_232 fait le produit cumulé, selon la même démarche.
La fonction codice_233 effectue un tri :
gsort(A) # tri par ordre décroissant
gsort(A, 'i') # tri par ordre croissant
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 codice_77, codice_235, codice_236, codice_79, codice_80 et codice_81.
Les fonctions codice_73 et codice_74 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 codice_242 ou codice_243.
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 :
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 :
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. Ce sont des nombres à virgule flottante "(floating point)" codés sur 64 bits (8 octets). Il s'ensuit que :
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 codice_264 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 :
Dans les deux cas, les donées sont placées dans la matrice M.
Notes.
"Interface" < ↑ > "Calcul numérique"