Programmation Octave/Version imprimable

Programmation Octave

Une version à jour et éditable de ce livre est disponible sur Wikilivres,
une bibliothèque de livres pédagogiques, à l'URL :
https://fr.wikibooks.org/wiki/Programmation_Octave

Vous avez la permission de copier, distribuer et/ou modifier ce document selon les termes de la Licence de documentation libre GNU, version 1.2 ou plus récente publiée par la Free Software Foundation ; sans sections inaltérables, sans texte de première page de couverture et sans Texte de dernière page de couverture. Une copie de cette licence est incluse dans l'annexe nommée « Licence de documentation libre GNU ».

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.

Liens

• Site officiel.

Résoudre un Système d'équations linéaires

Durant ce chapitre, nous utiliserons comme exemple la résolution du système suivant :

$\left\{{\begin{matrix}2x_{1}+3x_{2}-x_{3}=-1\\x_{1}-x_{2}+3x_{3}=4\\2x_{1}-3x_{2}+x_{3}=3\end{matrix}}\right.$

ou, sous forme matricielle:

$A\cdot x=b\;$

Définir un vecteur

Nous voulons définir le vecteur : $b={\begin{pmatrix}-1\\4\\3\end{pmatrix}}$

Pour cela il faut entrer:

octave> b = [-1 ; 4 ; 3]
b =

  -1
   4
   3

ou

octave> b = [-1 4 3]'
b =

  -1
   4
   3

L'opérateur " ' " transpose un vecteur ou une matrice, on crée un vecteur ligne et on le transpose. Il faut noter qu'on peut aussi définir un vecteur par une suite :

octave:> x = 1:4
x =

 1  2  3  4

octave> y = 10:-2:4
y =

 10   8   6   4

Et, si on ajoute ";" à la fin de la ligne, Octave n'affiche pas le résultat.

Définir une matrice

Pour définir une matrice, on procède comme pour le vecteur :

octave> A = [2 3 -1; 1 -1  3; 2 -3 1]
A =
  
  2   3  -1
  1  -1   3
  2  -3   1

On peut aussi modifier une matrice ou un vecteur composante par composante :

octave> A(2,2) = -10
A =
 
   2    3   -1
   1  -10    3
   2   -1    3

Résoudre le système

L'opérateur habituel pour résoudre un système linéaire est "\" :

octave> x = A\b
x =
 
  0.5000
 -0.3125
  1.0625

On peut verifier que $A\cdot x=b$ :

octave> b2 = A*x
b2 =

 -1
  4
  3

Décomposition LU

Avant de résoudre le système, on peut décomposer la matrice avec la décomposition LU :

octave> [L,U]= lu(A)
L =
 
 1.00000  0.00000  0.00000
 0.50000  0.62500  1.00000
 1.00000  1.00000  0.00000
 
U =
 
  2   3  -1
  0  -4   4
  0   0   1

puis :

octave> y = L\b
y =
 
 -1
  4
  2
 
octave> x = U\y
x =
 
 -1
  1
  2

Décomposition de Cholesky

Nous pouvons aussi résoudre des systèmes linéaire avec la décomposition de Cholesky obtenue par la fonction "chol(A)" si la matrice du système est symétrique définie positive :

octave> A = [2 -1 0 0;-1 2 -1 0;0 -1 2 -1;0 0 -1 2]
A =

  2  -1   0   0
 -1   2  -1   0
  0  -1   2  -1
  0   0  -1   2

octave> R = chol(A)
R =

  1.41421  -0.70711   0.00000   0.00000
  0.00000   1.22474  -0.81650   0.00000
  0.00000   0.00000   1.15470  -0.86603
  0.00000   0.00000   0.00000   1.11803
Upper Triangular

On peut vérifier que $A=R^{T}R\;$

octave> B = R'*R
B =

  2.00000  -1.00000   0.00000   0.00000
 -1.00000   2.00000  -1.00000   0.00000
  0.00000  -1.00000   2.00000  -1.00000
  0.00000   0.00000  -1.00000   2.00000

Puis on résout le système :

octave>b = [1 -1 1 -1]'
octave> y = R'\b;
octave> x = R\y
x =

  0.40000
 -0.20000
  0.20000
 -0.40000

Enfin on vérifie le calcul :

octave> z = A*x
z =

  1.0000
 -1.0000
  1.0000
 -1.0000

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 :

• hankel (Matrice de Hankel).
• invhilb (Inverse de la Matrice de Hilbert),
• sylvester_matrix (Matrice de Sylvester),
• toeplitz (Matrice de Toeplitz),
• vander (Matrice de Vandermonde).

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 $A=QR\,$:

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 :

• qz (decomposition QZ),
• qzhess (decomposition de Hessenberg),
• schur (decomposition de Schur),
• svd (décomposition de la valeur singulière),
• housh
• krylov

Analyse réelle

Opérateur de base

Octave possède tous les opérateurs de base : "+, -, *, /" cependant si on veut effectuer des calculs composantes par composantes et non matriciels il faut ajouter un point devant l'opérateur par exemple :

octave> x = 3*ones(2,2)
x =

 3  3
 3  3

octave>y = x*x
y =

 18  18
 18  18

octave:14>z = x.*x
z =

 9  9
 9  9

Fonction de base

La fonction "ceil" permet d'obtenir le plus petit entier supérieur au nombre passé en argument:

octave:> x = ceil(1.001)
x =  2

La fonction "round" permet d'obtenir l'entier le plus proche du nombre passé en argument:

octave> x = round(3.501)
x =  4

Trigonométrie

Octave propose plusieurs fonctions trigonométriques:

• Sinus : "sin(x)"
• Cosinus : "cos(x)"
• Tangente : "tan(x)"
• Sécante : "sec(x)"
• Arcsinus : "asin(x)"
• Arccosinus : "acos(x)"
• Arctangent : "atan(x)"
• Cosecante : "csc(x)"

Fonction exponentielle, logarithme et puissance

On peut aussi calculer l'exponentielle d'un nombre avec la commande "exp()" ou en elevant à la puissance la constante "e", D'une façon générale on peut élever un nombre à une puissance avec l'opérateur "^":

octave> x = 2
x = 2
octave> y = 2^10
y = 1024
octave>x = exp(2)
x =  7.3891
octave>y = e^2
y =  7.3891

Il y a aussi la commande "log()" pour calculer le logarithme ainsi que "log2()" et "log10()" pour le logarithme en base 2 et 10:

octave:18>z = log2(y)
z = 10

Fonctions hyperboliques

Voici les fonctions hyperboliques implémentées par Octave:

• Sinus hyperbolique : "sinh(x)"
• Cosinus hyperbolique : "cosh(x)"
• Tangente hyperbolique : "tanh(x)"
• Secante hyperbolique : "sech(x)"
• Cotangente hyperbolique : "coth(x)"
• Argument sinus hyperbolique : "asinh(x)"
• Argument cosinus hyperbolique : "acosh(x)"
• Argument tangente hyperbolique : "atanh(x)"

Fonctions spéciales

On peut aussi très simplement calculer des fonctions spéciales:

• Factorielle : "factorial(x)"
• Fonction Gamma : "gamma(x)"
• Fonction d'erreur : "erf(x)"
• Fonction Beta : "beta(x,y)"

Somme et Produit

Les commandes "sum()" et "prod()" permettent de calculer la somme ou le produit des composantes d'un vecteur ligne:

octave> x = 1:5
x =

 1  2  3  4  5

octave> s = sum(x)
s =  15
octave> p = prod(x)
p =  120

Polynôme

Octave permet de manipuler des polynômes facilement. Par exemple le vecteur :

octave> p = [-1 2 0 4];

Représente le polynôme $-x^{3}+2x^{2}+4$. Par afficher le polynôme de façon naturelle il faut utiliser la fonction "polyout" :

octave> polyout(p,'x')
-1*x^3 + 2*x^2 + 0*x^1 + 4

On peut aussi deriver ou integrer un polynôme avec les fonctions "polyint" et "polyder" :

octave> polyder(p)
ans =

 -3   4   0
octave> polyint(p)
ans =

 -0.25000   0.66667   0.00000   4.00000   0.00000

Et enfin pour evaluer un polynôme en un point on utilise polyval :

octave> polyval(p,1)
ans =  5

Définir des fonctions

Pour définir ses propres fonctions il faut utiliser une commande un peu différente de ce que nous avons déjà vu. Supposons que nous voulions utiliser la fonction:

$f(x)=\ln(1+x^{2})-{\sqrt {\cosh(x)}}$

Il faut procéder comme cela :

octave> function [y] = f(x)
> y = log(1+x.^2)-sqrt(cosh(x))
> endfunction

Ensuite nous pouvons tester notre fonction:

octave> y = f(0)
y = -1
y = -1
octave> y = f(10)
y = -100.33
y = -100.33

Une telle définition de fonction peut aussi être entrée dans un fichier spécifique qui contient exactement les mêmes caractères et qui porte comme nom, le nom de la fonction, sous la forme (ici) f.m

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 $[0;2\pi ]\;$ 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 $f(x)=e^{-\cos(x)}\,$):

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 :

Exemple de tracé en 3D avec Octave

Dessiner une surface

Nous allons dessiner la surface d'équation $z=\sin(2.{\sqrt {x^{2}+y^{2}}})$

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)

Voici la surface obtenue

Analyse Complexe

Définir des nombres complexes

Octave permet de définir des nombres complexes de façon très simple car "i" est une constante prédéfinie d'Octave:

octave> z = 1 + i
z = 1 + 1i

Ou des vecteurs complexes :

octave> z = [1; 3; 1] + i*[2; -2; -1]
z =

 1 + 2i
 3 - 2i
 1 - 1i

La lettre "j" peut aussi être utilisée au lieu de "i".

Fonctions de base

La commande "real()" donne la partie réelle d'un nombre complexe, la commande "imag()" en donne la partie imaginaire:

octave> z = 3 + 4i
z = 3 + 4i
octave> R = real(z)
R = 3
octave> I = imag(z)
I = 4

La commande "conj()" calcul le conjugué d'un nombre complexe:

octave> z2 = conj(z)
z2 = 3 - 4i

La commande "abs()" permet de calculer le module d'un nombre complexe:

octave> r = abs(z)
r = 5

La commande "arg()" calcul permet de calculer l'argument du nombre :

octave> a = arg(z)
a = 0.92730

Scripts et fonctions

Octave permet de créer des fichier ".m" qui peuvent s'exécuter comme des fonctions par la suite. Il suffit pour cela d'entrer des lignes de commande dans un éditeur de texte puis l'enregistrer avec l'extension ".m".

Un exemple de programme récursif

Par exemple nous créons le fichier "factorielle.m" qui contient :

function[n] = factorielle(x)
if(x <= 1)
   n = 1;
else
   n = x*factorielle(x-1);
   x = x-1;
endif
endfunction

Ensuite nous nous plaçons dans le répertoire où nous avons créé le fichier avec la commande "cd" car Octave connaît les commandes "cd" et "ls" (elles ont le même effet que si on les exécute dans un terminal). Et enfin on exécute le script en invoquant le nom de la fonction (qui est aussi le nom du fichier) :

octave>f = factorielle(2)
f = 2
octave> f = factorielle(10)
f = 3628800

Comme le script le laissait voir cette fonction calcule bien la factorielle du nombre.

Script pour résoudre un système d'équations non-linéaires

Voici un deuxième exemple de script sous Octave, il permet de résoudre un petit système d'équations non-linéaires à 2 variables x et y :

${\begin{cases}{\frac {\partial x}{\partial t}}=rx(1-x/k)-axy/(1+bx)\\{\frac {\partial y}{\partial t}}=caxy/(1+bx)-dy\end{cases}}$

$x(t=0)=1\ et\ y(t=0)=2$

Il affiche aussi les courbes d'évolution des deux variables. À noter que d'une manière générale, un fichier de script d'Octave ne doit pas commencer par le mot-clé function. Les commentaires dans le script sont précédés d'un #.

printf("Résolution d'un système d'équations et affichage.\n");		
function xdot = f (x, t)
# Paramètres des équations :
r = 0.25;
k = 1.4;
a = 1.5;
b = 0.16;
c = 0.9;
d = 0.8;
# Définition du système à 2 équations :
xdot(1) = r*x(1)*(1 - x(1)/k) - a*x(1)*x(2)/(1 + b*x(1));
xdot(2) = c*a*x(1)*x(2)/(1 + b*x(1)) - d*x(2);
endfunction
# Conditions initiales des deux variables :
x0 = [1; 2];
# Définition du vecteur temps :
t = linspace (0, 50, 200);
# Résolution avec la routine lsode :
x = lsode ("f", x0, t);
# Affichage des deux courbes :
plot (t, x);

On l'appelle par exemple 'nonlin.m' et l'on exécute en tapant nonlin dans la ligne de commande Octave.

Boucles

Comme la plupart des langages de programmation le langage Octave est composé de plusieurs types de boucles.

While

La boucle while permet d'exécuter les instructions tant que la condition spécifiée est vraie. Par exemple :

 fib = ones (1, 10);
 i = 3;
 while (i <= 10)
    fib (i) = fib (i-1) + fib (i-2);
    i++;
 endwhile

donne les dix premiers nombres de Fibbonacci :

 octave>
 fib =
 
   1    1    2    3    5    8   13   21   34   55

For

La boucle for permet d’exécuter une instruction ou une suite d'instructions à partir d'une valeur initiale jusqu’à une valeur finale:

fib = ones (1, 10);
 for i = 3:10
    fib (i) = fib (i-1) + fib (i-2);
endfor

Le script précédent donne le même résultat que l'exemple de la section précédente.

Résoudre des équations non-linéaires

La commande "fsolve("f",x0)" permet de donner une approximation de la solution à l'équation $f(x)=0$ en partant du nombre initiale "x0". Par exemple si on veut résoudre:

$x^{3}-x^{2}+5x-8=0\,$

Il faut d'abord définir la fonction:

octave> function [y] = f(x)
> y = x.^3 - x.^2 + 5.*x -8
> endfunction

Ensuite on dessine le graphique de la fonction pour voir approximativement ou se situe le zéro de la fonction:

octave> x = -5:0.1:5;
octave> plot(x,f(x));

On voit que le zéro se trouve entre 0 et 2 donc on peut choisir $x_{0}=1.5$:

octave> z = fsolve("f",1.5)
y =  0.62500
y =  0.62500
y =  0.017493
y =  5.0709e-04
y =  4.2678e-07
y =  1.0425e-11
y = 0
z =  1.4265

Ensuite on vérifie la solution:

octave> y = f(z)
y = 0
y = 0

Résoudre des équations différentielles du premier ordre

La commande "lsode" permet de résoudre des équations du type:

$f'(t)=g(f(t),t)\,$

Ou f est inconnue.

Minimiser une fonction

fmins permet de minimiser une fonction de plusieurs variables. Par exemple si on veut minimiser

$f(x_{1},x_{2})=(x_{2}-1)^{2}+(x_{1}-3)^{2}\,$

avec le vecteur initial (1,0). il suffit de faire :

octave> F = @(x) (x(2)-1)^2 + (x(1)-3)^2;
octave> fmins(F,[1 0])
ans =

  3   1

Traitement du son

Jouer un son

Octave permet de jouer un son grâce à la commande sound . Cette commande se trouve dans le package audio. sound prend en argument un vecteur représentant l'échantillon à jouer et éventuellement la fréquence d'échantillonnage:

octave> n = 1:10000;
octave> s = 10*sin(2.*pi.*n./500);
octave> sound(s);
Input Filename : -
Sample Size    : 16-bits
Sample Encoding: signed (2's complement)
Channels       : 1
Sample Rate    : 8000

Time: 00:01.25 [4473:54.21] of 4473:55.46 (  0.0%) Output Buffer:  59.80K

Done.

Lire et écrire des WAV

Octave permet de lire et d'écrire des fichier son en .wav les fonctions sont wavread et wavwrite . Par exemple si on veut écrire le signal s  :

octave> wavwrite("test.wav",s);

Et si maintenant on veut lire le signal :

octave> x = wavread("test.wav");

Transformées d'un signal

La commande fft calcule la transformée de Fourier d'un signal :

octave> x = [1 2 1];
octave> X = fft(x)
X =

  4.00000 + 0.00000i  -0.50000 - 0.86603i  -0.50000 + 0.86603i

Et la commande ifft retourne la transformée inverse :

octave> ifft(X)
ans =

   1   2   1

Les commandes dct et idct calculent la transformée en cosinus discrète ainsi que sa transformée inverse :

octave> X = dct(x)
X =

   2.30940   0.00000  -0.81650

octave> idct(X)
ans =

   1.0000   2.0000   1.0000

Installation de Octave-Forge sur GNU/Linux

Sur GNU/Linux, octave et ses composants sont en général disponible par défaut. L'installation est donc très simple en utilisant les outils de gestion des paquets logiciels.

Debian et ses dérivés (dont Ubuntu)

On peut utiliser le logiciel graphique synaptics et installer les paquets octave et ceux liés comme octave-forge .

Il est aussi possible de procéder de manière semblable en ligne de commande en tapant :

sudo apt-get install octave

Si aptitude est installé, on peut bien entendu également l'utiliser :

sudo aptitude install octave

Fedora

À la ligne de commande, on peut taper :

yum install octave

Gentoo

À la ligne de commande, on peut taper :

emerge sync
emerge octave

Installation de Octave-Forge sur OS X

Sur OS X (de Apple), il est assez facile d'installer une copie disponible sur Internet (FIXME)

Installation de Octave-Forge sur Microsoft Windows XP/Vista/7/8

La procédure pour Windows en particulier était un peu moins simple, sans être complexe cependant, et a été grandement simplifiée ces derniers mois grâce au travail de nombreux membres de la communauté octave. Un manipulation utilisant des outils et compilations récents au moment de l'écriture de cette page est indiquée ici. Pour des précisions ou de l'actualité, merci de consulter OctaveForWindows sur le wiki officiel d'Octave.

Il faut installer octave-forge et ceci fait, utiliser l'éditeur scite inclus. Celui-ci peut être francisé (pour ce qui concerne l'interface). Comme elle concerne potentiellement beaucoup d'utilisateurs, c'est celle-ci qui sera d'abord décrite ici.

La distribution Octave pour Windows de Michael Goffioul décrite ci-dessous est la plus aboutie actuellement et celle qui offre le plus haut degré de compatibilité avec MATLAB . Elle contient Octave-Forge dénommée ainsi car intégrant les extensions à Octave développée sur la célèbre plateforme open-source Web SourceForge).

Procédure d'installation

Cette version d'Octave-Forge intègre les composants suivants :

• GNU Octave, version 3.0.3 (i686-pc-msdosmsvc) et des versions plus récentes
• extensions octave-forge 2008.04.28
• preversion de OctaveDE, un outil graphique en développement pour octave (alpha release encore en test)
• Gnuplot 4.2.2 spécialement préparée pour cette version de octave pour Windows
• Jhandles permettant des graphiques avec une interface très puissante, plus compatible avec matlab, utilisant Java et OpenGL based
• Msys 1.0.10
• NSIS Installation
• l'éditeur SciTE 1.68, multilingue et permettant la mise en évidence colorée du code,
• la documentation en format PDF et HTML

Cette version est maintenue par Michael Goffioul et la dernière version (au moment de la rédaction) date du 2008-05-05

Elle est téléchargeable sur http://sourceforge.net/project/showfiles.php?group_id=2888&package_id=40078

Détails d'installation

• Télécharger le kit d'installation octave-3.0.3-setup.exe ou une version plus récente depuis le site SourceForge

• puis exécuter octave-3.0.3-setup.exe
• choisir le moteur graphique jhandle par défaut.
• si des paquets complémentaires de octave-forge doivent être installés, les sélectionner
• déroulement de l'installation... en poussant plusieurs fois sur les boutons next

Raccourci de lancement

Octave et Octave UI (pour l'interface graphique OctaveDE) en développement se trouvant dans le menu Démarrer > Programmes > Octave

Interface de développement

Une interface de développement (IDE) semblable à Matlab est qtoctave téléchargeable à https://forja.rediris.es/frs/download.php/601/qtoctave0.7.2_octave3.0.0_Portable_win32.zip

Usage de Octave-Forge et degré de compatibilité par rapport à MATLAB

Depuis le menu Démarrer > Programme > Octave... vous accédez à la documentation Octave sous forme HTML et PDF.

Dans l'un des répertoires pointé par la variable PATH Octave, vous pouvez définir un fichier .octaverc comme prologue de démarrage Octave. En quittant, Octave déposera, dans le dossier HOME Octave, son fichier historique .octave_hist

Pour des précisions sur la compatibilité Octave-Forge par rapport à MATLAB, on consultera notamment les pages suivantes :

• Octave Compatibility FAQ
• Matlab Octave Compatibility
• Matlab/Octave compatibility packages

Pour une compatibilité maximum avec MATLAB, Octave devrait être démarré avec octave --traditional (à définir donc dans le script octave.sh). Cela positionne de la façon suivante un certain nombre de variables "builtins"/intégrées

 PS1                      = '>> '
 PS2                      = '  '
 beep_on_error            = 1
 crash_dumps_octave_core  = 0
 default_save_format      = 'mat-binary'
 fixed_point_format       = 1
 page_screen_output       = 0
 print_empty_dimensions   = 0
 warn_function_name_clash = 0

Auteurs

• Nicolas Pettiaux (surtout les adaptations pour Wikibooks et mise en forme), basé sur page web Jean-Daniel Bonjour

Références

• Installation de Octave-Forge

Éditeur scite

Présentation

SciTE est un éditeur de textes très bien adapté à la programmation, libre et fonctionnant sur Microsoft Windows et GNU/linux.

Dans le monde des éditeurs de texte, le choix est plutôt difficile. Les utilisateurs de Microsoft Windows en savent quelque chose, le Bloc-notes étant limité et WordPad peu adapté à l'écriture de programmes.

SciTE, éditeur de texte libre, fonctionnant sous Windows et Linux entre autres, est léger, performant et offre plusieurs éléments de confort comme la coloration syntaxique. Il reconnaît aussi bien le HTML et le CSS, que le PHP, le Perl, le C ou encore le C++.

SciTE signifie Scintilla Text Editor. Scintilla est un composant d'édition de code source aux fonctionnalités puissantes, utilisé dans des projets comme Anjuta ou Notepad2. Que permet-il de faire au juste ?

SciTE permet d'éditer n'importe quel fichier texte (code source, fichier de configuration ou simple fichier texte), dans n'importe quel encodage (y compris l'UTF-8). Il offre de nombreuses fonctionnalités en terme d'édition pure (recherche et remplace à base de regexp, sélection en colonnes, ...) et se débrouille à merveille comme éditeur de code (coloration syntaxique, intégration des API des langages permettant l'autocomplétion des fonctions, possibilité de « replier » du code, de compiler et d'exécuter directement depuis l'éditeur, ...). En plus, il dispose d'onglets (tabs) et connaît autant de langages qu'on veut bien lui en définir. Si ce couteau suisse pour programmeur vous tente, passons à l'installation...

Installation

Les utilisateurs de Linux devraient trouver SciTE packagé dans leur distribution. Les utilisateurs de Windows pourront trouver sur la page de download plusieurs versions :

• Les Windows Executable ne demandent pas d'installation, mais n'offrent pas toutes les fonctionnalités. À utiliser lorsqu'on n'est pas sur son ordinateur (surtout le single file executable vraiment pratique).

• Les Windows Installers s'intègrent parfaitement à Windows (vous pourrez donc faire clic droit sur un fichier, puis « Éditer dans SciTE »). Je vous conseille l'installeur de Bruce Dodson, léger et très complet.

Utilisation

SciTE fonctionne comme n'importe quel éditeur de texte (ou presque). Il peut ouvrir plusieurs fichiers simultanément grâce à la gestion des onglets (tabs).

Les raccourcis claviers standards

Ce sont pratiquement tous les mêmes que dans la plupart des autres logiciels, aussi bien sous Windows que sous Linux.

Combo	Action
Ctrl + O	Ouvre un fichier.
Ctrl + W	Ferme le fichier en cours.
Ctrl + N	Nouveau fichier (nouvel onglet).
Ctrl + S	Enregistrer le fichier.
Ctrl + Shift + S	Enregistrer le fichier sous un autre nom.
Ctrl + Tab	Passer à l'onglet de droite.
Ctrl + Shift + Tab	Passer à l'onglet à gauche.
Ctrl + F	Rechercher (find).
F3	Trouver le résultat suivant (après avoir commencé une recherche).
Shift + F3	Trouver le résultat précédent (après avoir commencé une recherche).
Ctrl + H	Rechercher & Remplacer.
Ctrl + G	Aller à la ligne... (goto)
Ctrl + C	Copier.
Ctrl + X	Couper.
Ctrl + V	Coller.
Ctrl + Z	Annuler.
Ctrl + Y	Refaire (après une annulation ratée).
Ctrl + A	Sélectionner tout le contenu du fichier.
Ctrl + P	Imprimer.
Ctrl + R	Commenter un bloc (##)

Références

• L'essentiel de cette section provient de "scite l'éditeur indispensable" que l'auteur a permis de reprendre et adapter.

Octave Forge

Si la version de base d' Octave ne contient pas toutes les fonctions qu'il vous sont nécessaire, il existe Octave Forge qui vous permet de télécharger des fonctions supplémentaires en addition d'Octave. Les fonctions sont classées en différents packages, il suffit de télécharger le package qu'il vous faut, par exemple Audio, ensuite vous lancez Octave dans le dossier qui contient le fichier tar.gz. La commande Octave pkg permet de géré les différent packages. Par exemple la commande 'pkg install audio-1.0.2.tar.gz' installera le package Audio si il se trouve dans le dossier ou est lancé Octave. Voici une liste des principales option de la commande pkg:

• list, liste les packages installés.
• install, installe le package
• uninstall, désinstalle le package.
• load, charge le package, permet à Octave de l'utiliser.

GFDL

Vous avez la permission de copier, distribuer et/ou modifier ce document selon les termes de la licence de documentation libre GNU, version 1.2 ou plus récente publiée par la Free Software Foundation ; sans sections inaltérables, sans texte de première page de couverture et sans texte de dernière page de couverture.