Programmation Octave/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:
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:
Fonctions spéciales.
On peut aussi très simplement calculer des fonctions spéciales:
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 formula_1.
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:
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"

Livre de cuisine/Salade niçoise
Ingrédients.
Pour 6 personnes :

Livre de cuisine/Salade russe au poulet
Préparation.
... Bon appétit !

Livre de cuisine/Tomates farcies au thon

Ingrédients.
Pour 4 personnes :

Livre de cuisine/Velouté de champignons aux lardons

Le velouté de champignons aux lardons est une soupe.

Soupe méditerranéenne de tomates
Verbes irréguliers en anglais
Enseignement de l'anglais/Idiomes
Les idiotismes ou idiomes (en anglais "idioms") sont des locutions ou des constructions particulières à une langue intraduisible mot à mot.
Voir aussi.
Retour à Enseignement de l'anglais

Programmation Octave/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 : 
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é codice_1. Les commentaires dans le script sont précédés d'un #.
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.