essai de resolution du conflit

cffae80f · sophie-mauran · a54c27f0 · a07000a1 · cffae80f · cffae80f
Commit cffae80f authored 3 years ago by sophie-mauran
--- a/src/Algorithme_De_Newton.jl
+++ b/src/Algorithme_De_Newton.jl
 @doc doc"""
-# Objet
+#### Objet
 Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contrainte
-# Syntaxe
+#### Syntaxe
 ```julia
 xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
 ```
-# Entrées :
+#### Entrées :
   - f       : (Function) la fonction à minimiser
   - gradf   : (Function) le gradient de la fonction f
   - hessf   : (Function) la Hessienne de la fonction f
@@ -18,7 +18,7 @@ xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
       - Tol_abs       : la tolérence absolue
       - Tol_rel       : la tolérence relative
-# Sorties:
+#### 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
@@ -28,7 +28,7 @@ xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
      - 3    : nombre maximal d'itération dépassé
   - nb_iters : (Integer) le nombre d'itérations faites par le programme
-# Exemple d'appel
+#### Exemple d'appel
 ```@example
 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)]

--- a/src/Gradient_Conjugue_Tronque.jl
+++ b/src/Gradient_Conjugue_Tronque.jl
 @doc doc"""
-# Objet
+#### Objet
 Cette fonction calcule une solution approchée du problème
 ```math
@@ -8,12 +8,12 @@ Cette fonction calcule une solution approchée du problème
 par l'algorithme du gradient conjugué tronqué
-# Syntaxe
+#### Syntaxe
 ```julia
 sk = Gradient_Conjugue_Tronque(fk,gradfk,hessfk,option)
 ```
-# Entrées :   
+#### 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})
@@ -22,10 +22,10 @@ sk = Gradient_Conjugue_Tronque(fk,gradfk,hessfk,option)
      - tol      : la tolérance pour la condition d'arrêt sur le gradient
-# Sorties:
+#### Sorties:
   - s : (Array{Float,1}) le pas s qui approche la solution du problème : ``min_{||s||< \delta_{k}} q(s)``
-# Exemple d'appel:
+#### Exemple d'appel:
 ```julia
 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/Lagrangien_Augmente.jl
+++ b/src/Lagrangien_Augmente.jl
 @doc doc"""
-# Objet
+#### Objet
 Résolution des problèmes de minimisation sous contraintes d'égalités par l'algorithme du lagrangien augmenté
-# Syntaxe
+#### Syntaxe
 ```julia
 Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
 			hess_contrainte,x0,options)
 ```
-# Entrées
+#### Entrées
  - algo 		   : (String) l'algorithme sans contraintes à utiliser:
    - "newton"  : pour l'algorithme de Newton
    - "cauchy"  : pour le pas de Cauchy
@@ -28,7 +28,7 @@ Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
    4. lambda0	   : la deuxième composante du point de départ du Lagrangien
    5. mu0,tho 	   : valeurs initiales des variables de l'algorithme
-# Sorties
+#### 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
@@ -39,7 +39,7 @@ Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
 - muk : (Float) valeur de mu_k à la sortie
 - lambdak : (Float) valeur de lambda_k à la sortie
-# Exemple d'appel
+#### Exemple d'appel
 ```julia
 using LinearAlgebra
 f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2
@@ -54,7 +54,7 @@ hess_contrainte(x) = [2 0;0 2]
 output = Lagrangien_Augmente(algo,f,contrainte,gradf,hessf,grad_contrainte,hess_contrainte,x0,options)
 ```
-# Tolérances des algorithmes appelés
+#### Tolérances des algorithmes appelés
 Pour les tolérances définies dans les algorithmes appelés (Newton et régions de confiance), prendre les tolérances 
 par défaut définies dans ces algorithmes.

--- a/src/Pas_De_Cauchy.jl
+++ b/src/Pas_De_Cauchy.jl
 @doc doc"""
-# Objet
+#### 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
+#### Syntaxe
 ```julia
 s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
 ```
-# Entrées
+#### 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
+#### 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
@@ -28,7 +28,7 @@ s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
        sinon
            e <- 0
-# Exemple d'appel
+#### Exemple d'appel
 ```julia
 g1 = [0; 0]
 H1 = [7 0 ; 0 2]

--- a/src/Regions_De_Confiance.jl
+++ b/src/Regions_De_Confiance.jl
 @doc doc"""
-# Objet
+#### 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
+#### Syntaxe
 ```julia
 xk, nb_iters, f(xk), flag = Regions_De_Confiance(algo,f,gradf,hessf,x0,option)
 ```
-# Entrées :
+#### Entrées :
   - algo        : (String) string indicant la méthode à utiliser pour calculer le pas
        - "gct"   : pour l'algorithme du gradient conjugué tronqué
@@ -31,7 +31,7 @@ xk, nb_iters, f(xk), flag = Regions_De_Confiance(algo,f,gradf,hessf,x0,option)
     - Tol_abs       : la tolérence absolue
     - Tol_rel       : la tolérence relative
-# Sorties:
+#### 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})``
@@ -42,7 +42,7 @@ xk, nb_iters, f(xk), flag = Regions_De_Confiance(algo,f,gradf,hessf,x0,option)
      - 3    : nombre maximal d'itération dépassé
   - nb_iters : (Integer)le nombre d'iteration qu'à fait le programme
-# Exemple d'appel
+#### Exemple d'appel
 ```julia
 algo="gct"
 f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2

--- a/src/algo_newton.ipynb
+++ b/src/algo_newton.ipynb
--- a/src/notebook_lagrangien_augmente.ipynb
+++ b/src/notebook_lagrangien_augmente.ipynb
--- a/src/notebook_algo_newton.ipynb
+++ b/src/notebook_algo_newton.ipynb
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<center>\n",
-    "<h1> TP-Projet d'optimisation numérique </h1>\n",
-    "<h1> Algorithme de Newton </h1>\n",
-    "</center>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Implémentation \n",
-    " \n",
-    "1. Coder l’algorithme de Newton local en respectant la spécification ci-dessous (fichier `Algorithme_De_Newton.jl`)\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "\\section{Objet}\n",
-       "Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contrainte\n",
-       "\n",
-       "\\section{Syntaxe}\n",
-       "\\begin{verbatim}\n",
-       "xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)\n",
-       "\\end{verbatim}\n",
-       "\\section{Entrées :}\n",
-       "\\begin{itemize}\n",
-       "\\item f       : (Function) la fonction à minimiser\n",
-       "\n",
-       "\n",
-       "\\item gradf   : (Function) le gradient de la fonction f\n",
-       "\n",
-       "\n",
-       "\\item hessf   : (Function) la Hessienne de la fonction f\n",
-       "\n",
-       "\n",
-       "\\item x0      : (Array\\{Float,1\\}) première approximation de la solution cherchée\n",
-       "\n",
-       "\n",
-       "\\item options : (Array\\{Float,1\\})\n",
-       "\n",
-       "\\begin{itemize}\n",
-       "\\item max\\_iter      : le nombre maximal d'iterations\n",
-       "\n",
-       "\n",
-       "\\item Tol\\_abs       : la tolérence absolue\n",
-       "\n",
-       "\n",
-       "\\item Tol\\_rel       : la tolérence relative\n",
-       "\n",
-       "\\end{itemize}\n",
-       "\\end{itemize}\n",
-       "\\section{Sorties:}\n",
-       "\\begin{itemize}\n",
-       "\\item xmin    : (Array\\{Float,1\\}) une approximation de la solution du problème  : $\\min_{x \\in \\mathbb{R}^{n}} f(x)$\n",
-       "\n",
-       "\n",
-       "\\item f\\emph{min   : (Float) ``f(x}\\{min\\})``\n",
-       "\n",
-       "\n",
-       "\\item flag     : (Integer) indique le critère sur lequel le programme à arrêter\n",
-       "\n",
-       "\\begin{itemize}\n",
-       "\\item 0    : Convergence\n",
-       "\n",
-       "\n",
-       "\\item 1    : stagnation du xk\n",
-       "\n",
-       "\n",
-       "\\item 2    : stagnation du f\n",
-       "\n",
-       "\n",
-       "\\item 3    : nombre maximal d'itération dépassé\n",
-       "\n",
-       "\\end{itemize}\n",
-       "\n",
-       "\\item nb\\_iters : (Integer) le nombre d'itérations faites par le programme\n",
-       "\n",
-       "\\end{itemize}\n",
-       "\\section{Exemple d'appel}\n",
-       "\\begin{verbatim}\n",
-       "f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2\n",
-       "gradf(x)=[-400*x[1]*(x[2]-x[1]^2)-2*(1-x[1]) ; 200*(x[2]-x[1]^2)]\n",
-       "hessf(x)=[-400*(x[2]-3*x[1]^2)+2  -400*x[1];-400*x[1]  200]\n",
-       "x0 = [1; 0]\n",
-       "options = []\n",
-       "xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f,gradf,hessf,x0,options)\n",
-       "\\end{verbatim}\n"
-      ],
-      "text/markdown": [
-       "# Objet\n",
-       "\n",
-       "Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contrainte\n",
-       "\n",
-       "# Syntaxe\n",
-       "\n",
-       "```julia\n",
-       "xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)\n",
-       "```\n",
-       "\n",
-       "# Entrées :\n",
-       "\n",
-       "  * f       : (Function) la fonction à minimiser\n",
-       "  * gradf   : (Function) le gradient de la fonction f\n",
-       "  * hessf   : (Function) la Hessienne de la fonction f\n",
-       "  * x0      : (Array{Float,1}) première approximation de la solution cherchée\n",
-       "  * options : (Array{Float,1})\n",
-       "\n",
-       "      * max_iter      : le nombre maximal d'iterations\n",
-       "      * Tol_abs       : la tolérence absolue\n",
-       "      * Tol_rel       : la tolérence relative\n",
-       "\n",
-       "# Sorties:\n",
-       "\n",
-       "  * xmin    : (Array{Float,1}) une approximation de la solution du problème  : $\\min_{x \\in \\mathbb{R}^{n}} f(x)$\n",
-       "  * f*min   : (Float) ``f(x*{min})``\n",
-       "  * flag     : (Integer) indique le critère sur lequel le programme à arrêter\n",
-       "\n",
-       "      * 0    : Convergence\n",
-       "      * 1    : stagnation du xk\n",
-       "      * 2    : stagnation du f\n",
-       "      * 3    : nombre maximal d'itération dépassé\n",
-       "  * nb_iters : (Integer) le nombre d'itérations faites par le programme\n",
-       "\n",
-       "# Exemple d'appel\n",
-       "\n",
-       "```@example\n",
-       "f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2\n",
-       "gradf(x)=[-400*x[1]*(x[2]-x[1]^2)-2*(1-x[1]) ; 200*(x[2]-x[1]^2)]\n",
-       "hessf(x)=[-400*(x[2]-3*x[1]^2)+2  -400*x[1];-400*x[1]  200]\n",
-       "x0 = [1; 0]\n",
-       "options = []\n",
-       "xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f,gradf,hessf,x0,options)\n",
-       "```\n"
-      ],
-      "text/plain": [
-       "\u001b[1m  Objet\u001b[22m\n",
-       "\u001b[1m  ≡≡≡≡≡≡≡\u001b[22m\n",
-       "\n",
-       "  Cette fonction implémente l'algorithme de Newton pour résoudre un problème\n",
-       "  d'optimisation sans contrainte\n",
-       "\n",
-       "\u001b[1m  Syntaxe\u001b[22m\n",
-       "\u001b[1m  ≡≡≡≡≡≡≡≡≡\u001b[22m\n",
-       "\n",
-       "\u001b[36m  xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)\u001b[39m\n",
-       "\n",
-       "\u001b[1m  Entrées :\u001b[22m\n",
-       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
-       "\n",
-       "    •  f : (Function) la fonction à minimiser\n",
-       "\n",
-       "    •  gradf : (Function) le gradient de la fonction f\n",
-       "\n",
-       "    •  hessf : (Function) la Hessienne de la fonction f\n",
-       "\n",
-       "    •  x0 : (Array{Float,1}) première approximation de la solution\n",
-       "       cherchée\n",
-       "\n",
-       "    •  options : (Array{Float,1})\n",
-       "       • max_iter : le nombre maximal d'iterations\n",
-       "       • Tol_abs : la tolérence absolue\n",
-       "       • Tol_rel : la tolérence relative\n",
-       "\n",
-       "\u001b[1m  Sorties:\u001b[22m\n",
-       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
-       "\n",
-       "    •  xmin : (Array{Float,1}) une approximation de la solution du\n",
-       "       problème : \u001b[35m\\min_{x \\in \\mathbb{R}^{n}} f(x)\u001b[39m\n",
-       "\n",
-       "    •  f\u001b[4mmin : (Float) ``f(x\u001b[24m{min})``\n",
-       "\n",
-       "    •  flag : (Integer) indique le critère sur lequel le programme à\n",
-       "       arrêter\n",
-       "       • 0 : Convergence\n",
-       "       • 1 : stagnation du xk\n",
-       "       • 2 : stagnation du f\n",
-       "       • 3 : nombre maximal d'itération dépassé\n",
-       "\n",
-       "    •  nb_iters : (Integer) le nombre d'itérations faites par le\n",
-       "       programme\n",
-       "\n",
-       "\u001b[1m  Exemple d'appel\u001b[22m\n",
-       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
-       "\n",
-       "\u001b[36m  f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2\u001b[39m\n",
-       "\u001b[36m  gradf(x)=[-400*x[1]*(x[2]-x[1]^2)-2*(1-x[1]) ; 200*(x[2]-x[1]^2)]\u001b[39m\n",
-       "\u001b[36m  hessf(x)=[-400*(x[2]-3*x[1]^2)+2  -400*x[1];-400*x[1]  200]\u001b[39m\n",
-       "\u001b[36m  x0 = [1; 0]\u001b[39m\n",
-       "\u001b[36m  options = []\u001b[39m\n",
-       "\u001b[36m  xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f,gradf,hessf,x0,options)\u001b[39m"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "using LinearAlgebra\n",
-    "using Documenter\n",
-    "using Markdown  \n",
-    "include(\"Algorithme_De_Newton.jl\")\n",
-    "@doc Algorithme_De_Newton"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "2. Vérifier que les tests ci-dessous passent."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[37m\u001b[1mTest Summary:    | \u001b[22m\u001b[39m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n",
-      "Test algo newton | \u001b[32m  14  \u001b[39m\u001b[36m   14\u001b[39m\n"
-     ]
-    }
-   ],
-   "source": [
-    "using Test\n",
-    "\n",
-    "# Tolérance pour les tests d'égalité\n",
-    "tol_erreur = sqrt(eps())\n",
-    "\n",
-    "## ajouter les fonctions de test\n",
-    "include(\"../test/fonctions_de_tests.jl\")\n",
-    "\n",
-    "include(\"../test/tester_algo_newton.jl\")\n",
-    "\n",
-    "include(\"../src/Algorithme_De_Newton.jl\")\n",
-    "\n",
-    "affiche = false\n",
-    "\n",
-    "@testset \"Test algo newton\" begin\n",
-    "\t# Tester l'algorithme de Newton\n",
-    "\ttester_algo_newton(affiche,Algorithme_De_Newton)\n",
-    "end;"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "-------------------------------------------------------------------------\n",
-      "\u001b[34m\u001b[1mRésultats de : Newton appliqué à f0 au point initial -1.5707963267948966:\u001b[22m\u001b[39m\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 = -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 = 1.5707963267948966\n",
-      "  * f(xsol) = 1.0\n",
-      "  * nb_iters = 0\n",
-      "  * flag = 0\n",
-      "  * sol_exacte : -1.5707963267948966\n"
-     ]
-    }
-   ],
-   "source": [
-    "#using Pkg; Pkg.add(\"LinearAlgebra\"); Pkg.add(\"Markdown\")\n",
-    "# using Documenter\n",
-    "using LinearAlgebra\n",
-    "using Markdown                             # Pour que les docstrings en début des fonctions ne posent\n",
-    "                                           # pas de soucis. Ces docstrings sont utiles pour générer \n",
-    "                                           # la documentation sous GitHub\n",
-    "include(\"Algorithme_De_Newton.jl\")\n",
-    "\n",
-    "# Affichage les sorties de l'algorithme des Régions de confiance\n",
-    "function my_afficher_resultats(algo,nom_fct,point_init,xmin,fxmin,flag,sol_exacte,nbiters)\n",
-    "\tprintln(\"-------------------------------------------------------------------------\")\n",
-    "\tprintstyled(\"Résultats de : \",algo, \" appliqué à \",nom_fct, \" au point initial \", point_init, \":\\n\",bold=true,color=:blue)\n",
-    "\tprintln(\"  * xsol = \",xmin)\n",
-    "\tprintln(\"  * f(xsol) = \",fxmin)\n",
-    "\tprintln(\"  * nb_iters = \",nbiters)\n",
-    "\tprintln(\"  * flag = \",flag)\n",
-    "\tprintln(\"  * sol_exacte : \", sol_exacte)\n",
-    "end\n",
-    "\n",
-    "# Fonction f0\n",
-    "# -----------\n",
-    "f0(x) =  sin(x)\n",
-    "# la gradient de la fonction f0\n",
-    "grad_f0(x) = cos(x)\n",
-    "# la hessienne de la fonction f0\n",
-    "hess_f0(x) = -sin(x)\n",
-    "sol_exacte = -pi/2\n",
-    "options = []\n",
-    "\n",
-    "x0 = sol_exacte\n",
-    "xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f0,grad_f0,hess_f0,x0,options)\n",
-    "my_afficher_resultats(\"Newton\",\"f0\",x0,xmin,f_min,flag,sol_exacte,nb_iters)\n",
-    "x0 = -pi/2+0.5\n",
-    "xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f0,grad_f0,hess_f0,x0,options)\n",
-    "my_afficher_resultats(\"Newton\",\"f0\",x0,xmin,f_min,flag,sol_exacte,nb_iters)\n",
-    "x0 = pi/2\n",
-    "xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f0,grad_f0,hess_f0,x0,options)\n",
-    "my_afficher_resultats(\"Newton\",\"f0\",x0,xmin,f_min,flag,sol_exacte,nb_iters)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Interprétation \n",
-    "\n",
-    "1. Justifier les résultats obtenus pour l'exemple $f_0$ ci-dessus;\n",
-    "\n",
-    "2. Soit $$ f_{1} : \\mathbf{R}^3 \\rightarrow \\mathbf{R}$$ $$ (x_1,x_2, x_3) \\mapsto  2 (x_1 +x_2 + x_3 -3)^2 + (x_1-x_2)^2 + (x_2 - x_3)^2$$ Justifier que l’algorithme implémenté converge en une itération pour $f_{1}$;\n",
-    "\n",
-    "3. Soit $$ f_{2} : \\mathbf{R}^2 \\rightarrow \\mathbf{R}$$ $$ (x_1,x_2) \\mapsto 100(x_2-x_1^2)^2 + (1-x_1)^2 $$ que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.\n",
-    "\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Julia 1.6.3",
-   "language": "julia",
-   "name": "julia-1.6"
-  },
-  "language_info": {
-   "file_extension": ".jl",
-   "mimetype": "application/julia",
-   "name": "julia",
-   "version": "1.6.3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
-%% Cell type:markdown id: tags:
-<center>
-<h1> TP-Projet d'optimisation numérique </h1>
-<h1> Algorithme de Newton </h1>
-</center>
-%% Cell type:markdown id: tags:
-## Implémentation
-1. Coder l’algorithme de Newton local en respectant la spécification ci-dessous (fichier `Algorithme_De_Newton.jl`)
-%% Cell type:code id: tags:
-``` julia
-using LinearAlgebra
-using Documenter
-using Markdown
-include("Algorithme_De_Newton.jl")
-@doc Algorithme_De_Newton
-```
-%% Output
-    # Objet
-    Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contrainte
-    # Syntaxe
-    ```julia
-    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
-    # 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
-    # Exemple d'appel
-    ```@example
-    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]
-    x0 = [1; 0]
-    options = []
-    xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f,gradf,hessf,x0,options)
-    ```
-    \section{Objet}
-    Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contrainte
-    \section{Syntaxe}
-    \begin{verbatim}
-    xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
-    \end{verbatim}
-    \section{Entrées :}
-    \begin{itemize}
-    \item f       : (Function) la fonction à minimiser
-    \item gradf   : (Function) le gradient de la fonction f
-    \item hessf   : (Function) la Hessienne de la fonction f
-    \item x0      : (Array\{Float,1\}) première approximation de la solution cherchée
-    \item options : (Array\{Float,1\})
-    \begin{itemize}
-    \item max\_iter      : le nombre maximal d'iterations
-    \item Tol\_abs       : la tolérence absolue
-    \item Tol\_rel       : la tolérence relative
-    \end{itemize}
-    \end{itemize}
-    \section{Sorties:}
-    \begin{itemize}
-    \item xmin    : (Array\{Float,1\}) une approximation de la solution du problème  : $\min_{x \in \mathbb{R}^{n}} f(x)$
-    \item f\emph{min   : (Float) ``f(x}\{min\})``
-    \item flag     : (Integer) indique le critère sur lequel le programme à arrêter
-    \begin{itemize}
-    \item 0    : Convergence
-    \item 1    : stagnation du xk
-    \item 2    : stagnation du f
-    \item 3    : nombre maximal d'itération dépassé
-    \end{itemize}
-    \item nb\_iters : (Integer) le nombre d'itérations faites par le programme
-    \end{itemize}
-    \section{Exemple d'appel}
-    \begin{verbatim}
-    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]
-    x0 = [1; 0]
-    options = []
-    xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f,gradf,hessf,x0,options)
-    \end{verbatim}
-    [1m  Objet[22m
-    [1m  ≡≡≡≡≡≡≡[22m
-      Cette fonction implémente l'algorithme de Newton pour résoudre un problème
-      d'optimisation sans contrainte
-    [1m  Syntaxe[22m
-    [1m  ≡≡≡≡≡≡≡≡≡[22m
-    [36m  xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)[39m
-    [1m  Entrées :[22m
-    [1m  ≡≡≡≡≡≡≡≡≡≡≡[22m
-        •  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
-    [1m  Sorties:[22m
-    [1m  ≡≡≡≡≡≡≡≡≡≡[22m
-        •  xmin : (Array{Float,1}) une approximation de la solution du
-           problème : [35m\min_{x \in \mathbb{R}^{n}} f(x)[39m
-        •  f[4mmin : (Float) ``f(x[24m{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
-    [1m  Exemple d'appel[22m
-    [1m  ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡[22m
-    [36m  f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2[39m
-    [36m  gradf(x)=[-400*x[1]*(x[2]-x[1]^2)-2*(1-x[1]) ; 200*(x[2]-x[1]^2)][39m
-    [36m  hessf(x)=[-400*(x[2]-3*x[1]^2)+2  -400*x[1];-400*x[1]  200][39m
-    [36m  x0 = [1; 0][39m
-    [36m  options = [][39m
-    [36m  xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f,gradf,hessf,x0,options)[39m
-%% Cell type:markdown id: tags:
-2. Vérifier que les tests ci-dessous passent.
-%% Cell type:code id: tags:
-``` julia
-using Test
-# Tolérance pour les tests d'égalité
-tol_erreur = sqrt(eps())
-## ajouter les fonctions de test
-include("../test/fonctions_de_tests.jl")
-include("../test/tester_algo_newton.jl")
-include("../src/Algorithme_De_Newton.jl")
-affiche = false
-@testset "Test algo newton" begin
-	# Tester l'algorithme de Newton
-	tester_algo_newton(affiche,Algorithme_De_Newton)
-end;
-```
-%% Output
-    [37m[1mTest Summary:    | [22m[39m[32m[1mPass  [22m[39m[36m[1mTotal[22m[39m
-    Test algo newton | [32m  14  [39m[36m   14[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 = -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 = -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 = 1.5707963267948966
-      * f(xsol) = 1.0
-      * nb_iters = 0
-      * flag = 0
-      * sol_exacte : -1.5707963267948966
-%% Cell type:markdown id: tags:
-## Interprétation
-1. Justifier les résultats obtenus pour l'exemple $f_0$ ci-dessus;
-2. Soit $$ f_{1} : \mathbf{R}^3 \rightarrow \mathbf{R}$$ $$ (x_1,x_2, x_3) \mapsto  2 (x_1 +x_2 + x_3 -3)^2 + (x_1-x_2)^2 + (x_2 - x_3)^2$$ Justifier que l’algorithme implémenté converge en une itération pour $f_{1}$;
-3. Soit $$ f_{2} : \mathbf{R}^2 \rightarrow \mathbf{R}$$ $$ (x_1,x_2) \mapsto 100(x_2-x_1^2)^2 + (1-x_1)^2 $$ que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.
--- a/src/notebook_regions_confiance.ipynb
+++ b/src/notebook_regions_confiance.ipynb
--- a/src/regions_confiance.ipynb
+++ b/src/regions_confiance.ipynb