Programmation Octave/Algèbre linéaire
Opération sur les vecteurs.
On peut calculer la norme d'un vecteur grâce à la commande ""norm()" :
 octave> x = [2 3 1 1 1];
 octave> n = norm(x)
 n = 4
La commande "dot(x,y)" calcul le produit scalaire de deux vecteurs :
 octave> y = [-1 1 2]
 y =
 -1 1 2
 octave> x = [1 1 1]
 x =
 1 1 1
 octave>z = dot(x,y)
 z = 2
La commande "cross(x,y)'" calcul le produit vectoriel de vecteur en trois dimensions :
 octave> z = cross(x,y)
 z =
 1 -3 2
Opérations sur les matrices.
Nous avons déjà vu que nous pouvions multiplier des matrices et calculer leurs transposées. Mais Octave permet aussi de les élever à une puissance :
 octave> A = [-1 2;2 0]
 A =
 -1 2
 2 0
 octave>B = A^4
 B =
 29 -18
 -18 20
La commande "rank()" calcul le rang d'une matrice :
 octave> r = rank(A)
 r = 2
La commande "trace" permet d'obtenir la trace d'une matrice :
 octave> t = trace(A)
 t = -1
On peut aussi, grâce à la commande "expm()", calculer l'exponentielle de la matrice :
 octave> E = expm(A)
 E =
 0.36788 7.38906
 7.38906 1.00000
Matrices particulières.
Octave fournit plusieurs fonctions pour créer des matrices particulières.
Matrice nulle.
Pour créer une matrice nulle, il faut se servir de la fonction "zeros" :
 octave> null = zeros(5, 3)
 null =
 0 0 0
 0 0 0
 0 0 0
 0 0 0
 0 0 0
Matrice identité.
La fonction "eye" crée une matrice identité.
 octave:13> I = eye(3)
 I =
 1 0 0
 0 1 0
 0 0 1
Matrice diagonale.
La fonction "diag()" crée des matrices diagonales, sur-diagonales ou sous-diagonales à partir d'un vecteur :
 octave>A = diag([1 2 3],0)
 A =
 1 0 0
 0 2 0
 0 0 3
 octave>A = diag([1 2 3],2)
 A =
 0 0 1 0 0
 0 0 0 2 0
 0 0 0 0 3
 0 0 0 0 0
 0 0 0 0 0
 octave>A= diag([1 2 3],-1)
 A =
 0 0 0 0
 1 0 0 0
 0 2 0 0
 0 0 3 0
Matrice aléatoire.
La fonction "rand()" crée une matrice dont les coefficients sont des nombres choisis aléatoirement entre 0 et 1 :
 octave> rand(2,3)
 ans =
 0.871644 0.651894 0.563654
 0.076660 0.790505 0.275381
Matrice de Hilbert.
La fonction "hilb()" permet de créer une matrice de Hilbert :
 octave> hilb(3)
 ans =
 1.00000 0.50000 0.33333
 0.50000 0.33333 0.25000
 0.33333 0.25000 0.20000
Autre matrices particulières.
Octave propose beaucoup de commandes pour créer des matrices spéciales :
Calcul du déterminant.
Pour calculer un determinant il suffit d'utiliser la commande "det()"" :
 octave> A = [1 -1 3; 4 -3 1; 2 -3 1]
 A =
 1 -1 3
 4 -3 1
 2 -3 1
 octave> d = det(A)
 d = -16
Valeurs propres et vecteurs propres.
Avant d'aborder le calcul de valeurs propres et vecteurs propres, il faut savoir qu'on peut manipuler les vecteurs et les matrices composante par composante :
 octave> A = [2 -1; -1 1]
 A =
 2 -1
 -1 1
 octave> a11 = A(1,1)
 a11 = 2
On peut même utiliser le vecteur d'une matrice grâce au caractère ":" :
 octave:18> a2 = A(:,2)
 a2 =
 -1
 1
Donc la commande "eig" permet de calculer les vecteurs et valeurs propres d'une matrice :
 octave> [vecteursp , valeursp] = eig(A)
 vecteursp =
 -0.52573 -0.85065
 -0.85065 0.52573
 valeursp =
 0.38197 0.00000
 0.00000 2.61803
Les coefficients diagonaux de la matrice "valeursp" sont les valeurs propres.
On peut vérifier que le calcul est juste :
 octave> x=A*vecteursp(:,1)
 x =
 -0.20081
 -0.32492
 octave> y = valeursp(1,1)*vecteursp(:,1)
 y =
 -0.20081
 -0.32492
Décomposition de matrice.
Nous avons déjà vu la décomposition de Cholesky et LU d'une matrice dans le chapitre précédent, mais Octave permet d'effectuer d'autres décomposition. Par exemple on peut utiliser la décomposition QR :
 octave> A = [1 -1 2; 3 -2 1; -3 2 1]
 A =
 1 -1 2
 3 -2 1
 -3 2 1
 octave> [q r] = qr(A)
 q =
 -2.2942e-01 9.7333e-01 7.6411e-17
 -6.8825e-01 -1.6222e-01 7.0711e-01
 6.8825e-01 1.6222e-01 7.0711e-01
 r =
 -4.35890 2.98240 -0.45883
 0.00000 -0.32444 1.94666
 0.00000 0.00000 1.41421
Ensuite on vérifie que formula_1:
 octave:8>B = q*r
 B =
 1.00000 -1.00000 2.00000
 3.00000 -2.00000 1.00000
 -3.00000 2.00000 1.00000
On peut de même effectuer plusieurs autres décompositions grâve aux fonctions :

Programmation Octave/Dessiner des graphiques de fonctions

Graphique en deux dimensions.
Pour dessiner le graphique d'une fonction, il faut d'abord définir l'intervalle où la fonction va prendre ses valeurs. Ici, nous prenons formula_1 et un pas de "0.05" entre chaque valeurs:
 octave> x = [0:0.05:2*pi];
Ensuite, grâce à la fonction ""plot()", nous pouvons dessiner la fonction cosinus:
 octave> plot(x,cos(x))
On peut aussi créer des graphiques de fonction discrète avec la fonction "stem":
 octave> stem(x,cos(x))
Pour dessiner des fonctions il est possible d'utiliser la commande "fplot"". On commence par définir la fonction que l'on veut tracer (ici formula_2):
 octave> function [y] = mafonction(x)
 > y = exp(-cos(x));
 > endfunction
Ensuite on utilise "fplot" en passant en argument le nom de la fonction et l'intervalle sur lequel on veut la tracer :
 octave> fplot("mafonction",[0,10])
Dessiner une courbes en trois dimensions.
Nous allons prendre comme exemple le dessin d'une spirale en trois dimension (un ressort). Il faut d'abord paramétrer la courbe :
 octave> t = 0:0.1:30;
 octave> x = t;
 octave> y = sin(t);
 octave> z = cos(t);
Ensuite grâce à la commande ""plot3()" on dessine la courbe:
 octave> plot3(x,y,z)
On obtient le résultat suivant :
Dessiner une surface.
Nous allons dessiner la surface d'équation formula_3
Dans un premier temps nous définissons la surface de départ avec la fonction "meshgrid()"" ici nous prenons un carré de côté 5 et de 0.1 entre chaque point:
 octave> [x,y] = meshgrid(-5:0.1:5);
Puis nous définissons "z":
 octave> z = sin(2.*(x.^2 + y.^2).^(1/2));
Enfin nous dessinons la surface:
 octave> mesh(z)

Programmation Octave/Introduction
Octave est à la fois un langage interprété et un logiciel de calcul numérique distribué sous licence GPL. Le langage Octave est compatible avec Matlab pour la plupart des usages mathématiques. Ce livre devrait donc convenir comme introduction tant à Octave qu'à Matlab.
L'environnement de travail Octave.
L'interpréteur Octave se lance en ligne de commande en invoquant ""octave" ou en activant le raccourci adéquat, qui est apparu lors de l'installation. Après avoir lancé le programme, celui-ci affiche une session de travail dans la fenêtre de commandes (command window en anglais), dans laquelle l'utilisateur est invité à entrer les commandes interactivement. 
Une autre manière d'entrer des commandes ou des suites de commandes regroupées dans des fichiers script ou des fonctions est abordée dans la section Scripts et fonctions
Pour chaque commande, il est possible d'obtenir de l'aide en tapant "help le_nom_de_la_commande"". La documentation qui apparaît alors est en anglais (en tout cas tant que nous n'aurons pas fait le travail de traduction de la documentation :-). Pour consulter la documentation, il est aussi possible, sous GNU/linux de taper "info:octave" dans la barre de navigation de Konqueror sous KDE.
Nous verrons plus loin comment les utiliser mais, avec Octave, nous pouvons assigner des valeurs à des variable par exemple :
 octave> x = -3
 x = -3
 octave> y = 1
 y = 1
 octave> z = [1 -1]
 z =
 1 -1
Ensuite nous pouvons voir à chaque instant quelles variables sont utilisées avec la commande ""whos":
 octave> whos -variables
 *** local user variables:
 Prot Name Size Bytes Class
 rw- __nargin__ 1x1 8 double
 rwd x 1x1 8 double
 rwd y 1x1 8 double
 rwd z 1x2 16 double
 Total is 5 elements using 40 bytes
La commande "clear" suivie du nom de la variable permet de supprimer la variable ou toutes les variables définies si elle n'est pas suivie d'argument.
La commande "history"" permet de consulter l'historique de toutes les lignes tapées jusqu'à maintenant.

DOS/Rsh
Permet de lancer des commandes distantes sur un serveur Unix
Syntaxe : rsh nom d'hote (-l utilisateur) (-n) commande