Merge branch 'feature/refonte-spec' into 'feature/refonte'

Modification de la documentation des fonctions See merge request toc/mathn7/optimisation-numerique/projet-optinum!3

Merge branch 'feature/refonte-spec' into 'feature/refonte'
4638ffaf · Olivier Cots · 5101c4de · ee270e0e · 4638ffaf · 4638ffaf
Commit 4638ffaf authored 3 years ago by Olivier Cots
--- a/src/Algorithme_De_Newton.jl
+++ b/src/Algorithme_De_Newton.jl
+
 @doc doc"""
-Approximation de la solution du problème ``\min_{x \in \mathbb{R}^{n}} f(x)`` en utilisant l'algorithme de Newton
+# Objet
+Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contrainte

 # Syntaxe
 ```julia
@@ -7,28 +9,27 @@ xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
 ```

 # Entrées :
-   * **f**       : (Function) la fonction à minimiser
-   * **gradf**   : (Function) le gradient de la fonction f
-   * **hessf**   : (Function) la Hessienne de la fonction f
-   * **x0**      : (Array{Float,1}) première approximation de la solution cherchée
-   * **options** : (Array{Float,1})
-       * **max_iter**      : le nombre maximal d'iterations
-       * **Tol_abs**       : la tolérence absolue
-       * **Tol_rel**       : la tolérence relative
+   - f       : (Function) la fonction à minimiser
+   - gradf   : (Function) le gradient de la fonction f
+   - hessf   : (Function) la Hessienne de la fonction f
+   - x0      : (Array{Float,1}) première approximation de la solution cherchée
+   - options : (Array{Float,1})
+       - max_iter      : le nombre maximal d'iterations
+       - Tol_abs       : la tolérence absolue
+       - Tol_rel       : la tolérence relative

 # Sorties:
-   * **xmin**    : (Array{Float,1}) une approximation de la solution du problème  : ``\min_{x \in \mathbb{R}^{n}} f(x)``
-   * **f_min**   : (Float) ``f(x_{min})``
-   * **flag**     : (Integer) indique le critère sur lequel le programme à arrêter
-      * **0**    : Convergence
-      * **1**    : stagnation du xk
-      * **2**    : stagnation du f
-      * **3**    : nombre maximal d'itération dépassé
-   * **nb_iters** : (Integer) le nombre d'itérations faites par le programme
+   - xmin    : (Array{Float,1}) une approximation de la solution du problème  : ``\min_{x \in \mathbb{R}^{n}} f(x)``
+   - f_min   : (Float) ``f(x_{min})``
+   - flag     : (Integer) indique le critère sur lequel le programme à arrêter
+      - 0    : Convergence
+      - 1    : stagnation du xk
+      - 2    : stagnation du f
+      - 3    : nombre maximal d'itération dépassé
+   - nb_iters : (Integer) le nombre d'itérations faites par le programme

 # Exemple d'appel
 ```@example
-using Optinum
 f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2
 gradf(x)=[-400*x[1]*(x[2]-x[1]^2)-2*(1-x[1]) ; 200*(x[2]-x[1]^2)]
 hessf(x)=[-400*(x[2]-3*x[1]^2)+2  -400*x[1];-400*x[1]  200]

--- a/src/Gradient_Conjugue_Tronque.jl
+++ b/src/Gradient_Conjugue_Tronque.jl
 @doc doc"""
-Minimise le problème : ``min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs``
-                        pour la ``k^{ème}`` itération de l'algorithme des régions de confiance
+# Objet
+Cette fonction calcule une solution approchée du problème
+
+```math
+\min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs
+```
+
+par l'algorithme du gradient conjugué tronqué

 # Syntaxe
 ```julia
@@ -8,16 +14,16 @@ sk = Gradient_Conjugue_Tronque(fk,gradfk,hessfk,option)
 ```

 # Entrées :   
-   * **gradfk**           : (Array{Float,1}) le gradient de la fonction f appliqué au point xk
-   * **hessfk**           : (Array{Float,2}) la Hessienne de la fonction f appliqué au point xk
-   * **options**          : (Array{Float,1})
-      - **delta**    : le rayon de la région de confiance
-      - **max_iter** : le nombre maximal d'iterations
-      - **tol**      : la tolérance pour la condition d'arrêt sur le gradient
+   - gradfk           : (Array{Float,1}) le gradient de la fonction f appliqué au point xk
+   - hessfk           : (Array{Float,2}) la Hessienne de la fonction f appliqué au point xk
+   - options          : (Array{Float,1})
+      - delta    : le rayon de la région de confiance
+      - max_iter : le nombre maximal d'iterations
+      - tol      : la tolérance pour la condition d'arrêt sur le gradient


 # Sorties:
-   * **s** : (Array{Float,1}) le pas s qui approche la solution du problème : ``min_{||s||< \delta_{k}} q(s)``
+   - s : (Array{Float,1}) le pas s qui approche la solution du problème : ``min_{||s||< \delta_{k}} q(s)``

 # Exemple d'appel:
 ```julia

--- a/src/Lagrangien_Augmente.jl
+++ b/src/Lagrangien_Augmente.jl
 @doc doc"""
-Résolution des problèmes de minimisation sous contraintes d'égalités
+# Objet
+
+Résolution des problèmes de minimisation sous contraintes d'égalités par l'algorithme du lagrangien augmenté

 # Syntaxe
 ```julia
@@ -8,32 +10,32 @@ Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
 ```

 # Entrées
-  * **algo** 		   : (String) l'algorithme sans contraintes à utiliser:
-    - **"newton"**  : pour l'algorithme de Newton
-    - **"cauchy"**  : pour le pas de Cauchy
-    - **"gct"**     : pour le gradient conjugué tronqué
-  * **fonc** 		   : (Function) la fonction à minimiser
-  * **contrainte**	   : (Function) la contrainte [x est dans le domaine des contraintes ssi ``c(x)=0``]
-  * **gradfonc**       : (Function) le gradient de la fonction
-  * **hessfonc** 	   : (Function) la hessienne de la fonction
-  * **grad_contrainte** : (Function) le gradient de la contrainte
-  * **hess_contrainte** : (Function) la hessienne de la contrainte
-  * **x0** 			   : (Array{Float,1}) la première composante du point de départ du Lagrangien
-  * **options**		   : (Array{Float,1})
-    1. **epsilon** 	   : utilisé dans les critères d'arrêt
-    2. **tol**         : la tolérance utilisée dans les critères d'arrêt
-    3. **itermax** 	   : nombre maximal d'itération dans la boucle principale
-    4. **lambda0**	   : la deuxième composante du point de départ du Lagrangien
-    5. **mu0,tho** 	   : valeurs initiales des variables de l'algorithme
+  - algo 		   : (String) l'algorithme sans contraintes à utiliser:
+    - "newton"  : pour l'algorithme de Newton
+    - "cauchy"  : pour le pas de Cauchy
+    - "gct"     : pour le gradient conjugué tronqué
+  - fonc 		   : (Function) la fonction à minimiser
+  - contrainte	   : (Function) la contrainte [x est dans le domaine des contraintes ssi ``c(x)=0``]
+  - gradfonc       : (Function) le gradient de la fonction
+  - hessfonc 	   : (Function) la hessienne de la fonction
+  - grad_contrainte : (Function) le gradient de la contrainte
+  - hess_contrainte : (Function) la hessienne de la contrainte
+  - x0 			   : (Array{Float,1}) la première composante du point de départ du Lagrangien
+  - options		   : (Array{Float,1})
+    1. epsilon 	   : utilisé dans les critères d'arrêt
+    2. tol         : la tolérance utilisée dans les critères d'arrêt
+    3. itermax 	   : nombre maximal d'itération dans la boucle principale
+    4. lambda0	   : la deuxième composante du point de départ du Lagrangien
+    5. mu0,tho 	   : valeurs initiales des variables de l'algorithme

 # Sorties
-* **xmin**		   : (Array{Float,1}) une approximation de la solution du problème avec contraintes
-* **fxmin** 	   : (Float) ``f(x_{min})``
-* **flag**		   : (Integer) indicateur du déroulement de l'algorithme
-   - **0**    : convergence
-   - **1**    : nombre maximal d'itération atteint
-   - **(-1)** : une erreur s'est produite
-* **niters** 	   : (Integer) nombre d'itérations réalisées
+- xmin		   : (Array{Float,1}) une approximation de la solution du problème avec contraintes
+- fxmin 	   : (Float) ``f(x_{min})``
+- flag		   : (Integer) indicateur du déroulement de l'algorithme
+   - 0    : convergence
+   - 1    : nombre maximal d'itération atteint
+   - (-1) : une erreur s'est produite
+- niters 	   : (Integer) nombre d'itérations réalisées

 # Exemple d'appel
 ```julia

--- a/src/Pas_De_Cauchy.jl
+++ b/src/Pas_De_Cauchy.jl
 @doc doc"""
-Approximation de la solution du sous-problème ``q_k(s) = s^{t}g + (1/2)s^{t}Hs`` 
-        avec ``s=-t g_k,t > 0,||s||< \delta_k ``

+# Objet
+Cette fonction calcule une solution approchée du problème
+```math
+\min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs
+```
+par le calcul du pas de Cauchy

 # Syntaxe
 ```julia
@@ -9,13 +13,13 @@ s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
 ```

 # Entrées
- * **gradfk** : (Array{Float,1}) le gradient de la fonction f appliqué au point ``x_k``
- * **hessfk** : (Array{Float,2}) la Hessienne de la fonction f appliqué au point ``x_k``
- * **delta**  : (Float) le rayon de la région de confiance
+ - gradfk : (Array{Float,1}) le gradient de la fonction f appliqué au point ``x_k``
+ - hessfk : (Array{Float,2}) la Hessienne de la fonction f appliqué au point ``x_k``
+ - delta  : (Float) le rayon de la région de confiance

 # Sorties
- * **s** : (Array{Float,1}) une approximation de la  solution du sous-problème
- * **e** : (Integer) indice indiquant l'état de sortie:
+ - s : (Array{Float,1}) une approximation de la  solution du sous-problème
+ - e : (Integer) indice indiquant l'état de sortie:
        si g != 0
            si on ne sature pas la boule
              e <- 1

--- a/src/Regions_De_Confiance.jl
+++ b/src/Regions_De_Confiance.jl
 @doc doc"""
-Minimise une fonction en utilisant l'algorithme des régions de confiance avec
-    - le pas de Cauchy
-ou
-    - le pas issu de l'algorithme du gradient conjugue tronqué
+
+# Objet
+
+Minimise une fonction de R^n à valeurs dans R en utilisant l'algorithme des régions de confiance. 
+
+La solution approchées des sous-problèmes quadratiques est calculé 
+par le pas de Cauchy ou le pas issu de l'algorithme du gradient conjugue tronqué

 # Syntaxe
 ```julia
@@ -11,33 +14,33 @@ xk, nb_iters, f(xk), flag = Regions_De_Confiance(algo,f,gradf,hessf,x0,option)

 # Entrées :

-   * **algo**        : (String) string indicant la méthode à utiliser pour calculer le pas
-        - **"gct"**   : pour l'algorithme du gradient conjugué tronqué
-        - **"cauchy"**: pour le pas de Cauchy
-   * **f**           : (Function) la fonction à minimiser
-   * **gradf**       : (Function) le gradient de la fonction f
-   * **hessf**       : (Function) la hessiene de la fonction à minimiser
-   * **x0**          : (Array{Float,1}) point de départ
-   * **options**     : (Array{Float,1})
-     * **deltaMax**      : utile pour les m-à-j de la région de confiance
+   - algo        : (String) string indicant la méthode à utiliser pour calculer le pas
+        - "gct"   : pour l'algorithme du gradient conjugué tronqué
+        - "cauchy": pour le pas de Cauchy
+   - f           : (Function) la fonction à minimiser
+   - gradf       : (Function) le gradient de la fonction f
+   - hessf       : (Function) la hessiene de la fonction à minimiser
+   - x0          : (Array{Float,1}) point de départ
+   - options     : (Array{Float,1})
+     - deltaMax      : utile pour les m-à-j de la région de confiance
                      ``R_{k}=\left\{x_{k}+s ;\|s\| \leq \Delta_{k}\right\}``
-     * **gamma1,gamma2** : ``0 < \gamma_{1} < 1 < \gamma_{2}`` pour les m-à-j de ``R_{k}``
-     * **eta1,eta2**     : ``0 < \eta_{1} < \eta_{2} < 1`` pour les m-à-j de ``R_{k}``
-     * **delta0**        : le rayon de départ de la région de confiance
-     * **max_iter**      : le nombre maximale d'iterations
-     * **Tol_abs**       : la tolérence absolue
-     * **Tol_rel**       : la tolérence relative
+     - gamma1,gamma2 : ``0 < \gamma_{1} < 1 < \gamma_{2}`` pour les m-à-j de ``R_{k}``
+     - eta1,eta2     : ``0 < \eta_{1} < \eta_{2} < 1`` pour les m-à-j de ``R_{k}``
+     - delta0        : le rayon de départ de la région de confiance
+     - max_iter      : le nombre maximale d'iterations
+     - Tol_abs       : la tolérence absolue
+     - Tol_rel       : la tolérence relative

 # Sorties:

-   * **xmin**    : (Array{Float,1}) une approximation de la solution du problème : ``min_{x \in \mathbb{R}^{n}} f(x)``
-   * **fxmin**   : (Float) ``f(x_{min})``
-   * **flag**    : (Integer) un entier indiquant le critère sur lequel le programme à arrêter
-      - **0**    : Convergence
-      - **1**    : stagnation du ``x``
-      - **2**    : stagnation du ``f``
-      - **3**    : nombre maximal d'itération dépassé
-   * **nb_iters** : (Integer)le nombre d'iteration qu'à fait le programme
+   - xmin    : (Array{Float,1}) une approximation de la solution du problème : ``min_{x \in \mathbb{R}^{n}} f(x)``
+   - fxmin   : (Float) ``f(x_{min})``
+   - flag    : (Integer) un entier indiquant le critère sur lequel le programme à arrêter
+      - 0    : Convergence
+      - 1    : stagnation du ``x``
+      - 2    : stagnation du ``f``
+      - 3    : nombre maximal d'itération dépassé
+   - nb_iters : (Integer)le nombre d'iteration qu'à fait le programme

 # Exemple d'appel
 ```julia

--- a/src/projet-optinum.ipynb
+++ b/src/projet-optinum.ipynb
@@ -26,19 +26,64 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
-      "\u001b[32m\u001b[1m      Status\u001b[22m\u001b[39m `~/.julia/environments/v1.6/Project.toml`\n",
-      " \u001b[90m [336ed68f] \u001b[39mCSV v0.9.10\n",
-      " \u001b[90m [a93c6f00] \u001b[39mDataFrames v1.2.2\n",
-      " \u001b[90m [0c46a032] \u001b[39mDifferentialEquations v6.20.0\n",
-      " \u001b[90m [7073ff75] \u001b[39mIJulia v1.23.2\n",
-      " \u001b[90m [91a5bcdd] \u001b[39mPlots v1.23.6\n"
+      "\u001b[32m\u001b[1mStatus\u001b[22m\u001b[39m `~/.julia/environments/v1.4/Project.toml`\n",
+      " \u001b[90m [c52e3926]\u001b[39m\u001b[37m Atom v0.12.15\u001b[39m\n",
+      " \u001b[90m [336ed68f]\u001b[39m\u001b[37m CSV v0.6.2\u001b[39m\n",
+      " \u001b[90m [159f3aea]\u001b[39m\u001b[37m Cairo v1.0.3\u001b[39m\n",
+      " \u001b[90m [13f3f980]\u001b[39m\u001b[37m CairoMakie v0.1.2\u001b[39m\n",
+      " \u001b[90m [5ae59095]\u001b[39m\u001b[37m Colors v0.12.2\u001b[39m\n",
+      " \u001b[90m [a81c6b42]\u001b[39m\u001b[37m Compose v0.8.2\u001b[39m\n",
+      " \u001b[90m [717857b8]\u001b[39m\u001b[37m DSP v0.6.7\u001b[39m\n",
+      " \u001b[90m [a93c6f00]\u001b[39m\u001b[37m DataFrames v0.21.2\u001b[39m\n",
+      " \u001b[90m [41bf760c]\u001b[39m\u001b[37m DiffEqSensitivity v6.21.0\u001b[39m\n",
+      " \u001b[90m [6d1b261a]\u001b[39m\u001b[37m DiffEqTutorials v0.7.0 #master (https://github.com/JuliaDiffEq/DiffEqTutorials.jl)\u001b[39m\n",
+      " \u001b[90m [0c46a032]\u001b[39m\u001b[37m DifferentialEquations v6.14.0\u001b[39m\n",
+      " \u001b[90m [e30172f5]\u001b[39m\u001b[37m Documenter v0.24.11\u001b[39m\n",
+      " \u001b[90m [90d7349d]\u001b[39m\u001b[37m Erdos v0.7.0\u001b[39m\n",
+      " \u001b[90m [587475ba]\u001b[39m\u001b[37m Flux v0.10.4\u001b[39m\n",
+      " \u001b[90m [f6369f11]\u001b[39m\u001b[37m ForwardDiff v0.10.10\u001b[39m\n",
+      " \u001b[90m [c91e804a]\u001b[39m\u001b[37m Gadfly v1.3.0\u001b[39m\n",
+      " \u001b[90m [4d00f742]\u001b[39m\u001b[37m GeometryTypes v0.8.3\u001b[39m\n",
+      " \u001b[90m [a2cc645c]\u001b[39m\u001b[37m GraphPlot v0.3.1\u001b[39m\n",
+      " \u001b[90m [bd48cda9]\u001b[39m\u001b[37m GraphRecipes v0.5.4\u001b[39m\n",
+      " \u001b[90m [86223c79]\u001b[39m\u001b[37m Graphs v0.10.3\u001b[39m\n",
+      " \u001b[90m [7073ff75]\u001b[39m\u001b[37m IJulia v1.21.2\u001b[39m\n",
+      " \u001b[90m [4138dd39]\u001b[39m\u001b[37m JLD v0.10.0\u001b[39m\n",
+      " \u001b[90m [033835bb]\u001b[39m\u001b[37m JLD2 v0.1.13\u001b[39m\n",
+      " \u001b[90m [e5e0dc1b]\u001b[39m\u001b[37m Juno v0.8.2\u001b[39m\n",
+      " \u001b[90m [b964fa9f]\u001b[39m\u001b[37m LaTeXStrings v1.1.0\u001b[39m\n",
+      " \u001b[90m [093fc24a]\u001b[39m\u001b[37m LightGraphs v1.3.3\u001b[39m\n",
+      " \u001b[90m [5c8ed15e]\u001b[39m\u001b[37m LinearOperators v1.1.0\u001b[39m\n",
+      " \u001b[90m [4854310b]\u001b[39m\u001b[37m MINPACK v1.1.1\u001b[39m\n",
+      " \u001b[90m [99179fae]\u001b[39m\u001b[37m MTH2210 v0.2.0 #master (https://github.com/amontoison/MTH2210.jl.git)\u001b[39m\n",
+      " \u001b[90m [7ebac608]\u001b[39m\u001b[37m Multigraphs v0.1.0\u001b[39m\n",
+      " \u001b[90m [2774e3e8]\u001b[39m\u001b[37m NLsolve v4.4.0\u001b[39m\n",
+      " \u001b[90m [54ca160b]\u001b[39m\u001b[37m ODEInterface v0.4.6\u001b[39m\n",
+      " \u001b[90m [09606e27]\u001b[39m\u001b[37m ODEInterfaceDiffEq v3.7.0\u001b[39m\n",
+      " \u001b[90m [289cfbba]\u001b[39m\u001b[37m Optinum v0.1.0 #master (https://github.com/mathn7/Optinum)\u001b[39m\n",
+      " \u001b[90m [217bec77]\u001b[39m\u001b[37m OptinumProf v0.1.0 #master (https://github.com/mathn7/OptinumProf.git)\u001b[39m\n",
+      " \u001b[90m [1dea7af3]\u001b[39m\u001b[37m OrdinaryDiffEq v5.41.0\u001b[39m\n",
+      " \u001b[90m [d254efa0]\u001b[39m\u001b[37m PkgSkeleton v0.3.1 #master (https://github.com/triscale-innov/PkgSkeleton.jl)\u001b[39m\n",
+      " \u001b[90m [91a5bcdd]\u001b[39m\u001b[37m Plots v1.4.1\u001b[39m\n",
+      " \u001b[90m [d330b81b]\u001b[39m\u001b[37m PyPlot v2.9.0\u001b[39m\n",
+      " \u001b[90m [295af30f]\u001b[39m\u001b[37m Revise v2.7.2\u001b[39m\n",
+      " \u001b[90m [47aef6b3]\u001b[39m\u001b[37m SimpleWeightedGraphs v1.1.1\u001b[39m\n",
+      " \u001b[90m [2913bbd2]\u001b[39m\u001b[37m StatsBase v0.32.2\u001b[39m\n",
+      " \u001b[90m [a6016688]\u001b[39m\u001b[37m TestOptinum v0.1.0 #master (https://github.com/mathn7/TestOptinum.git)\u001b[39m\n",
+      " \u001b[90m [1504d1ba]\u001b[39m\u001b[37m Toto v0.1.0 [`../../../ENS/Julia/Creation-Pkg/Toto`]\u001b[39m\n",
+      " \u001b[90m [44d3d7a6]\u001b[39m\u001b[37m Weave v0.9.4\u001b[39m\n",
+      " \u001b[90m [e88e6eb3]\u001b[39m\u001b[37m Zygote v0.4.20\u001b[39m\n",
+      " \u001b[90m [37e2e46d]\u001b[39m\u001b[37m LinearAlgebra \u001b[39m\n",
+      " \u001b[90m [d6f4376e]\u001b[39m\u001b[37m Markdown \u001b[39m\n",
+      " \u001b[90m [de0858da]\u001b[39m\u001b[37m Printf \u001b[39m\n",
+      " \u001b[90m [8dfed614]\u001b[39m\u001b[37m Test \u001b[39m\n"
     ]
    }
   ],
@@ -49,7 +94,148 @@
  },
  {
   "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/latex": [
+       "\\section{Objet}\n",
+       "Cette fonction calcule une solution approchée du problème\n",
+       "\n",
+       "$$\\min_{||s||< \\delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs$$\n",
+       "par le calcul du pas de Cauchy\n",
+       "\n",
+       "\\section{Syntaxe}\n",
+       "\\begin{verbatim}\n",
+       "s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)\n",
+       "\\end{verbatim}\n",
+       "\\section{Entrées}\n",
+       "\\begin{itemize}\n",
+       "\\item gradfk : (Array\\{Float,1\\}) le gradient de la fonction f appliqué au point $x_k$\n",
+       "\n",
+       "\n",
+       "\\item hessfk : (Array\\{Float,2\\}) la Hessienne de la fonction f appliqué au point $x_k$\n",
+       "\n",
+       "\n",
+       "\\item delta  : (Float) le rayon de la région de confiance\n",
+       "\n",
+       "\\end{itemize}\n",
+       "\\section{Sorties}\n",
+       "\\begin{itemize}\n",
+       "\\item s : (Array\\{Float,1\\}) une approximation de la  solution du sous-problème\n",
+       "\n",
+       "\n",
+       "\\item e : (Integer) indice indiquant l'état de sortie:      si g != 0          si on ne sature pas la boule            e <- 1          sinon            e <- -1      sinon          e <- 0\n",
+       "\n",
+       "\\end{itemize}\n",
+       "\\section{Exemple d'appel}\n",
+       "\\begin{verbatim}\n",
+       "g1 = [0; 0]\n",
+       "H1 = [7 0 ; 0 2]\n",
+       "delta1 = 1\n",
+       "s1, e1 = Pas_De_Cauchy(g1,H1,delta1)\n",
+       "\\end{verbatim}\n"
+      ],
+      "text/markdown": [
+       "# Objet\n",
+       "\n",
+       "Cette fonction calcule une solution approchée du problème\n",
+       "\n",
+       "$$\n",
+       "\\min_{||s||< \\delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs\n",
+       "$$\n",
+       "\n",
+       "par le calcul du pas de Cauchy\n",
+       "\n",
+       "# Syntaxe\n",
+       "\n",
+       "```julia\n",
+       "s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)\n",
+       "```\n",
+       "\n",
+       "# Entrées\n",
+       "\n",
+       "  * gradfk : (Array{Float,1}) le gradient de la fonction f appliqué au point $x_k$\n",
+       "  * hessfk : (Array{Float,2}) la Hessienne de la fonction f appliqué au point $x_k$\n",
+       "  * delta  : (Float) le rayon de la région de confiance\n",
+       "\n",
+       "# Sorties\n",
+       "\n",
+       "  * s : (Array{Float,1}) une approximation de la  solution du sous-problème\n",
+       "  * e : (Integer) indice indiquant l'état de sortie:      si g != 0          si on ne sature pas la boule            e <- 1          sinon            e <- -1      sinon          e <- 0\n",
+       "\n",
+       "# Exemple d'appel\n",
+       "\n",
+       "```julia\n",
+       "g1 = [0; 0]\n",
+       "H1 = [7 0 ; 0 2]\n",
+       "delta1 = 1\n",
+       "s1, e1 = Pas_De_Cauchy(g1,H1,delta1)\n",
+       "```\n"
+      ],
+      "text/plain": [
+       "\u001b[1m  Objet\u001b[22m\n",
+       "\u001b[1m  ≡≡≡≡≡≡≡\u001b[22m\n",
+       "\n",
+       "  Cette fonction calcule une solution approchée du problème\n",
+       "\n",
+       "\u001b[35m\\min_{||s||< \\delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs\u001b[39m\n",
+       "\n",
+       "  par le calcul du pas de Cauchy\n",
+       "\n",
+       "\u001b[1m  Syntaxe\u001b[22m\n",
+       "\u001b[1m  ≡≡≡≡≡≡≡≡≡\u001b[22m\n",
+       "\n",
+       "\u001b[36m  s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)\u001b[39m\n",
+       "\n",
+       "\u001b[1m  Entrées\u001b[22m\n",
+       "\u001b[1m  ≡≡≡≡≡≡≡≡≡\u001b[22m\n",
+       "\n",
+       "    •    gradfk : (Array{Float,1}) le gradient de la fonction f appliqué au\n",
+       "        point \u001b[35mx_k\u001b[39m\n",
+       "\n",
+       "    •    hessfk : (Array{Float,2}) la Hessienne de la fonction f appliqué\n",
+       "        au point \u001b[35mx_k\u001b[39m\n",
+       "\n",
+       "    •    delta : (Float) le rayon de la région de confiance\n",
+       "\n",
+       "\u001b[1m  Sorties\u001b[22m\n",
+       "\u001b[1m  ≡≡≡≡≡≡≡≡≡\u001b[22m\n",
+       "\n",
+       "    •    s : (Array{Float,1}) une approximation de la solution du\n",
+       "        sous-problème\n",
+       "\n",
+       "    •    e : (Integer) indice indiquant l'état de sortie: si g != 0 si on\n",
+       "        ne sature pas la boule e <- 1 sinon e <- -1 sinon e <- 0\n",
+       "\n",
+       "\u001b[1m  Exemple d'appel\u001b[22m\n",
+       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
+       "\n",
+       "\u001b[36m  g1 = [0; 0]\u001b[39m\n",
+       "\u001b[36m  H1 = [7 0 ; 0 2]\u001b[39m\n",
+       "\u001b[36m  delta1 = 1\u001b[39m\n",
+       "\u001b[36m  s1, e1 = Pas_De_Cauchy(g1,H1,delta1)\u001b[39m"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#using Pkg; Pkg.add(\"LinearAlgebra\"); Pkg.add(\"Markdown\")\n",
+    "# using Documenter\n",
+    "using LinearAlgebra\n",
+    "using Documenter\n",
+    "using Markdown  \n",
+    "include(\"Pas_De_Cauchy.jl\")\n",
+    "@doc Pas_De_Cauchy"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
@@ -58,26 +244,37 @@
     "text": [
      "-------------------------------------------------------------------------\n",
      "\u001b[34m\u001b[1mRésultats de : Newton appliqué à f0 au point initial -1.5707963267948966:\u001b[22m\u001b[39m\n",
-      "  * xsol = [0.0]\n",
-      "  * f(xsol) = 0\n",
+      "  * xsol = -1.5707963267948966\n",
+      "  * f(xsol) = -1.0\n",
      "  * nb_iters = 0\n",
      "  * flag = 0\n",
      "  * sol_exacte : -1.5707963267948966\n",
      "-------------------------------------------------------------------------\n",
      "\u001b[34m\u001b[1mRésultats de : Newton appliqué à f0 au point initial -1.0707963267948966:\u001b[22m\u001b[39m\n",
-      "  * xsol = [0.0]\n",
-      "  * f(xsol) = 0\n",
+      "  * xsol = -1.0707963267948966\n",
+      "  * f(xsol) = -0.8775825618903726\n",
      "  * nb_iters = 0\n",
      "  * flag = 0\n",
      "  * sol_exacte : -1.5707963267948966\n",
      "-------------------------------------------------------------------------\n",
      "\u001b[34m\u001b[1mRésultats de : Newton appliqué à f0 au point initial 1.5707963267948966:\u001b[22m\u001b[39m\n",
-      "  * xsol = [0.0]\n",
-      "  * f(xsol) = 0\n",
+      "  * xsol = 1.5707963267948966\n",
+      "  * f(xsol) = 1.0\n",
      "  * nb_iters = 0\n",
      "  * flag = 0\n",
      "  * sol_exacte : -1.5707963267948966\n"
     ]
+    },
+    {
+     "ename": "MethodError",
+     "evalue": "MethodError: no method matching Base.Docs.Binding(::typeof(Algorithme_De_Newton), ::Symbol)\nClosest candidates are:\n  Base.Docs.Binding(!Matched::Module, ::Symbol) at docs/bindings.jl:12",
+     "output_type": "error",
+     "traceback": [
+      "MethodError: no method matching Base.Docs.Binding(::typeof(Algorithme_De_Newton), ::Symbol)\nClosest candidates are:\n  Base.Docs.Binding(!Matched::Module, ::Symbol) at docs/bindings.jl:12",
+      "",
+      "Stacktrace:",
+      " [1] top-level scope at In[6]:39"
+     ]
    }
   ],
   "source": [
@@ -284,15 +481,15 @@
 ],
 "metadata": {
  "kernelspec": {
-   "display_name": "Julia 1.6.0",
+   "display_name": "Julia 1.4.1",
   "language": "julia",
-   "name": "julia-1.6"
+   "name": "julia-1.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
-   "version": "1.6.0"
+   "version": "1.4.1"
  }
 },
 "nbformat": 4,

 %% Cell type:markdown id: tags:

 <center>
 <h1> TP-Projet d'optimisation numérique </h1>
 <h1> Année 2020-2021 - 2e année département Sciences du Numérique </h1>
 <h1> Noms:  </h1>
 <h1> Prénoms:  </h1>
 </center>

 %% Cell type:markdown id: tags:

 # Algorithme de Newton
 ## Implémentation

 1. Coder l’algorithme de Newton local tel que décrit dans la section *Algorithme de Newton* (fichier `Algorithme_De_Newton.jl`)

 2. Tester l’algorithme sur les fonctions $f_{1}$ , $f_{2}$ avec les points initiaux $x_{011}$ , $x_{012}$ (pour $f_{1}$ ) et $x_{021}$ , $x_{022}$ , $x_{023}$ (pour $f_{2}$ ) donnés en Annexe A.

 %% Cell type:code id: tags:

 ``` julia
 using Pkg
 Pkg.status()
 ```

 %% Output

-    [32m[1m      Status[22m[39m `~/.julia/environments/v1.6/Project.toml`
-     [90m [336ed68f] [39mCSV v0.9.10
-     [90m [a93c6f00] [39mDataFrames v1.2.2
-     [90m [0c46a032] [39mDifferentialEquations v6.20.0
-     [90m [7073ff75] [39mIJulia v1.23.2
-     [90m [91a5bcdd] [39mPlots v1.23.6
+    [32m[1mStatus[22m[39m `~/.julia/environments/v1.4/Project.toml`
+     [90m [c52e3926][39m[37m Atom v0.12.15[39m
+     [90m [336ed68f][39m[37m CSV v0.6.2[39m
+     [90m [159f3aea][39m[37m Cairo v1.0.3[39m
+     [90m [13f3f980][39m[37m CairoMakie v0.1.2[39m
+     [90m [5ae59095][39m[37m Colors v0.12.2[39m
+     [90m [a81c6b42][39m[37m Compose v0.8.2[39m
+     [90m [717857b8][39m[37m DSP v0.6.7[39m
+     [90m [a93c6f00][39m[37m DataFrames v0.21.2[39m
+     [90m [41bf760c][39m[37m DiffEqSensitivity v6.21.0[39m
+     [90m [6d1b261a][39m[37m DiffEqTutorials v0.7.0 #master (https://github.com/JuliaDiffEq/DiffEqTutorials.jl)[39m
+     [90m [0c46a032][39m[37m DifferentialEquations v6.14.0[39m
+     [90m [e30172f5][39m[37m Documenter v0.24.11[39m
+     [90m [90d7349d][39m[37m Erdos v0.7.0[39m
+     [90m [587475ba][39m[37m Flux v0.10.4[39m
+     [90m [f6369f11][39m[37m ForwardDiff v0.10.10[39m
+     [90m [c91e804a][39m[37m Gadfly v1.3.0[39m
+     [90m [4d00f742][39m[37m GeometryTypes v0.8.3[39m
+     [90m [a2cc645c][39m[37m GraphPlot v0.3.1[39m
+     [90m [bd48cda9][39m[37m GraphRecipes v0.5.4[39m
+     [90m [86223c79][39m[37m Graphs v0.10.3[39m
+     [90m [7073ff75][39m[37m IJulia v1.21.2[39m
+     [90m [4138dd39][39m[37m JLD v0.10.0[39m
+     [90m [033835bb][39m[37m JLD2 v0.1.13[39m
+     [90m [e5e0dc1b][39m[37m Juno v0.8.2[39m
+     [90m [b964fa9f][39m[37m LaTeXStrings v1.1.0[39m
+     [90m [093fc24a][39m[37m LightGraphs v1.3.3[39m
+     [90m [5c8ed15e][39m[37m LinearOperators v1.1.0[39m
+     [90m [4854310b][39m[37m MINPACK v1.1.1[39m
+     [90m [99179fae][39m[37m MTH2210 v0.2.0 #master (https://github.com/amontoison/MTH2210.jl.git)[39m
+     [90m [7ebac608][39m[37m Multigraphs v0.1.0[39m
+     [90m [2774e3e8][39m[37m NLsolve v4.4.0[39m
+     [90m [54ca160b][39m[37m ODEInterface v0.4.6[39m
+     [90m [09606e27][39m[37m ODEInterfaceDiffEq v3.7.0[39m
+     [90m [289cfbba][39m[37m Optinum v0.1.0 #master (https://github.com/mathn7/Optinum)[39m
+     [90m [217bec77][39m[37m OptinumProf v0.1.0 #master (https://github.com/mathn7/OptinumProf.git)[39m
+     [90m [1dea7af3][39m[37m OrdinaryDiffEq v5.41.0[39m
+     [90m [d254efa0][39m[37m PkgSkeleton v0.3.1 #master (https://github.com/triscale-innov/PkgSkeleton.jl)[39m
+     [90m [91a5bcdd][39m[37m Plots v1.4.1[39m
+     [90m [d330b81b][39m[37m PyPlot v2.9.0[39m
+     [90m [295af30f][39m[37m Revise v2.7.2[39m
+     [90m [47aef6b3][39m[37m SimpleWeightedGraphs v1.1.1[39m
+     [90m [2913bbd2][39m[37m StatsBase v0.32.2[39m
+     [90m [a6016688][39m[37m TestOptinum v0.1.0 #master (https://github.com/mathn7/TestOptinum.git)[39m
+     [90m [1504d1ba][39m[37m Toto v0.1.0 [`../../../ENS/Julia/Creation-Pkg/Toto`][39m
+     [90m [44d3d7a6][39m[37m Weave v0.9.4[39m
+     [90m [e88e6eb3][39m[37m Zygote v0.4.20[39m
+     [90m [37e2e46d][39m[37m LinearAlgebra [39m
+     [90m [d6f4376e][39m[37m Markdown [39m
+     [90m [de0858da][39m[37m Printf [39m
+     [90m [8dfed614][39m[37m Test [39m
+
+%% Cell type:code id: tags:
+
+``` julia
+#using Pkg; Pkg.add("LinearAlgebra"); Pkg.add("Markdown")
+# using Documenter
+using LinearAlgebra
+using Documenter
+using Markdown
+include("Pas_De_Cauchy.jl")
+@doc Pas_De_Cauchy
+```
+
+%% Output
+
+    # Objet
+    
+    Cette fonction calcule une solution approchée du problème
+    
+    $$
+    \min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs
+    $$
+    
+    par le calcul du pas de Cauchy
+    
+    # Syntaxe
+    
+    ```julia
+    s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
+    ```
+    
+    # Entrées
+    
+      * gradfk : (Array{Float,1}) le gradient de la fonction f appliqué au point $x_k$
+      * hessfk : (Array{Float,2}) la Hessienne de la fonction f appliqué au point $x_k$
+      * delta  : (Float) le rayon de la région de confiance
+    
+    # Sorties
+    
+      * s : (Array{Float,1}) une approximation de la  solution du sous-problème
+      * e : (Integer) indice indiquant l'état de sortie:      si g != 0          si on ne sature pas la boule            e <- 1          sinon            e <- -1      sinon          e <- 0
+    
+    # Exemple d'appel
+    
+    ```julia
+    g1 = [0; 0]
+    H1 = [7 0 ; 0 2]
+    delta1 = 1
+    s1, e1 = Pas_De_Cauchy(g1,H1,delta1)
+    ```
+    \section{Objet}
+    Cette fonction calcule une solution approchée du problème
+    
+    $$\min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs$$
+    par le calcul du pas de Cauchy
+    
+    \section{Syntaxe}
+    \begin{verbatim}
+    s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
+    \end{verbatim}
+    \section{Entrées}
+    \begin{itemize}
+    \item gradfk : (Array\{Float,1\}) le gradient de la fonction f appliqué au point $x_k$
+    
+    
+    \item hessfk : (Array\{Float,2\}) la Hessienne de la fonction f appliqué au point $x_k$
+    
+    
+    \item delta  : (Float) le rayon de la région de confiance
+    
+    \end{itemize}
+    \section{Sorties}
+    \begin{itemize}
+    \item s : (Array\{Float,1\}) une approximation de la  solution du sous-problème
+    
+    
+    \item e : (Integer) indice indiquant l'état de sortie:      si g != 0          si on ne sature pas la boule            e <- 1          sinon            e <- -1      sinon          e <- 0
+    
+    \end{itemize}
+    \section{Exemple d'appel}
+    \begin{verbatim}
+    g1 = [0; 0]
+    H1 = [7 0 ; 0 2]
+    delta1 = 1
+    s1, e1 = Pas_De_Cauchy(g1,H1,delta1)
+    \end{verbatim}
+    [1m  Objet[22m
+    [1m  ≡≡≡≡≡≡≡[22m
+    
+      Cette fonction calcule une solution approchée du problème
+    
+    [35m\min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs[39m
+    
+      par le calcul du pas de Cauchy
+    
+    [1m  Syntaxe[22m
+    [1m  ≡≡≡≡≡≡≡≡≡[22m
+    
+    [36m  s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)[39m
+    
+    [1m  Entrées[22m
+    [1m  ≡≡≡≡≡≡≡≡≡[22m
+    
+        •    gradfk : (Array{Float,1}) le gradient de la fonction f appliqué au
+            point [35mx_k[39m
+    
+        •    hessfk : (Array{Float,2}) la Hessienne de la fonction f appliqué
+            au point [35mx_k[39m
+    
+        •    delta : (Float) le rayon de la région de confiance
+    
+    [1m  Sorties[22m
+    [1m  ≡≡≡≡≡≡≡≡≡[22m
+    
+        •    s : (Array{Float,1}) une approximation de la solution du
+            sous-problème
+    
+        •    e : (Integer) indice indiquant l'état de sortie: si g != 0 si on
+            ne sature pas la boule e <- 1 sinon e <- -1 sinon e <- 0
+    
+    [1m  Exemple d'appel[22m
+    [1m  ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡[22m
+    
+    [36m  g1 = [0; 0][39m
+    [36m  H1 = [7 0 ; 0 2][39m
+    [36m  delta1 = 1[39m
+    [36m  s1, e1 = Pas_De_Cauchy(g1,H1,delta1)[39m

 %% Cell type:code id: tags:

 ``` julia
 #using Pkg; Pkg.add("LinearAlgebra"); Pkg.add("Markdown")
 # using Documenter
 using LinearAlgebra
 using Markdown                             # Pour que les docstrings en début des fonctions ne posent
                                           # pas de soucis. Ces docstrings sont utiles pour générer
                                           # la documentation sous GitHub
 include("Algorithme_De_Newton.jl")

 # Affichage les sorties de l'algorithme des Régions de confiance
 function my_afficher_resultats(algo,nom_fct,point_init,xmin,fxmin,flag,sol_exacte,nbiters)
 	println("-------------------------------------------------------------------------")
 	printstyled("Résultats de : ",algo, " appliqué à ",nom_fct, " au point initial ", point_init, ":\n",bold=true,color=:blue)
 	println("  * xsol = ",xmin)
 	println("  * f(xsol) = ",fxmin)
 	println("  * nb_iters = ",nbiters)
 	println("  * flag = ",flag)
 	println("  * sol_exacte : ", sol_exacte)
 end

 # Fonction f0
 # -----------
 f0(x) =  sin(x)
 # la gradient de la fonction f0
 grad_f0(x) = cos(x)
 # la hessienne de la fonction f0
 hess_f0(x) = -sin(x)
 sol_exacte = -pi/2
 options = []

 x0 = sol_exacte
 xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f0,grad_f0,hess_f0,x0,options)
 my_afficher_resultats("Newton","f0",x0,xmin,f_min,flag,sol_exacte,nb_iters)
 x0 = -pi/2+0.5
 xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f0,grad_f0,hess_f0,x0,options)
 my_afficher_resultats("Newton","f0",x0,xmin,f_min,flag,sol_exacte,nb_iters)
 x0 = pi/2
 xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f0,grad_f0,hess_f0,x0,options)
 my_afficher_resultats("Newton","f0",x0,xmin,f_min,flag,sol_exacte,nb_iters)
 ```

 %% Output

    -------------------------------------------------------------------------
    [34m[1mRésultats de : Newton appliqué à f0 au point initial -1.5707963267948966:[22m[39m
-      * xsol = [0.0]
-      * f(xsol) = 0
+      * xsol = -1.5707963267948966
+      * f(xsol) = -1.0
      * nb_iters = 0
      * flag = 0
      * sol_exacte : -1.5707963267948966
    -------------------------------------------------------------------------
    [34m[1mRésultats de : Newton appliqué à f0 au point initial -1.0707963267948966:[22m[39m
-      * xsol = [0.0]
-      * f(xsol) = 0
+      * xsol = -1.0707963267948966
+      * f(xsol) = -0.8775825618903726
      * nb_iters = 0
      * flag = 0
      * sol_exacte : -1.5707963267948966
    -------------------------------------------------------------------------
    [34m[1mRésultats de : Newton appliqué à f0 au point initial 1.5707963267948966:[22m[39m
-      * xsol = [0.0]
-      * f(xsol) = 0
+      * xsol = 1.5707963267948966
+      * f(xsol) = 1.0
      * nb_iters = 0
      * flag = 0
      * sol_exacte : -1.5707963267948966

+MethodError: no method matching Base.Docs.Binding(::typeof(Algorithme_De_Newton), ::Symbol)
+Closest candidates are:
+  Base.Docs.Binding(!Matched::Module, ::Symbol) at docs/bindings.jl:12
+Stacktrace:
+ [1] top-level scope at In[6]:39
+
 %% Cell type:markdown id: tags:

 ## Interprétation

 Justifier

 1. les résultats obtenus pour l'exemple $f_0$ ci-dessus;

 2. que l’algorithme implémenté converge en une itération pour $f_{1}$;

 3. que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.

 %% Cell type:markdown id: tags:

 ## Vos réponses?

 %% Cell type:markdown id: tags:

 # Régions de confiance avec pas de cauchy

 ## Implémentation

 1. Coder l'algorithme du pas de Cauchy d’un sous-problème de
 régions de confiance (fichier `Pas_De_Cauchy.jl`). Tester sur les quadratiques proposées en Annexe B.

 2. Coder l'algorithme de régions de confiance (fichier `Regions_De_Confiance.jl`). Tester sur les problèmes de l’Annexe A.

 %% Cell type:code id: tags:

 ``` julia
 # Vos tests
 ```

 %% Cell type:markdown id: tags:

 ## Interprétation

 1. Quelle relation lie la fonction test $f_1$ et son modèle de Taylor à l’ordre 2 ? Comparer alors les performances de Newton et RC-Pas de Cauchy sur cette fonction.

 2. Le rayon initial de la région de confiance est un paramètre important dans l’analyse
 de la performance de l’algorithme. Sur quel(s) autre(s) paramètre(s) peut-on jouer
 pour essayer d’améliorer cette performance ? Étudier l’influence d’au moins deux de
 ces paramètres.

 %% Cell type:markdown id: tags:

 ## Vos réponses?

 %% Cell type:markdown id: tags:

 # Régions de confiance avec gradient conjugué tronqué

 ## Implémentation

 1. Implémenter l’algorithme du Gradient Conjugué Tronqué, en se basant sur le cours (fichier `Gradient_Conjugue_Tronque.jl`).
 On validera les résultats sur les fonctions de l’Annexe C.

 2. Intégrer finalement l’algorithme du Gradient Conjugué Tronqué dans le code de
 régions de confiance, et appliquer ce code pour résoudre les exemples proposés en
 Annexe A.

 %% Cell type:code id: tags:

 ``` julia
 # Vos tests
 ```

 %% Cell type:markdown id: tags:

 ## Interprétation

 1. Comparer la décroissance obtenue avec celle du pas de Cauchy, en imposant la sortie
 dans l’algorithme 3 au bout d’une itération seulement. Que remarquez vous ?

 2. Comparer la décroissance obtenue avec celle du pas de Cauchy dans le cas général.

 3. Quels sont les avantages et inconvénients des deux approches ?

 %% Cell type:markdown id: tags:

 ## Vos réponses?

 %% Cell type:markdown id: tags:

 # Lagrangien augmenté

 ## Implémentation
 1.Choisir des critères d’arrêt pour la convergence de l'algorithme.

 2.Implémenter l'algorithme du lagrangien augmenté, en utilisant les différentes méthodes
 qui ont été vues en première partie pour la résolution de la suite de problémes sans
 contraintes (fichier `Lagrangien_Augmente.jl`)

 3.Tester les différentes variantes sur les problèmes en Annexe D.


 %% Cell type:code id: tags:

 ``` julia
 # Vos tests
 ```

 %% Cell type:markdown id: tags:

 ## Interprétation
 1.Commenter les résultats obtenus, en étudiant notamment les valeurs de $\lambda_k$ et $\mu_k$.

 2.Étudier l'influence du paramètre $\tau$ dans la performance de l'algorithme.

 3.**Supplémentaire** :
      Que proposez-vous comme méthode pour la résolution des problèmes avec
      des contraintes à la fois d'égalité et d'inégalité ? Implémenter (si le temps le permet)
      ce nouvel algorithme

 %% Cell type:markdown id: tags:

 ## Vos réponses?