ajout tp scilab

num/tp1/README.md

@@ -0,0 +1,202 @@
+# TP1 Calcul approché, résolution d'équation $f(x)=0$
+On s'interesse à la résolution numérique d'une équation $f(x)=0$, où de manière équivalente à
+$g(x)=x$ avec $g(x)=f(x)+x$.
+
+> Lisez d'abord l'aide sur [scilab](../../scilab).
+
+> Si vous avez des problèmes d'affichages, lancez scilab depuis la console avec 
+> ```
+> LIBGL_ALWAYS_SOFTWARE=1 /usr/bin/scilab
+> ```
+## Exécuter sous Scilab.
+
+Les commandes Scilab peuvent être tapées directement en ligne. Par exemple,
+```
+--> x = 1
+--> A = ones(3,2);
+--> x + A
+```
+
+Le caractère `;` à la fin de la ligne indique si scilab affiche le résultat de la commande. Les commandes peuvent 
+écrites dans un fichier `*.sce`.
+
+1. Enregistrez les instructions suivantes dans un fichier `test.sce`.
+```
+clc;clear;
+A = rand(3,4)
+```
+
+Exécutez "le fichier" avec `exec("test.sce")`.
+
+2. On peut définir des fonctions, et les placer dans un fichier :
+```
+// (commentaires en Scilab) Fonction carre.sci
+function [res] = carre(x)
+	res = x.*x
+endfunction
+```
+3. Faites `exec("carre.sci")`.
+   La fonction carre est maintenant définie sous Scilab
+```
+--> x = carre ([0,1,2,3,4])
+--> y = carre(x)
+--> plot2d(x,y)
+```
+
+ 
+## Calcul approché
+Récupérez le fichier [myF.sci](src/myF.sci) qui définit la fonction suivante :
+```
+function [ y ] = myF( x )
+	y = x;
+	for i=1:50
+	  y = sqrt(y);
+	end
+	for i=1:50
+	  y = y.*y;
+	end
+endfunction
+```
+
+1. Charger `myF` dans scilab, et calculer la fonction pour quelques valeurs.
+2. Que vaut en théorie la fonction `myF` ? Tracez-là sur `[0,100]`. 
+3. Tracez l'erreur en valeur absolue entre la fonction, et sa valeur théorique.
+
+## Méthode du point fixe
+On cherche à résoudre l'équation
+\[
+	x - \cos x = 0, \,\, x\in [0,1]
+\]
+
+Sous certaines hypothèses (cf TD), la suite définie par 
+\[
+	\left\{\begin{array}{l}
+x_0\in I \\
+x_{n+1} = g(x_n)
+\end{array}\right.
+\]
+converge vers un point fixe de $g$. Ici, $g(x) = \cos x\,\, , \,x\in [0,1]$.
+
+1. Récupérez le fichier [pointFixe.sci](src/pointFixe.sci)  définissant la fonction 
+  ```
+  function [ y ] = pointFixe(x0,n)
+	y = x0;
+	for i = 1:n
+	  y = ...
+	end
+  endfunction
+  ```
+
+  Cette fonction prend en entrée `x0` une valeur initiale de la suite et `n` le nombre d'itérations.
+  La fonction doit retourner `y` valant $x_n$.  
+  
+  Complétez le fichier, chargez la fonction, et vérifiez pour différentes valeurs 
+  initiales de $[0,1]$ que la suite converge vers le même $l = \cos l$. Que vaut $l$ ? Normalement, 
+  $l \approx 0.739085133215161$.
+
+2. Récupérez le fichier [pointFixeErreur.sci](src/pointFixeErreur.sci)  définissant la fonction
+```
+function [ err ] = pointFixeErreur(x0)
+	for i=1:50
+	  y = pointFixe(x0,i)
+	  err(i) = ...
+	end
+endfunction
+```
+Cette fonction prend en entrée `x0` une valeur initiale de la suite. Complétez la fonction pour que `err(i)` vale
+$|e_i|$ l'erreur commise à l'étape $i$, en valeur absolue.
+
+3. Tracez l'évolution de l'erreur :
+```
+erreur = pointFixeErreur(0.1)
+plot2d(erreur)
+```
+
+3. Récupérez le fichier [pointFixeVitesseConvergence.sci](src/pointFixeVitesseConvergence.sci) qui définit la fonction
+```
+function [ ratio ] = pointFixeVitesseConvergence(x0)
+	err = pointFixeErreur(x0);
+	for i = 1:49
+	 ratio(i) = ...
+	end
+endfunction
+```
+
+Cette fonction prend en entrée `x0` une valeur initiale de la suite. Complétez le fichier pour que `ratio(i)` vale
+$\frac{|e_{i+1}|}{|e_i|}$.
+
+
+Chargez la fonction, et tracez le résultat. Vérifie-t'on que la méthode est d'ordre 1 ?
+
+
+## Dichotomie
+### Principe de la méthode
+On se donne une fonction continue $f$ sur l'intervalle $[a,b]$ sur lequel $f$
+ne s'annule qu'une fois en changeant de signe.
+
+Pour trouver la solution, on divise l'intervalle $[a,b]$ en deux avec son milieu
+\[
+	m=\frac{a+b}{2}
+\]
+
+Si $f(a)$ et $f(m)$ sont de même signe, la solution cherchée se trouve dans $[m,b]$, sinon 
+elle se trouve dans $[a,m]$.
+
+On itére alors la recherche dans le nouvel intervalle jusqu'à ce que sa longueur soit inférieur à une précision $\epsilon$ voulue.
+
+<div align="center">
+<img src="./img/Dichotomie.png">
+</div>
+
+1. Écrire une fonction  
+   ```
+    function [x]=dichotomie(f,a,b,eps)
+    // f <-> fonction
+    // a,b <-> [a,b] intervalle de départ
+    // eps <-> valeur pour le test d'arret
+	// x <-> valeur approché de f(x)=0
+   ```
+2. Tester avec 
+   - la fonction de l'exercice précédent,
+   - $f(x)=x^2-2$ sur l'intervalle $[1,2]$. Comparer numériquement la solution approchée avec 
+     la solution exacte, en faisant varier $\epsilon$.
+   - $g(x)=cos(x)-x^2$ sur l'intervalle $[0,1]$
+3. Modifier la fonction pour qu'elle renvoié le nombre d'itérations nécessaires. Tester avec
+\[
+  x-\sin x - \frac{1}{4} = 0, \;\;x\in[\frac{1}{4},\frac{5}{4}]
+\]
+
+Aide Scilab
+[function](https://help.scilab.org/docs/6.1.1/fr_FR/functions.html)
+[if](https://help.scilab.org/docs/6.1.1/fr_FR/if.html)
+[while](https://help.scilab.org/docs/6.1.1/fr_FR/while.html)
+[for](https://help.scilab.org/docs/6.1.1/fr_FR/for.html)
+
+
+## Méthode de la fausse position
+### Principe de la méthode
+On prend les même hypothèses que pour la dichotomie. La méthode consiste alors à diminuer l'intervalle
+de recherche en considérant le point \$c\$ intersection de la corde aux extrémités de l'intervalle avec 
+l'axe des abscisses.
+
+<div align="center">
+<img src="./img/Regula_falsi_method.png">
+</div>
+
+1. Calculer $c$ en fonction de $f(a),f(b),a,b$
+2. Écrire une fonction 
+   ```
+   --> function [x,n]=fausse_position(f,a,b,eps)
+   // f <-> fonction
+   // a,b <-> [a,b] intervalle de départ
+    // eps <-> valeur pour le test d'arret
+	// x <-> valeur approché de f(x)=0
+	// n <-> nombre d'itérations
+   ```
+3. Tester avec 
+\[
+  x-\sin x - \frac{1}{4} = 0, \;\;x\in[\frac{1}{4},\frac{5}{4}]
+ \]
+
+
+

num/tp1/src/myF.sci

@@ -0,0 +1,9 @@
+function [ y ] = myF( x )
+	y = x;
+	for i=1:50
+	  y = sqrt(y);
+	end
+	for i=1:50
+	  y = y.*y;
+	end
+endfunction

num/tp1/src/pointFixe.sci

@@ -0,0 +1,6 @@
+function [ y ] = pointFuxe(x0,n)
+	y = x0;
+	for i = 1:n
+		y = // A completer 
+	end
+endfunction

num/tp1/src/pointFixeErreur.sci

@@ -0,0 +1,6 @@
+function [ err ] = pointFixeErreur(x0)
+	for i=1:50
+		y = pointFixe(x0,i)
+		err(i) = // A completer
+	end
+endfunction

num/tp1/src/pointFixeVitesseConvergence.sci

@@ -0,0 +1,6 @@
+function [ ratio ] = pointFixeVitesseConvergence(x0)
+	err = pointFixeErreur(x0);
+	for i = 1:49
+		ratio(i) = // A completer
+	end
+endfunction

scilab/README.md

@@ -0,0 +1,435 @@
+## Avant de commencer
+SCILAB est téléchargeable rapidement [http://www.scilab.org/](http://www.scilab.org/).
+
+Le  logiciel  est accompagné  d'une  documentation  très complète.  
+
+De nombreux TP sont présents sur le site de Scilab  référencé ci-dessus.
+
+
+Il  faut savoir  que scilab,  comme  matlab, est  basé sur  un noyau  de
+fonctions   en   Fortran   ou   en   C  déjà   compilées   donc   rapides
+d'utilisation.  En revanche,  tout ce  que vous  créerez  vous-même sera
+interprété  ce   qui  ralentira  l'exécution  par   rapport  à  d'autres
+langages. De  plus, la gestion  des nombres n'est pas  toujours optimale
+car ils sont codés en complexes double précision ce qui peut être lourd.
+
+### Console
+
+La  ligne  de   commande  dans  la  console  permet  de   taper  des  opérations
+élémentaires, comme pour  une calculatrice scientifique. Il faut  taper tous les
+opérateurs, et  bien mettre des  parenthèses autour de  la formule. Une  fois la
+formule correctement entrée, appuyer sur la touche "entrée" affiche le résultat.
+Par exemple : 
+```
+--> 1+1 
+ans = 
+
+2. 
+```
+
+`ans` est l’abréviation de answer, il s’agit du nom
+de la variable où la réponse est stockée. 
+
+### Variables
+
+```
+--> x=9
+```
+
+- `clear x` supprime `x`
+- `clear` supprime toutes les variables et fonctions.
+
+Variables permanentes :
+
+| variable  | valeur         | 
+| :--------------- |:---------------| 
+| ans     | dernière réponse |
+|%t,%f    | Constante booléenne Vrai,Faux |
+|%e,%pi   | $e$ , $\pi$ |
+|%inf     | infini |
+
+### Opérations de base
+```
+--> 3+2
+```
+
+Si on ajoute un `;` à la fin de la ligne, cell-ci est lue, mais le résultat n'est pas affiché : c'est le mode silencieux.
+
+```
+--> a=2; b=2;3*a+8*b^3 // le résultat de ce dernier calcul sera affiché
+ans =
+
+70.
+```
+
+```
+1+sqrt(2)
+```
+
+On peut naviguer, comme dans le shell, dans l'historique des commandes avec les fléches directionnelles.
+
+```
+--> %e,%pi
+--> log(%e^2)
+```
+
+On peut utiliser des variables :
+
+```
+--> a=3;
+--> a^2
+--> clear a
+```
+
+### Objet de base : la matrice
+Tout est matrice pour scilab
+
+Une **matrice ligne** (vecteur ligne) :
+
+```
+--> vl = [1 2 3 10 100*%pi] //espace ou  virgule
+vl  =
+
+   1.   2.   3.   10.   314.15927
+
+```
+
+Une **matrice colonne** (vecteur colonne) :
+
+```
+--> w=[2;-3*%pi;7] // point virgule
+ w  = 
+
+   2.
+  -9.4247780
+   7.
+```
+
+Transposée : opérateur `'`
+```
+--> vl'
+ ans  =
+
+   1.
+   2.
+   3.
+   10.
+   314.15927
+```
+
+#### Vecteur dont les éléments forment une suite arithmétique
+
+Syntaxe `v=a:r:b` premier terme `a`, raison `r`, ne dépassant pas `b`
+
+```
+--> w=[-3:1.5:14]
+ w  =
+
+  -3.  -1.5   0.   1.5   3.   4.5   6.   7.5   9.   10.5   12.   13.5
+```
+
+Lorsque le pas est 1, on peut l'omettre.
+
+```
+--> y=[0:9] 
+ y  = 
+
+   0.   1.   2.   3.   4.   5.   6.   7.   8.   9.
+
+```
+
+Subdivision uniforme d'un intervalle avec `v=linspace(début, fin, nombre de valeurs)`
+
+```
+--> v=linspace(-5,8,6)
+ v  =
+
+  -5.  -2.4   0.2   2.8   5.4   8.
+```
+
+#### Création de matrices
+Avec la liste des coefficients 
+
+```
+--> A=[1,2,3;4,5,6]
+ A  =
+
+   1.   2.   3.
+   4.   5.   6.
+
+--> A=[1:4;2:5;3:6] 
+ A  = 
+
+   1.   2.   3.   4.
+   2.   3.   4.   5.
+   3.   4.   5.   6.
+
+
+```
+
+Matrices prédéfinies :
+
+| variable  | valeur         | 
+| :--------------- |:---------------| 
+| `ones(n,m)`     | matrice nxm dont les éléments valent 1 |
+| `zeros(n,m)`     | matrice nxm dont les éléments valent 0 |
+| `eye(n,m)`     | matrice nxm dont les éléemnts diagonaux valent 1, et 0 ailleurs |
+
+
+### Opérations sur les matrices
+**Concaténation**
+La concaténation permet de juxtaposer vecteurs et matrices dont les formats sont compatibles.
+```
+--> u=1:3; v=[u,u,u]
+ v  =
+
+   1.   2.   3.   1.   2.   3.   1.   2.   3.
+
+-->  u=1:3; v=[u;u;u]
+ v  =
+
+   1.   2.   3.
+   1.   2.   3.
+   1.   2.   3.
+
+```
+
+**Opérations algébriques**
+
+
+| Syntaxe   | k*A | A+B | A-B | A*B | A^n  |  inv(A) ou A^(-1)|  A' |
+| --- | --- | --- | --- | --- | --- | --- | --- | 
+| Signification   | $kA$ | $A+B$ | $A-B$ | $AB$ | $A^n$ | $A^{-1}$ | $^tA$ |
+</table>
+
+
+**Opérations algébriques pointées**
+
+Ce sont des opérations élément par élément
+| Syntaxe |A.*B | A./B | A.^n |
+| --- | --- | --- | --- |
+| Valeur | $(a_{ij}b_{ij})$ | $(a_{ij}/b_{ij})$ | $(a_{ij}^{n})$ |
+
+
+```
+--> u.^2
+ ans  =
+
+   0.   4.   16.   36.   64.   100.
+```
+
+
+**Fonctions matricielles**
+
+Si `A` est une matrice, et `f` une fonction connue de scilab, `f(A)` retourne la matrice sont les éléments sont les images des éléments de `A` par
+`f`.
+
+```
+--> A=[1 2 3;4 5 6;7 8 9]
+ A  =
+
+   1.   2.   3.
+   4.   5.   6.
+   7.   8.   9.
+
+--> sqrt(A+1)
+ ans  =
+
+   1.4142136   1.7320508   2.
+   2.236068    2.4494897   2.6457513
+   2.8284271   3.          3.1622777
+
+```
+
+
+
+
+
+**Accès à une partie**
+
+```
+--> A=[1 2 3;4 5 6];
+
+--> A(1,2) = 10
+ A  =
+
+   1.   10.   3.
+   4.   5.    6.
+
+--> u=[0 2 4  8 10];
+
+--> u(3),u(1:3),u($)
+ ans  =
+
+   4.
+ ans  =
+
+   0.   2.   4.
+ ans  =
+
+   10.
+
+```
+
+On peut rechercher dans un vecteur 
+
+```
+--> (A>2)
+ ans  =
+
+  F T T
+  T T T
+
+
+--> find(u>2)
+ ans  =
+
+   3.   4.   5.   6.
+
+```
+
+
+Pour extraire des lignes ou des colonnes ou des éléments particuliers :
+
+```
+--> A=[1,2,3;4,5,6;7,8,9];
+--> A(1,3)
+--> A(1,:)
+--> A(:,1)
+--> A($,:)
+--> A(1:2:$,:) 
+--> A($:-1:1,:)
+```
+### Fonctions usuelles prédéfinies
+
+**Analyse**
+
+`exp,log,sin,abs,floor`
+
+```
+--> exp(3),log(2),sin(%pi/3),abs(-2),floor(2.178)
+ ans  =
+
+   20.085537
+ ans  =
+
+   0.6931472
+ ans  =
+
+   0.8660254
+ ans  =
+
+   2.
+ ans  =
+
+   2.
+
+```
+
+**Matrice**
+
+`min,max,mean,median,sum,cumsum,size`
+
+```
+--> u=1:10, s=sum(u),cs = cumsum(u),m=mean(u),
+ u  =
+
+   1.   2.   3.   4.   5.   6.   7.   8.   9.   10.
+ s  =
+
+   55.
+ cs  =
+
+   1.   3.   6.   10.   15.   21.   28.   36.   45.   55.
+ m  =
+
+   5.5
+```
+
+### Graphiques
+On commence par créer un vecteur de 10000 valeurs régulièrement espacées entre 0 et 100 :
+``` 
+-->x=linspace(0,100,10000);
+```
+
+On aurait pu aussi bien poser :
+```
+--> x=0:.01:100
+```
+
+Nous voulons obtenir la représentation graphique de la fonction $x \rightarrow  x\sin(x)$  sur $[0,100]$ :
+
+```
+--> plot(x,x .*sin(x))
+```
+<div align="center">
+<img src="./img/img1.png">
+</div>
+
+Pour ajouter une autre courbe :
+```
+--> plot(x,x);
+```
+
+Tout demander d'un coup
+
+```
+--> clf; plot(x,x .*sin(x),x,x,x,-x)
+```
+
+On peut modifier le style des courbes 
+
+```
+--> X=linspace(-%pi,%pi,20);
+--> clf;plot(X,sin(X),"+-b");
+```
+
+<div align="center">
+<img src="./img/img2.png">
+</div>
+
+
+L'option **+-b** signifie qu'on représente chaque point par une croix (+) , qu'on les relie par un trait continue (-), en bleu (b)
+
+Regardez l'aide pour toutes les options.
+
+### Statistiques
+La fonction `rand(l,c)` permet de générer une matrice de nombres réelles aléatoires (par défaut, distribution uniforme sur [0,1[)
+
+Par exemple, pour simuler 100 lancers d'un dé à six faces :
+
+```
+--> m=floor(6*rand(100,1)+1)
+```
+On utilisera aussi la fonction `grand` (help grand) qui permet de simuler la plupart des lois classiques : binomiale, bernoulli, exponentielle, poisson, uniforme, normale, etc.
+
+
+La fonction `tabul(mat)` est très pratique : elle renvoie une matrice de deux colonnes avec les valeurs prises
+par les coefficients de mat sur la première colonne et leurs effectifs respectifs sur la deuxième.
+
+```
+--> t = tabul(m)
+```
+
+Pour obtenir une représentation graphique sous forme d’un diagramme en bâtons, 
+on utilise `bar(liste des abs,liste des ord)` :
+
+```
+--> bar(t(:,1),t(:,2))
+```
+
+<div align="center">
+<img src="./img/img3.png">
+</div>
+
+On peut aussi générer un camembert (une tarte en anglais :-))
+
+```
+--> pie(t(:,2),t(:,1),string(t(:,1)))
+```
+
+<div align="center">
+<img src="./img/img4.png">
+</div>
+
+