suivant: Graphiques monter: CN_ECS précédent: Table des matières Table des matières Index

Sous-sections

Vecteurs et matrices

A savoir pour commencer

Pour lancer Scilab on a deux possibilités :
$\bullet$ soit on ouvre un terminal, on se place dans le répertoire de travail grâce à la commande cd et ensuite on tape scilab ;

$\bullet$ soit on passe par le menu $\fbox{Applications}$ -> $\fbox{Math}$ -> $\fbox{Scilab}$ , dans ce cas le répertoire de travail peut être choisi dans le menu $\fbox{Fichier}$ -> $\fbox{Changer le répertoire courant}$ .

$\includegraphics[width=12cm]{scilab_w_intro.eps}$

On obtient ainsi une ligne commande, indiquée par -->
Pour alléger ces notes, on omettra systématiquement ce ``prompt'' (invite de commande) :

1+1

Scilab est basé sur le principe que tout calcul, programmation ou tracé graphique peut se faire à partir de matrices rectangulaires.

En Scilab, tout est matrice : les scalaires sont des matrices $1\times 1$ , les éléments de $\mathbb{R}^n$ sont des vecteurs colonnes, c-à-d des matrices $n\times 1$ et les vecteurs lignes sont des matrices $1\times n$ .

Pour démarrer, et pour une utilisation ``légère'', vous rentrerez des commandes ligne par ligne.

Un ``retour-chariot'' $\fbox{Entrée}$ exécute la ligne, sauf dans deux cas :

$\bullet$ si la ligne se termine par deux points, la séquence de commandes se prolonge sur la ligne suivante ;

$\bullet$ si la commande définit une matrice, les lignes de cette matrice peuvent être séparées par des retour-chariot. Ceci sert essentiellement à importer de grandes matrices depuis des fichiers.

Dans une ligne de commande, tout ce qui suit // est ignoré, ce qui est utile pour les commentaires. Les commandes que nous proposons sur des lignes successives sont supposées être séparées par des retour-chariot.

A=[1,2,3;4,5,6;7,8,9]  // definit une matrice 3X3
A=[1,2,3;4,            // message d'erreur
A=[1,2,3;4,..          // attend la suite de la commande
5,6;7,8,9]             // la meme matrice est definie
A=[1,2,3;              // premiere ligne 
4,5,6;                 // deuxieme ligne
7,8,9]                 // fin de la matrice

Ajouter un point virgule en fin de ligne supprime l'affichage du résultat (le calcul est quand même effectué). Ceci évite les longs défilements à l'écran, et s'avère vite indispensable.

x=ones(1,100);         // rien n'apparait
x                      // le vecteur x a bien ete defini

Ligne de commande : Il est fréquent que des commandes doivent être répétées avec des modifications mineures. Il est inutile de tout taper à nouveau : il suffit d'appuyer sur la touche $\fbox{$\uparrow$}$ pour rappeler les commandes précédentes. On peut alors les modifier : en reculant dans la ligne avec $\fbox{$\leftarrow$}$ ou en avançant avec $\fbox{$\rightarrow$}$ . On les exécute à nouveau par un retour-chariot.

Dans les noms de variables, les majuscules sont distinctes des minuscules. Les résultats sont affectés par défaut à la variable ans (``answer''), qui contient donc le résultat du dernier calcul non affecté. Toutes les variables d'une session sont globales et conservées en mémoire. Des erreurs proviennent souvent de confusions avec des noms de variables déjà affectés. Il faut penser à ne pas toujours utiliser les mêmes noms ou à libérer les variables par clear. Les variables courantes sont accessibles par who et whos.

a=[1,2]; A=[1,2;3,4];  // affecte a et A
1+1                    // affecte ans
who                    // toutes les variables
whos()                 // les details techniques 
clear a                
who                    // a disparait 
clear                  
who                    // a, A et ans disparaissent

Il faut aussi faire attention à ne pas utiliser des noms de fonctions prédéfinies.

gamma(1)    // appel de la fonction gamma
gamma=3     // warning
gamma(1)    // 1er de la variable gamma
gamma(4)    // erreur : pas de 4e element dans gamma
clear       // efface les variables de l'utilisateur
gamma(4)    // la fonction gamma est de nouveau disponible

L'aide en ligne est appelée par help. La commande apropos permet de retrouver les rubriques d'aide quand on ignore le nom exact d'une fonction.

help help
help apropos
apropos matrix         // rubriques dont le titre contient "matrix"
help matrix            // aide de la fonction "matrix"

On peut aussi accéder à l'aide grâce au menu $\fbox{\tt ?}$ -> $\fbox{Aide de Scilab}$ de la fenêtre Scilab.

Construire des matrices

On peut saisir manuellement des (petites) matrices. Les coefficients d'une même ligne sont séparés par des blancs ou des virgules (préférable). Les lignes sont séparées par des points-virgules. La transposée est notée par une apostrophe. Elle permet en particulier de changer un vecteur ligne en un vecteur colonne.

x=[1,2,3]
x'
A=[1,2,3;4,5,6;7,8,9]
A'

On a souvent besoin de connaître les dimensions d'une matrice (par exemple pour vérifier si un vecteur est une ligne ou une colonne). On utilise pour cela la fonction size.

La fonction size
`size(A)`	nombre de lignes et de colonnes
`size(A,"r")`ou `size(A,1)`	nombre de lignes
`size(A,"c")`ou `size(A,2)`	nombre de colonnes
`size(A,"*")`	nombre total d'éléments

Note : ``ligne'' est en anglais ``row'', et ``colonne'' se traduit par ```column''.

help size
A=[1,2,3;4,5,6]
size(A)
size(A')
size(A,1)
size(A,"c")
size(A,"*")

Les commandes d'itération permettent de construire des vecteurs de nombres séparés par des pas positifs ou négatifs. La syntaxe de base, [deb:pas:fin], retourne un vecteur ligne de valeurs allant de deb à fin par valeurs séparées par des multiples de pas. Les crochets sont facultatifs. Par défaut, pas vaut . Selon que fin-deb est ou non un multiple entier de pas, le vecteur se terminera ou non par fin.

Si l'on souhaite un vecteur commençant par deb et se terminant par fin avec n coordonnées régulièrement espacées, il est préférable d'utiliser linspace(deb,fin,n).

v=0:10
v=0.10       
v=[0:10]
v=[0;10]
v=[0,10]              // attention aux confusions
v=[0:0.1:1]
size(v)
v=[0:0.1:0.99]
size(v)
v=[0:0.15:1]
v=[1:-0.15:0]
v=linspace(0,1,10)
v=linspace(0,1,11)
v=linspace(0,1)      // attention, n=100 par défaut
v=logspace(1,2,11)
log10(v)             // voir l'aide en ligne

L'élément de la i-ième ligne, j-ième colonne de la matrice A est A(i,j). Si v et w sont deux vecteurs d'entiers, A(v,w) désigne la sous-matrice extraite de A en conservant les éléments dont l'indice de ligne est dans v et l'indice de colonne dans w. A(v,:) (respectivement : A(:,w)) désigne la sous-matrice formée des lignes (resp. : des colonnes) indicées par les coordonnées de v (resp. : w). Les coordonnées sont numérotées à partir de . Le dernier indice peut être désigné par $.

A=[1,2,3;4,5,6]
A(2,2)
A(:,2)
A(:,[1,3])
A(1,$)
A($,2)

On peut modifier un élément, une ligne, une colonne, pourvu que le résultat reste une matrice. Pour supprimer des éléments, on les affecte à la matrice vide : []

A=[1,2,3;4,5,6]
A(1,3)=30
A(:,[1,3])=[10,20]       // erreur
A(:,[1,3])=[10,30;40,60]
A(:,[1,3])=0             
A(:,2)=[]

Il suffit d'une coordonnée pour repérer les éléments d'un vecteur ligne ou colonne.

v=[1:6]
v(3)
v(4)=40
v([2:4])=[]
w=[1:6]'
w([2,4,6])=0

Faire appel à un élément dont les coordonnées dépassent celles de la matrice provoque un message d'erreur. Cependant on peut étendre une matrice en affectant de nouvelles coordonnées, au-delà de sa taille. Les coordonnées intermédiaires sont nulles par défaut.

A=[1,2,3;4,5,6]
A(0,0)          // erreur
A(3,2)          // erreur
A(3,2)=1        
v=[1:6]
v(8)            // erreur
v(8) = 1

Vecteurs
`x:y`	nombres de `x` à `y` par pas de 1
`x:p:y`	nombres de `x` à `y` par pas de `p`
`linspace(x,y)`	nombres entre `x` et `y`
`linspace(x,y,n)`	`n` nombres entre `x` et `y`
`v(i)`	`i`-ième coordonnée de `v`
`v($)`	dernière coordonnée de `v`
`v(i1:i2)`	coordonnées `i1` à `i2` de `v`
`v(i1:i2)=[]`	supprimer les coordonnées `i1` à `i2` de `v`

Matrices
`A(i,j)`	coefficient d'ordre `i,j` de `A`
`A(i1:i2,:)`	lignes `i1` à `i2` de `A`
`A($,:)`	dernière ligne de `A`
`A(i1:i2,:)=[]`	supprimer les lignes `i1` à `i2` de `A`
`A(:,j1:j2)`	colonnes `j1` à `j2` de `A`
`A(:,$)`	dernière colonne de `A`
`A(:,j1:j2)=[]`	supprimer les colonnes `j1` à `j2` de `A`
`diag(A)`	coefficients diagonaux de `A`

Si A, B, C, D sont 4 matrices, les commandes [A,B], [A;B], [A,B;C,D] retourneront des matrices construites par blocs, pourvu que les dimensions coïncident. En particulier, si v et w sont deux vecteurs lignes, [v,w] les concaténera, tandis que [v;w] les empilera.

A=[1,2,3;4,5,6]
M=[A,A]
M=[A;A]
M=[A,A']                 // erreur
M=[A,[10;20];[7,8,9],30]  
M=[A,[10,20];[7,8,9],30] // erreur

Des fonctions prédéfinies permettent de construire certaines matrices particulières.

Matrices particulières
`zeros(m,n)`	matrice nulle de taille `m,n`
`ones(m,n)`	matrice de taille `m,n` dont les coefficients valent 1
`eye(m,n)`	matrice identité de taille min(`m,n`), complétée par des zéros
`rand(m,n)`	matrice de taille `m,n` à coefficients aléatoires uniformes sur
`diag(v)`	matrice diagonale dont la diagonale est le vecteur `v`
`diag(v,k)`	matrice dont la -ième diagonale est le vecteur `v`
`diag(A)`	extrait la diagonale de la matrice `A`
`diag(A,k)`	extrait la -ième diagonale de la matrice `A`
`triu(A)`	annule les coefficients au-dessous de la diagonale
`tril(A)`	annule les coefficients au-dessus de la diagonale
`toeplitz`	matrices à diagonales constantes
`testmatrix`	carrés magiques et autres

d=[1:6]
D=diag(d)
diag(d,1)
A=[1,2,3;4,5,6]
d=diag(A)
B=[A,zeros(2,3);rand(2,2),ones(2,4)]
diag(B,1)
diag(B,-1)
diag(B,0)
help testmatrix
M=testmatrix("magi",3)
help toeplitz
M=toeplitz([1:4],[1:5])
triu(M)
tril(M)

Les commandes zeros, ones, eye, rand retournent des matrices dont la taille peut être spécifiée soit par un nombre de lignes et de colonnes, soit par une autre matrice. Si un seul nombre est donné comme argument, ce nombre est compris comme une matrice de taille $1\times 1$ .

A=ones(5,5)      // 5 lignes et 5 colonnes
rand(A)          // idem
eye(A)           // idem 
eye(5)           // 1 ligne et 1 colonne
ones(5)          // idem
rand(size(A))    // 1 ligne et 2 colonnes

On dispose de deux moyens pour réordonner des coefficients en une nouvelle matrice. La commande A(:) concatène toutes les colonnes de A en un seul vecteur colonne (on peut jouer avec la transposée pour concaténer les vecteurs lignes). La fonction matrix crée une matrice de dimensions spécifiées, pourvu qu'elles soient compatibles avec l'entrée. On peut même créer avec matrix des tableaux à plus de deux entrées (hypermatrices), ce qui ne sert que rarement.

v=[1:6]
help matrix
A=matrix(v,2,2)    // erreur
A=matrix(v,3,3)    // erreur
A=matrix(v,2,3)
A=matrix(v,3,2)'
w=A(:)
A=A'; w=A(:)'
H=matrix([1:24],[2,3,4])

Remarquons qu'un peu d'algèbre permet souvent de construire des matrices particulières à peu de frais, en utilisant le produit, noté *, et la transposée. Le produit de Kronecker, kron ou .*., peut également être utile.

A=ones(4,1)*[1:5]
A=[1:4]'*ones(1,5)
B=[1,2;3,4]
kron(B,B)
kron(B,eye(B))
kron(eye(B),B)
kron(B,ones(2,3))
kron(ones(2,3),B)

Un générateur(s) de nombres pseudo-aléatoires plus performant que rand est fourni par la commande grand. Dans sa syntaxe, il faut indiquer les dimensions du tableau, la loi de distribution et les paramètres nécessaires :

grand(2,2,'bin',100,0.5)
grand(1,10,'uin',-100,100)
help grand

Opérations

Les opérations numériques s'effectuent en suivant les ordres de priorité classiques (puissance avant multiplication, et multiplication avant addition). Pour éviter les doutes il est toujours prudent de mettre des parenthèses.

2+3*4
(2+3)*4
2^3*4
2^(3*4) 
2^3^4
(2^3)^4

Toutes les opérations habituelles +, -, *, ^, / sont matricielles. Tenter une opération entre matrices de tailles non compatibles retournera en général un message d'erreur, sauf si une des matrices est un scalaire. Dans ce cas, l'opération (addition, multiplication, puissance) s'appliquera terme à terme.

A=[1,2,3;4,5,6]
A+ones(1,3)     // erreur
A+ones(A)
A+10
A*10
A*ones(A)       // erreur
A*ones(A')
A'*ones(A)

Il n'y a pas d'ambiguïté sur l'addition, mais il est souvent utile de pouvoir appliquer des multiplications terme à terme sans qu'elles soient interprétées comme des produits matriciels.

Dans ce cas on considère que les matrices sont des tableaux qui doivent avoir les mêmes dimensions afin de garantir un sens aux opérations terme à terme. Plus loin (section 1.5) on verra que les fonctions mathématiques habituelles s'appliquent en général terme à terme.

Le symbole d'opérateur, * ou ^, doit alors être précédé d'un point, .* ou .^

A=[1,2,3;4,5,6]
A*A             // erreur
A*A'
A.*A'           // erreur
A.*A
A=[1,2;3,4]
A^3
A.^3            // attention
2.^A
2^A             // attention
A.^A

La division est un cas particulier dangereux. Par défaut, la division à droite, A/B, calcule une solution d'un système linéaire, X*B=A.

A=[1,2;3,4]
B=[1,2;2,2]
D=A./B
X=A/B
X*B

Si v est un vecteur colonne, 1/v retourne un vecteur ligne w tel que w*v=1. Ceci engendre des erreurs fréquentes, d'autant que 1./v, compris comme (1.0)/v, retourne la même chose. Il y a plusieurs solutions à ce problème, dont la plus simple consiste à mettre des parenthèses : (1)./v

v=[1,2,3]'
w=1/v
w*v
1./v
(1)./v
ones(v)./v
v.^(-1)
v=v'
w=1/v
1./v

Opérations matricielles
`+ -`	addition, soustraction
`* ^`	multiplication, puissance (matricielles)
`.* .^`	multiplication, puissance terme à terme
`A\b`	solution de `A*x=b`
`b/A`	solution de `x*A=b`
`./`	division terme à terme

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 bien sûr, et peuvent être obtenus par la fonction type. 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 que Scilab ne peux distinguer deux réels que à %eps près.

help type
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 au valeurs par défaut

À part les réels, les entrées d'une matrice peuvent être des complexes, des booléens, 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
`<`		`>`
`<=`	$\leq$	`>=`	$\geq$
`&`	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. Cette propriété, fort utile en programmation, a pour corollaire quelques comportements curieux : ones(B) retournera une matrice de même taille que la matrice de booléens B. 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,"x","c")
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 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

Les chaînes de caractères, encadrées par des côtes ("..." 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

Fonctions

Scilab propose beaucoup de fonctions dans des domaines très variés. On peut en obtenir la description par help. On peut retrouver une fonction avec apropos, qui retourne les rubriques d'aide dont le titre contient une chaîne de caractères donnée. De très nombreux exemples sont disponibles en démonstration, on y accède par le menu $\fbox{?}$ -> $\fbox{Démonstrations}$

Les fonctions numériques s'appliquent en général à chaque terme d'un vecteur ou d'une matrice. Il ne faut pas oublier que la multiplication, la puissance, la division doivent être précédées par un point pour s'appliquer terme à terme.

x=1:10
y=sin(x)
y=x*sin(x)       // erreur
y=x.*sin(x)
y=1./x.*sin(x)   // erreur
y=(1)./x.*sin(x)
y=sin(x)./x
A=[ 4, 4; 4, 4]
sqrt(A)
A.^(1/2)
B=A^(1/2)        // attention
B*B

Fonctions mathématiques
`sqrt`	`exp`	`log`
`sin`	`cos`	`tan`
`asin`	`acos`	`atan`
`round`	`floor`	`ceil`

Les fonctions vectorielles s'appliquent à l'ensemble d'un vecteur ou d'une matrice, et retournent un scalaire. Pour appliquer une telle fonction colonne par colonne ou ligne par ligne, il faut rajouter l'option "r" ou "c". Il n'est pas toujours évident de décider laquelle des deux options choisir. Il faut se souvenir qu'avec l'option "r", la fonction retournera un vecteur ligne (row), et donc s'appliquera aux colonnes. Par exemple, sum(A,"r") retourne un vecteur ligne, qui est formé des sommes des coefficients dans chaque colonne.

Fonctions vectorielles
`max`	maximum
`min`	minimum
`sort`	tri par ordre décroissant
`gsort`	tri, ordres particuliers
`sum`	somme
`prod`	produit
`cumsum`	sommes cumulées
`cumprod`	produits cumulés
`mean`	moyenne
`median`	médiane
`st_deviation`	écart-type
`stdev`	écart-type

A=[1,2,3;4,5,6]
sum(A)
sum(A,"r")
sum(A,"c")
cumsum(A,"r")
cumsum(A,"c")
cumsum(A)
x=rand(1,5)
mean(x)
st_deviation(x)
median(x)
sort(x)
gsort(x,"c","i")

L'utilisation de Scilab consiste en général à étendre le langage par de nouvelles fonctions, définies par des séquences d'instructions. Nous avons vu l'utilisation de deff, nous verrons plus loin la syntaxe des fichiers de fonctions. Comme alternative à deff, signalons la possibilité de définir une fonction sur plusieurs lignes dans la fenêtre Scilab. La première ligne est nécessairement du type function y=f(x), la dernière est endfunction. Il n'est pas recommandé d'utiliser cette possibilité si la fonction à écrire est un tant soit peu compliquée. Écrire un fichier de fonction externe, comme nous le verrons plus loin, permet une programmation beaucoup plus claire et un débuggage plus efficace.

Il est important de choisir des noms différents pour les nouvelles fonctions, sans quoi les définitions se superposeront, y compris à celles des fonctions prédéfinies.

deff("y=sin(x)","y=2*x")      // message d'avertissement
sin(2)
clear
sin(2)

Les nouvelles fonctions sont traitées comme des variables, à la différence des fonctions prédéfinies (primitives) : une fonction définie par deff peut être utilisée comme argument dans fplot2d fonction mais une primitive ne peut pas.

deff("z=pente_secante(f,x,y)","z=(f(y)-f(x))/(y-x)")
x=%pi; y=%pi+0.01;
pente_secante(cos,x,y)        // correct
deff("y=f(x)","y=cos(x)")  
pente_secante(f,x,y)
z=[0:0.01:%pi];
fplot2d(z,cos)                // erreur
fplot2d(z,f)

Quand on définit une nouvelle fonction numérique, on a toujours intérêt à faire en sorte qu'elle puisse s'appliquer correctement à une matrice, ce qui impose de veiller aux multiplications terme à terme. On peut aussi utiliser feval, qui distribue l'évaluation d'une fonction sur l'ensemble des éléments d'un vecteur.

deff("y=f(x)","y=x*sin(x)")
f(1)
f([1:5])                      // erreur
help feval
feval([1:5],f)
deff("y=g(x)","y=x.*sin(x)") 
g(1)
g([1:5])

Certaines fonctions peuvent retourner plus d'un argument. Par exemple les fonctions de tri sort et gsort retournent par défaut le vecteur trié, mais peuvent aussi donner la permutation des coordonnées qui a été effectuée. Les fonctions max et min donnent aussi la position des maxima et minima dans une matrice.

v=rand(1,5)
max(v)
[m,i]=max(v)
sort(v)
[vtrie,perm]=sort(v)

suivant: Graphiques monter: CN_ECS précédent: Table des matières Table des matières Index

Georges Koepfler 2011-01-19