Informatique Scientique

Introduction à GNU Octave

Ludovic Chatellier

1 Prise en main
GNU Octave est un langage de programmation interprété destiné au calcul numérique, à la
philosphie très proche de celle du logiciel commercial Matlab édité par The Mathworks, Inc.
Pour l'essentiel, l'environnement d'Octave permet d'éxécuter des commandes mathématiques, à la
manière d'une calculatrice scientique évoluée, de gérer des chiers et de concevoir des programmes
structurés. L'une des principale caractéristiques d'Octave réside dans le fait qu'il est conçu pour
traiter nativement des problèmes d'algèbre linéaire. L'entité essentielle de travail d'Octave est donc
la matrice.

1.1 Démarrage

Démarrage d'Octave sous Linux : ouvrir une console, éxécuter la commande octave. Pour
quitter Octave, entrer quit ou exit.

L'environnement de travail d'Octave est intégré à la console, depuis laquelle les instructions
peuvent être invoquées une à une, en mode interactif. Le résultat d'un commande sera systé-
matiquement aché à l'écran. Pour interdire cet achage, chaque commande devra être terminée
par un point-virgule, celui-ci permettant par ailleurs de séparer les commandes successives sur une
même ligne (la virgule également, tout en conservant l'achage du résultat).

Octave permet également de dénir des scripts (programmes) et des fonctions enregistrés dans
des chiers texte, préférentiellement munis de l'extension .m.

L'utilisation d'Octave en mode interactif reprend pour beaucoup la philosophie du mode console
de Linux : rappel de l'historique de commandes par les èches haut/bas, auto-complétion des noms
de chiers, de variables ou de constantes par la touche de Tabulation, achage de l'aide en ligne,
etc . . .

Les scripts et fonctions s'éxécutent lorsque leur nom est invoqué en mode interactif. Il est égale-
ment possible d'éxécuter un unique script depuis une console linux par une commande de type
octave script.m. Pour rester dans l'environnement Octave après éxécution du script, il faut en-
trer octave script.m --persist. Les autres options de démarrage d'Octave peuvent être consul-
tées par l'intermédiaire de la commande octave --help.

Au démarrage, Octave éxécute les instructions contenues dans un chier octaverc déni par
l'administrateur du système. Il est possible à tout utilisateur de dénir un chier de démarrage
personnalisé, nommé impérativement .octaverc, à placer dans un dossier de son choix. Octave
éxécutera ce script s'il le trouve dans le dossier depuis lequel il est lancé.

Il peut être utile de rendre ses propres fonctions et scripts directement accessibles dans Octave.
Il sut pour cela d'indiquer à Octave où les trouver, par l'intermédiaire de la variable LOADPATH,
avec une commande de type :

1
LOADPATH = [LOADPATH '~/Octave/:~/Octave/dossier1/:~/Octave/dossier2/:'];
que l'on intègre généralement au chier .octaverc.

Il est en principe possible d'interrompre l'éxécution de toute commande Octave en eectuant

la combinaison Ctrl+c.

Octave fournit une aide en ligne directement accessible par la commande help qui ache une
liste des opérateurs, fonctions, constantes et variables disponibles.
Les informations sur une fonction (ou une commande) et son utilisation sont obtenues par la
commande help suivie du nom de la fonction. Par exemple, help help renvoie les modalités
d'utilisation de la commande help.
La commande help -i donne accès au manuel complet d'Octave en mode texte. Ce manuel est
également disponible en version HTML sur à l'adresse :
http ://www.gnu.org/software/octave/doc/interpreter/.

1.2 Notions de base

Type de données : Le type de données essentiel d'Octave est la matrice, constituée de nombres
réels ou complexes double précision, et de dimensions quelconques. Un scalaire est donc une matrice
de dimension 1×1. Les nombres entiers sont également représentés par des réels. Octave traite de
plus les chaînes de caractères, les cellules (type tableur), et les données structurées.

Constantes et variables spéciales : Certaines constantes utiles sont prédénies dans Octave,
comme π ou e, qui peuvent être invoquées par les commandes pi et e.
Les nombre les plus élevés pouvant être traités par octave sont −2.2251 × 10308 et 1.7977 × 10308 ,
avec la précision eps=2.2204×10−16 , qui peut être modiée. Au delà de ces valeurs, Octave renvoie
les constantes -Inf ou Inf.
En cas d'indétermination dans un calcul, Octave renvoie la constante NaN, pour Not A Number.
La variable ans (pour answer) contient toujours le dernier résultat obtenu.

Opérations arithmétiques : Les opérations de base d'Octave sont l'addition, la soustraction,

la division et la multiplication, accessibles par les symboles +, -, * et /. Ces opérations sont à
comprendre au sens matriciel, il convient donc de les appliquer à des matrices de dimensions com-
patibles. En particulier, l'opérateur de division eectue une inversion de matrice. La division par
le terme de gauche se fait en utilisant le symbole \.
Pour eectuer multiplications et divisions terme à terme, il faut utiliser le symbole . avant l'opé-
rateur, soit .*, ./ ou .\.
L'élévation d'une matrice à une puissance quelconque (entière, réelle ou complexe) se fait par
l'opérateur ^ ou par .^ en calcul terme à terme.

2 Saisie et manipulation des données

2.1 Vecteurs ou tableaux à une dimension

Dans Octave, le vecteur est un cas particulier de matrice à une dimension. Le moyen le plus
simple de saisir un vecteur est d'entrer ses éléments en les séparant par un espace ou une virgule,
ou encore un point virgule :

octave>x = [ 1 2 3 ]
x=
1 2 3
octave>x = [ 1 , 2 , 3 ]
x=

2
 1 2 3
octave>x = [ 1 ; 2 ; 3 ]
x=
1
2
3

La longueur d'un vecteur s'obtient par la commande :

octave>length(x)
ans=
3

On peut construire un vecteur dont les éléments se suivent à intervalle régulier à l'aide du symbole
::

octave>x = [ 1 : 3 ]
x=
1 2 3
octave>x = [ 1 : 2 : 5 ]
x=
1 3 5
octave>x = [ 1.1 : .2 : 1.5 ]
x=
1.1000 1.3000 1.5000

Exemples : des fonctions comme sum, cumsum ou mean s'appliquent directement aux vecteurs.
Les autres fonctions prédénies sont détaillées dans l'aide et le manuel d'Octave.

2.2 Matrices ou tableaux à deux dimension

Les matrices peuvent être construites de manière similaire aux vecteurs :

octave>x=[ 1:3 ; 4:6 ]

x=
1 2 3
4 5 6

On peut également utiliser un retour à la ligne :

octave>x = [1:3
>4:6]
x=
1 2 3
4 5 6

Les dimensions d'une matrice s'obtiennent par la commande :

octave>[m n] = size(x)
m = 2
n = 3

Les éléments d'une matrice peuvent être extraits à l'aide de leurs indices :

3
octave>x=[ 1:3 ; 4:6 ]; x(1,2)
ans = 2
octave>x=[ 1:3 ; 4:6 ]; x(1,2:3)
ans =
2 3

On peut construire matrices et vecteurs à partir de données existantes :

octave>x=[ 1:3 ; 4:6 ]; y=[x [pi ; 2*pi] ]

y =
1.0000 2.0000 3.0000 3.1416
4.0000 5.0000 6.0000 6.2832

Certaines matrices particulières sont prédénies, comme la matrice Identité eye(n), la matrice
nulle zeros(m,n) ou zeros(n), la matrice unité ones(m,n) ou ones(n) ou encore la matrice aléa-
toire rand(m,n) ou rand(n), qui renvoie des élements pseudo-aléatoires uniformément répartis
entre 0 et 1.

Les opérations sur les matrices ne peuvent s'eectuer que si leur dimensions sont compatibles.
En particulier, une matrice non carrée ne pourra être multipliée par elle même. Dans certains cas
il est nécessaire de transposer une matrice, ce qui s'eectue à l'aide du symbole '. Par exemple :

octave>x = [1:3 ; 4:6]; y = x*x'

y=
14 32
32 77

Exemples : les fonctions sum, cumsum ou mean s'appliquent aux vecteurs colonne constituant une
matrice. De nombreuses fonctions spéciques au calcul matriciel sont prédénies, comme det,
trace, diag, inv, . . .

2.3 Nombres complexes

L'imaginaire pur i tel que i2 = −1 est noté i ou j et permet de construire les nombres com-
plexes sous la forme :

octave>z = 1 + 2i*eye(2)
z=
1 + 2i 1 + 0i
1 + 0i 1 + 2i

La norme, l'argument et le conjugué d'un complexe s'obtient par abs, angle et conj.
Les variables i et j peuvent être redénies par l'utilisateur, elles perdent alors leur valeur initiale
tant qu'elles ne sont pas détruites (commande clear).

2.4 Polynômes

Un polynôme est représenté par un tableau contenant ses coecients classés dans l'ordre des
puissances décroissantes. On peut évaluer les valeurs prises par un polynôme en un ou plusieurs
points à l'aide de la fonction polyval.
La fonction roots permet de déterminer les racines d'un polynôme. La fonction poly permet de
dénir un polynôme à partir de ses racines.
Les fonctions conv et deconv (pour convolution et déconvolution) pemettent de multiplier ou
diviser deux polynômes entre eux.

4
La fonction polyfit dénit un polynôme de degré arbitraire permettant d'approximer une série
de données au sens des moindres carrés.

2.5 Chaînes de caractère

Un chaîne de caractères est un cas particulier de matrice dont les éléments sont des caractères
alphanumériques, représentés par des nombres entiers correspondant à leur code ASCII. On dénit
une chaîne de caractères en la délimitant par deux symboles ' :

octave>c = 'Octave'
c = Octave

Toute les opérations et manipulations relatives aux matrices peuvent s'appliquer aux chaînes de
caractères.

3 Graphiques
Octave propose plusieurs possibilités d'achage graphique des résultats par l'intermédiaire du
logiciel gnuplot. Il est également possible d'exploiter directement les possibilités graphiques de
gnuplot en utilisant les commandes gplot et gsplot, équivalentes aux commandes plot et splot
de gnuplot.

3.1 Graphiques en deux dimensions

La commande plot est le moyen le plus simple d'obtenir un ou plusieurs tracés en deux di-
mensions, et d'en choisir titre, couleur et symboles :

octave> x=[0:.05:2*pi];plot(x,sin(x),'-11;Sinus;',x,cos(x),'-23;Cosinus;')

La commande hold permet de superposer plusieurs tracés les uns aux autres (hold on) ou de
remplacer le tracé existant (hold off). Un tracé peut être eacé par clearplot ou clg.
Les titres et légendes sont modiables par title, xlabel, ylabel.
La zone de tracé est modiable par axis, l'achage d'une grille se fait par grid [on/off].

Autres fonctions : semilogx, semilogy, loglog, polar, multiplot, mplot, bar, errorbar, hist,
stairs.

3.2 Graphiques en trois dimensions

Un graphique en trois dimension peut être réalisé par la commande mesh à partir de matrices
de dimensions identiques représentant les coordonnées d'un maillage 2D et d'un champ de valeurs
correspondant.

octave> t=[-pi:pi/10:pi];[x,y]=meshdom(t,t);
octave> z=sin(x.^2+y.^2)./(x.^2+y.^2);
octave> mesh(x,y,z)

La commande contour, basée sur le même principe, permet d'acher en 2D les lignes de ni-
veaux correspondant à un champ 3D.
Les commandes image et imagesc permettent d'acher les valeurs contenues dans une matrice
sous forme d'image par l'intermédiaire du logiciel ImageMagick.

5
3.3 Impression/Export des graphiques

Il est possible d'imprimer les graphiques ou de les exporter sous forme de chiers. La commande
gset suivie de diérentes options permet de rediriger un tracé vers une imprimante ou un chier.
Exemple pour un chier postscript couleur :
octave> gset term postscript color
octave> gset output "nom_fichier.eps"
octave> plot(x,y)

Ici, si un graphique est déjà aché, l'instruction replot permet de renouveler le tracé an de
l'inclure au chier postscript. Tout nouveau graphique sera ajouté au chier postscript jusqu'à ce
qu'un nouveau nom de chier soit demandé ou que l'instruction :
octave>gset term x11
soit entrée. Celle-ci permet de revenir à un achage à l'écran.
Pour imprimer un graphique, il faut spécier un langage d'impression (généralement postscript)
et entrer un nom d'imprimante sous cette forme :
octave>gset output "|lpr -Pnom_imprimante
puis relancer le tracé.
Note : Pour une utilisation systématique, il est préférable de remplacer la commande gset par la
commande interne __gnuplot_set__.

4 Scripts et Fonctions
Octave permet à l'utilisateur de dénir ses propres scripts et fonctions. Par analogie avec
Matlab, ceux-ci sont écrits dans des chiers dont l'extension est .m, modiables dans n'importe
quel éditeur de texte. Ces chiers se présentent come une séquence d'instructions, exactement
comme si elles étaient entrées manuellement.

4.1 Fichiers de commande

Dans un chier de commande, ou script, les variables utilisées sont les mêmes que dans l'en-
vironnement Octave. Elles peuvent donc être directement exploitées et modiées par le script.
Il est possible d'inclure des lignes de commentaires (symboles % ou #) de manière à rendre la
compréhension d'un script plus aisée.
%domaine de tracé
x=[-pi:pi/50:pi]

%valeurs de la fonction
y=sin(x)

%tracé de la courbe
plot(x,y)

%aspect à l'écran
grid %affichage de la grille
title('y=sin(x)') %définition du titre
xlabel('x') %titre de l'axe x
ylabel('y') %titre de l'axe y
Si ce script est sauvegardé dans un chier tracesin.m accessible par Octave (dans le répertoire
courant ou dans l'un de ceux dénis par LOADPATH), la commande :
octave>tracesin
sut à en démarrer l'éxécution.

6
4.2 Fonctions

Les chiers fonction donnent à Octave un très grande exibilité d'emploi. Ils permettent à
l'utilisateur de dénir sa propre bibliothèque et de l'utiliser de la même manière que s'il s'agissait
de fonctions prédénies dans Octave.
De nombreuses contributions signicatives ont été eectuées par la communauté d'utilisateurs
d'Octave et sont disponibles depuis le site d'Octave : http://www.gnu.org/software/octave/.
Une fonction traite de variables locales, soit internes, soit passées en argument. L'utilisation de
variables globales (communes à la fonction ainsi qu'à l'environnement Octave) est rendue possible
par la commande global.
A la diérence des langages de programmation traditionnels, une fonction doit être enregistrée
dans un chier du même nom an de pouvoir être 'vue' par Octave.
function y=sincos(x)
y=sin(x).*cos(x);
endfunction
Si cette fonction nommé sincos est enregistrée dans sincos.f, alors la commande :
octave>y=sincos(-pi:pi/20:pi);
permet de l'appliquer à tout élément d'Octave, quelles que soient ses dimensions.
Les fonctions d'Octave peuvent traiter tous les types de données d'Octave, quel que soit leur
nombre. Le passage d'argument se fait de la façon suivante :
function [s1, s2, s3]=mafonction(e1, e2, e3, e4)
...
...
endfunction
L'appel à la fonction se fait alors naturellement :
octave>[x,y,z]=mafonction(a, b, c, d);

Il est également possible de traiter un nombre indéterminé de variables d'entrée et de sortie à

l'aide des variables nargin, nargout, varargin et varargout.

Octave gère de plus les appels récursifs à une même fonction.

4.3 Instructions de contrôle

Octave dispose des instructions de contrôle traditionnelles des langages de programmation

structurée, telles que structures conditionnelles, boucles ou contrôle d'éxécution.

Structures conditionnelles : La structure conditionnelle traditionnelle if/elseif/else/endif

est utilisée par Octave. A l'exception du test d'égalité, ==, et d'inégalité, ~= les opérateurs habi-
tuels sont utilisés : <, <=, >, >=. Les opérateurs logiques 'et' et 'ou' sont représentés par & et |.

Une structure conditionnelle de choix, le bloc switch/case/otherwise/endswitch existe éga-

lement et est d'utilisation plus directe, mais plus restreinte, que if/endif.
switch a
case 1
disp('a=1')
case 2
disp('a=2')
otherwise
disp('recommencer')
endswitch

7
Boucles : Les boucles for/end et while/end sont dénies de manière semblable aux langages
traditionnels. Toutefois, on privilégie logiquement dans Octave une écriture traitant directement
vecteurs et matrices à l'utilisation de boucles, beaucoup plus lentes.
Exemple pour un produit scalaire :
octave> x=[1:100];tic;disp(x*x');toc
338350
ans = 0.00066500
octave> x=[1:100];tic;y=0;for n=1:length(x);y=y+x(n)^2;end;disp(y);toc
338350
ans = 0.0021390
Il existe également un structure de boucle do/until, similaire au while/end, qui peut être utile
dans certains cas.
Il est possible de sortir des boucles en utilisant l'instruction break, ou de passer directement à
l'itération suivante en utilisant continue. Ceci permet généralement de conditionner et d'accélérer
l'éxécution de boucles.

Gestion des exceptions : Les erreurs d'utilisation d'Octave entraînent l'arrêt immédiat du
script ou de la fonction en cours. L'utilisateur peut par ailleurs dénir ses propres cas d'erreur en
utilisant l'instruction error.
Octave prévoit cependant un bloc try/catch/end_try_catch de gestion simple des cas d'excep-
tions qui peut permettre d'éviter les arrêts brutaux :
try
0/[]
catch
disp('Résutat indéterminé!')
end_try_catch
Un gestion plus avancée des cas d'exception est possible à l'aide du bloc :
unwind_protect/unwind_protect_cleanup/end_unwind_protect.

5 Entrées/Sorties
Outre l'achage, l'impression et la sauvegarde de graphiques, Octave permet l'enregistrement
et la relecture de résultats et, plus généralement, la manipulation de chiers.
L'instruction la plus simple est save, qui permet d'enregistrer une ou plusieurs variables dans des
chiers en mode texte ou binaire (format Octave, Matlab ou hdf5). L'instruction load permet de
lire ces chiers et de charger en mémoire les données qu'ils contiennent.
Une gestion plus avancée des chiers s'eectue à partir des instructions fopen, fclose, fwrite,
et fread.