Programmation Octave/Version imprimable
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
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 modifier
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 modifier
Résoudre un Système d'équations linéaires
Durant ce chapitre, nous utiliserons comme exemple la résolution du système suivant :
ou, sous forme matricielle:
Définir un vecteur modifier
Nous voulons définir le vecteur :
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 modifier
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 modifier
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 :
octave> b2 = A*x b2 = -1 4 3
Décomposition LU modifier
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 modifier
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
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 modifier
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 modifier
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 modifier
Octave fournit plusieurs fonctions pour créer des matrices particulières.
Matrice nulle modifier
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é modifier
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 modifier
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 modifier
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 modifier
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 modifier
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 modifier
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 modifier
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 modifier
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 :
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),houshkrylov
Analyse réelle
Opérateur de base modifier
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 modifier
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 modifier
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 modifier
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 modifier
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 modifier
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 modifier
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 modifier
Octave permet de manipuler des polynômes facilement. Par exemple le vecteur :
octave> p = [-1 2 0 4];
Représente le polynôme . 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 modifier
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:
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 modifier
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 et un pas de 0.05 entre chaque valeurs:
![{\displaystyle [0;2\pi ]\;}](https://wikimedia.org/api/rest_v1/media/math/render/svg/010c090b537e1e8050a59499f16aff4474f9e3e7)
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 ):
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 modifier
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 modifier
Nous allons dessiner la surface d'équation
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)
Analyse Complexe
Définir des nombres complexes modifier
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 modifier
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 modifier
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 modifier
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 :
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 modifier
Comme la plupart des langages de programmation le langage Octave est composé de plusieurs types de boucles.
While modifier
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 modifier
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.
Calcul numérique
Résoudre des équations non-linéaires modifier
La commande "fsolve("f",x0)" permet de donner une approximation de la solution à l'équation en partant du nombre initiale "x0". Par exemple si on veut résoudre:
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 :
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 modifier
La commande "lsode" permet de résoudre des équations du type:
Ou f est inconnue.
Minimiser une fonction modifier
fmins permet de minimiser une fonction de plusieurs variables. Par exemple si on veut minimiser
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 modifier
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 modifier
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 modifier
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 octave
Installation de Octave-Forge sur GNU/Linux modifier
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) modifier
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 modifier
À la ligne de commande, on peut taper :
yum install octave
Gentoo modifier
À la ligne de commande, on peut taper :
emerge sync emerge octave
Installation de Octave-Forge sur OS X modifier
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 modifier
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 modifier
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 modifier
- 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 modifier
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 modifier
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 modifier
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 :
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 modifier
- Nicolas Pettiaux (surtout les adaptations pour Wikibooks et mise en forme), basé sur page web Jean-Daniel Bonjour
Références modifier
Éditeur scite
Présentation modifier
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 modifier
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 modifier
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 modifier
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 modifier
- 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. |