Types de données

Certaines constantes sont prédéfinies, et leur valeur ne peut être modifiée.

Constantes prédéfinies
%pi	3.1415927
%e	2.7182818
%i	$\sqrt{-1}$
%eps	précision machine
%inf	infini
%t	vrai
%f	faux
%s	variable de polynôme

Scilab est un langage faiblement typé. Les variables ne sont pas déclarées, et la même lettre peut désigner un réel, un entier, un polynôme, ou une fonction. Les types existent cependant, et peuvent être obtenus par typeof. Par défaut, les nombres sont traités comme des réels en double précision. Les calculs ne sont donc pas «exacts». La précision machine est donnée par la constante %eps, de l'ordre de $10^{-16}$. Cela ne signifie pas que les nombres inférieurs à %eps ou supérieurs à 1/%eps sont inaccessibles, mais Scilab ne peut distinguer deux réels que à %eps près.

help typeof
%eps
1/%eps
a=1+%eps
typeof(a)
a-1
b=(1+a)/2
b-a
b-1
1/%inf
1/0.0000000000000000000000000000000000000003
1/300000000000000000000000000000000000000000
A=[1,2,3;4,5,6;7,8,8]
A/A
A*(1/A)
2^[1:20]
2^2^[1:20]

La commande format permet de modifier l'affichage des réels.

a=1/3
format("v",15); a
format("e",5);  a
format("e",15); a
format("v",25); a
%eps
100000/3
tan(atan(1))
v=[-1:0.1:1];
v(11)
w=linspace(-1,1,21);
w(11)
format('v',10)   // retour aux valeurs par defaut

À part les réels, les entrées d'une matrice peuvent être des booléens, des complexes, des polynômes ou des chaînes de caractères. Les booléens sont %t (true) et %f (false) pour les saisies, T et F pour les affichages. L'égalité logique est notée == pour la distinguer de l'affectation.

a=2==3 
b=2<3
c=%t
a|(b&c)

Opérateurs logiques
==	égalité	~	non
<	$<$	>	$>$
<=	$\leqslant$	>=	$\geqslant$
&	et	|	ou

Les matrices booléennes sont le résultat d'opérations logiques matricielles (toujours terme à terme). Par exemple, si A et B sont deux matrices (réelles) de même taille, A<B est la matrice des booléens A(i,j)<B(i,j). Les opérateurs and et or peuvent s'appliquer à l'ensemble des éléments d'une matrice booléenne, à ses lignes ou à ses colonnes selon l'option choisie. La commande find(v) retourne la liste des indices des coordonnées «vraies» du vecteur booléen v. Si v est une matrice, ses colonnes sont préalablement concaténées. Si A est une matrice et B est une matrice de booléens, la commande A(B) extrait de A les coordonnées correspondant aux indices pour lesquels B est à vrai. La fonction bool2s transforme des booléens en 0 ou 1.

x=rand(2,10)
b=x<0.5
bool2s(b)
and(b)
and(b,"c")
and(b,"r")
or(b)
or(b,"r")
b1=b(1,:); b2=b(2,:);
b1 & b2
b1 | b2
b1
find(b1)
y=[1:10]
y(b1)
A=[1,2,3;4,5,6;7,8,9]
x=[%t,%f,%t]
A(x,x)
A(~x,x)
B=rand(3,3)<0.5
A(B)

Les complexes sont définis à l'aide de la constante %i ($\sqrt{-1}$) ou bien en affectant sqrt(-1) à une nouvelle variable. A noter que par défaut A' est la transposée conjuguée de A. La transposée non conjuguée est A.'. Les fonctions classiques appliquées à un complexe donnent toujours un résultat unique, même si mathématiquement elles ne sont pas définies de façon unique (racine carrée, logarithme, puissances).

A=[1,2;3,4]+%i*[0,1;2,3]
real(A)
imag(A)
conj(A)
A'
A.'
abs(A)
phasemag(A)
i=sqrt(-1)
%i*i
A*i
%e^(%i*%pi)
x=log(%i)
exp(x)
x=%i^(1/3)
x^3

Complexes
real	partie réelle
imag	partie imaginaire
conj	conjugué
abs	module
phasemag	argument (en degrés)

Les polynômes et les fractions rationnelles constituent un type de données particulier. On peut construire un polynôme comme résultat d'opérations sur d'autres polynômes. Il existe par défaut un polynôme élémentaire, %s. On peut construire un polynôme d'une variable quelconque à l'aide de la fonction poly, en spécifiant soit ses racines (par défaut), soit ses coefficients. Les fractions rationnelles sont des quotients de polynômes. Par défaut, Scilab effectue automatiquement les simplifications qu'il reconnaît.

apropos poly
help poly
v=[1,2,3]
p1=poly(v,"x")
roots(p1)
p2=poly(v,varn(p1),"c") // meme variable que p1
coeff(p2)
p1+p2
p3=1+2*%s-3*%s^2
p1+p3                   // erreur : variables differentes
p4=(%s-1)*(%s-2)*(%s-3)
p3/p4

Polynômes
poly(v,"x")	polynôme unitaire dont les racines sont les éléments de v
poly(v,"x","c")	polynôme dont les coefficients sont les éléments de v
inv_coeff(v)	idem
coeff(P)	coefficients du polynôme P
roots(P)	racines du polynôme P
factors	facteurs irréductibles réels d'un polynôme
horner	évaluation d'un polynôme
varn(P)	indéterminée du polynôme P

Les chaînes de caractères, encadrées par des apostrophes, en anglais quotes, ("..." ou '...'), permettent de définir des expressions mathématiques, interprétables ensuite comme des commandes à exécuter ou des fonctions à définir. Elles servent aussi d'intermédiaire pour des échanges de données avec des fichiers. On peut transformer et formater des nombres en chaînes de caractères (voir apropos string).

expression=["x+y","x-y"]     // matrice de 2 chaines de caracteres
length(expression)           // longueurs des 2 chaines
size(expression)             // taille de la matrice 
part(expression,2)           // deuxieme caractere de chaque chaine
expression(1)+expression(2)  // concatenation des deux chaines
x=1; y=2;
evstr(expression)
x=1; instruction="y=(x+1)^2"
execstr(instruction)
y
deff("p=plus(x,y)","p=x+y")
plus(1,2)
plus(2,3)

Chaînes de caractères
evstr	évaluer une expression
deff	définir une fonction
execstr	exécuter une instruction
length	longueur
part	extraire
+	concaténer
string	transformer en chaîne