diff --git a/README.md b/README.md
index 9607f0130a044a8d35314ec7f73cd885e841b522..5a39c7b3a67a23c7669932a58a9d68437cb971c4 100644
--- a/README.md
+++ b/README.md
@@ -2,15 +2,12 @@
 
 ## Récupérer les sources
 
-Pour récupérer les sources, il faut cloner ce dépot git : 
-
-```bash
-git clone https://gitlab.irit.fr/toc/mathn7/optimisation-numerique/projet-optinum.git
-```
+Pour récupérer les sources, il faut cloner ce dépot git. Vous pouvez suivre les instructions : 
+[Cloner un dépôt Gitlab](https://gitlab.irit.fr/toc/etu-n7/documentation/-/wikis/Cloner-un-projet-Gitlab).
 
 ## Organisation des sources
 
-Les sujets liés au projet se trouvent dans les notebooks. Voici l'ordre des sujets :
+Les sujets liés au projet se trouvent dans les notebooks du répertoire `notebooks`. Voici l'ordre des sujets :
 
 * Newton
 * Régions de confiance
@@ -20,9 +17,9 @@ Pour réaliser le projet vous aurez besoin de cette [documentation](doc-projet.p
 
 ## Installation de Julia
 
-Si vous n'avez pas encore installer Julia sur votre compte N7 ou sur votre machine personnelle, suivez les indications :
-[Utilisation de Julia à l'N7](https://gitlab.irit.fr/toc/mathn7/wiki/-/wikis/Utilisation-de-Julia-à-l'N7).
+Si vous n'avez pas encore installer Julia sur votre compte N7 ou sur votre machine personnelle, suivez les instructions :
+[Utilisation de Julia à l'N7](https://gitlab.irit.fr/toc/etu-n7/documentation/-/wikis/Utilisation-de-Julia-à-l'N7).
 
 ## Illustration de la méthode de Newton
 
-![newton](newton.gif)
+![Newton](newton.gif)
\ No newline at end of file
diff --git a/doc-projet.pdf b/doc-projet.pdf
index 62521cacf8f9ba52e96c87cb5aabe367d3ca9d13..f321b71330978dc4083f5f86e47cab2f9b3bd86c 100644
Binary files a/doc-projet.pdf and b/doc-projet.pdf differ
diff --git a/src/Algorithme_De_Newton.jl b/src/Algorithme_De_Newton.jl
deleted file mode 100644
index b47719bef2e9685f4fb49a5e5e0614f8c6574211..0000000000000000000000000000000000000000
--- a/src/Algorithme_De_Newton.jl
+++ /dev/null
@@ -1,61 +0,0 @@
-
-@doc doc"""
-#### Objet
-Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contraintes
-
-#### Syntaxe
-```julia
-xmin,fmin,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
-       - epsilon       : epsilon pour les tests de stagnation
-
-#### Sorties:
-   - xmin    : (Array{Float,1}) une approximation de la solution du problème  : ``\min_{x \in \mathbb{R}^{n}} f(x)``
-   - fmin    : (Float) ``f(x_{min})``
-   - flag    : (Integer) indique le critère sur lequel le programme s'est arrêté (en respectant cet ordre de priorité si plusieurs critères sont vérifiés)
-      - 0    : CN1 
-      - 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,fmin,flag,nb_iters = Algorithme_De_Newton(f,gradf,hessf,x0,options)
-```
-"""
-function Algorithme_De_Newton(f::Function,gradf::Function,hessf::Function,x0,options)
-
-    "# Si options == [] on prends les paramètres par défaut"
-    if options == []
-        max_iter = 100
-        Tol_abs = sqrt(eps())
-        Tol_rel = 1e-15
-        epsilon = 1.e-2
-    else
-        max_iter = options[1]
-        Tol_abs = options[2]
-        Tol_rel = options[3]
-        epsilon = options[4]
-    end
-        xmin = x0
-        fmin = f(x0)
-        flag = 0
-        nb_iters = 0
-    return xmin,fmin,flag,nb_iters
-end
diff --git a/src/Gradient_Conjugue_Tronque.jl b/src/Gradient_Conjugue_Tronque.jl
deleted file mode 100644
index db9e6a5ddb6892f549ef920aaffcbc05f27dcdc3..0000000000000000000000000000000000000000
--- a/src/Gradient_Conjugue_Tronque.jl
+++ /dev/null
@@ -1,52 +0,0 @@
-@doc doc"""
-#### Objet
-Cette fonction calcule une solution approchée du problème
-
-```math
-\min_{||s||< \Delta}  q(s) = s^{t} g + \frac{1}{2} s^{t}Hs
-```
-
-par l'algorithme du gradient conjugué tronqué
-
-#### Syntaxe
-```julia
-s = Gradient_Conjugue_Tronque(g,H,option)
-```
-
-#### Entrées :   
-   - g : (Array{Float,1}) un vecteur de ``\mathbb{R}^n``
-   - H : (Array{Float,2}) une matrice symétrique de ``\mathbb{R}^{n\times n}``
-   - 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} q(s)``
-
-#### 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]
-xk = [1; 0]
-options = []
-s = Gradient_Conjugue_Tronque(gradf(xk),hessf(xk),options)
-```
-"""
-function Gradient_Conjugue_Tronque(g,H,options)
-
-    "# Si option est vide on initialise les 3 paramètres par défaut"
-    if options == []
-        delta = 2
-        max_iter = 100
-        tol = 1e-6
-    else
-        delta = options[1]
-        max_iter = options[2]
-        tol = options[3]
-    end
-
-   n = length(g)
-   s = zeros(n)
-   return s
-end
diff --git a/src/Lagrangien_Augmente.jl b/src/Lagrangien_Augmente.jl
old mode 100755
new mode 100644
index cffadf803e3cb2367ddfcccd78cefd1800ed6434..ebeac8597bb374b99d4e852c05d3359b858bbf62
--- a/src/Lagrangien_Augmente.jl
+++ b/src/Lagrangien_Augmente.jl
@@ -1,92 +1,75 @@
-@doc doc"""
-#### Objet
+using LinearAlgebra
+include("../src/newton.jl")
+include("../src/regions_de_confiance.jl")
+"""
 
-Résolution des problèmes de minimisation avec une contrainte d'égalité scalaire par l'algorithme du lagrangien augmenté.
+Approximation d'une solution au problème 
 
-#### Syntaxe
-```julia
-xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)
-```
+    min f(x), x ∈ Rⁿ, sous la c c(x) = 0,
 
-#### 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é
-  - f : (Function) la fonction à minimiser
-  - gradf       : (Function) le gradient de la fonction
-  - hessf       : (Function) la hessienne de la fonction
-  - c     : (Function) la contrainte [x est dans le domaine des contraintes ssi ``c(x)=0``]
-  - gradc : (Function) le gradient de la contrainte
-  - hessc : (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
+par l'algorithme du lagrangien augmenté.
 
-#### 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
-- muks : (Array{Float64,1}) tableau des valeurs prises par mu_k au cours de l'exécution
-- lambdaks : (Array{Float64,1}) tableau des valeurs prises par lambda_k au cours de l'exécution
+# Syntaxe
 
-#### Exemple d'appel
-```julia
-using LinearAlgebra
-algo = "gct" # ou newton|gct
-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]
-c(x) =  (x[1]^2) + (x[2]^2) -1.5
-gradc(x) = [2*x[1] ;2*x[2]]
-hessc(x) = [2 0;0 2]
-x0 = [1; 0]
-options = []
-xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)
-```
+    x_sol, f_sol, flag, nb_iters, μs, λs = lagrangien_augmente(f, gradf, hessf, c, gradc, hessc, x0; kwargs...)
+
+# Entrées
+
+    - f      : (Function) la ftion à minimiser
+    - gradf  : (Function) le gradient de f
+    - hessf  : (Function) la hessienne de f
+    - c      : (Function) la c à valeur dans R
+    - gradc  : (Function) le gradient de c
+    - hessc  : (Function) la hessienne de c
+    - x0     : (Vector{<:Real}) itéré initial
+    - kwargs : les options sous formes d'arguments "keywords"
+        • max_iter  : (Integer) le nombre maximal d'iterations (optionnel, par défaut 1000)
+        • tol_abs   : (Real) la tolérence absolue (optionnel, par défaut 1e-10)
+        • tol_rel   : (Real) la tolérence relative (optionnel, par défaut 1e-8)
+        • λ0        : (Real) le multiplicateur de lagrange associé à c initial (optionnel, par défaut 2)
+        • μ0        : (Real) le facteur initial de pénalité de la c (optionnel, par défaut 10)
+        • τ         : (Real) le facteur d'accroissement de μ (optionnel, par défaut 2)
+        • algo_noc  : (String) l'algorithme sans c à utiliser (optionnel, par défaut "rc-gct")
+            * "newton"    : pour l'algorithme de Newton
+            * "rc-cauchy" : pour les régions de confiance avec pas de Cauchy
+            * "rc-gct"    : pour les régions de confiance avec gradient conjugué tronqué
+
+# Sorties
+
+    - x_sol    : (Vector{<:Real}) une approximation de la solution du problème
+    - f_sol    : (Real) f(x_sol)
+    - flag     : (Integer) indique le critère sur lequel le programme s'est arrêté
+        • 0 : convergence
+        • 1 : nombre maximal d'itération dépassé
+    - nb_iters : (Integer) le nombre d'itérations faites par le programme
+    - μs       : (Vector{<:Real}) tableau des valeurs prises par μk au cours de l'exécution
+    - λs       : (Vector{<:Real}) tableau des valeurs prises par λk au cours de l'exécution
 
-#### Tolérances des algorithmes appelés
+# Exemple d'appel
 
-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.
+    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]
+    c(x) =  x[1]^2 + x[2]^2 - 1.5
+    gradc(x) = 2*x
+    hessc(x) = [2 0; 0 2]
+    x0 = [1; 0]
+    x_sol, _ = lagrangien_augmente(f, gradf, hessf, c, gradc, hessc, x0, algo_noc="rc-gct")
 
 """
-function Lagrangien_Augmente(algo,fonc::Function,contrainte::Function,gradfonc::Function,
-        hessfonc::Function,grad_contrainte::Function,hess_contrainte::Function,x0,options)
+function lagrangien_augmente(f::Function, gradf::Function, hessf::Function, 
+        c::Function, gradc::Function, hessc::Function, x0::Vector{<:Real}; 
+        max_iter::Integer=1000, tol_abs::Real=1e-10, tol_rel::Real=1e-8,
+        λ0::Real=2, μ0::Real=10, τ::Real=2, algo_noc::String="rc-gct")
 
-    	if options == []
-		epsilon = 1e-2
-		tol = 1e-5
-		itermax = 1000
-		lambda0 = 2
-		mu0 = 100
-		tho = 2
-	else
-		epsilon = options[1]
-		tol = options[2]
-		itermax = options[3]
-		lambda0 = options[4]
-		mu0 = options[5]
-		tho = options[6]
-	end
+    #
+    x_sol = x0
+    f_sol = f(x_sol)
+    flag  = -1
+    nb_iters = 0
+    μs = [μ0] # vous pouvez faire μs = vcat(μs, μk) pour concaténer les valeurs
+    λs = [λ0]
 
-  n = length(x0)
-  xmin = zeros(n)
-        fxmin = 0
-        flag = 0
-        iter = 0
-  muk = mu0
-  muks = [mu0]
-  lambdak = lambda0
-  lambdaks = [lambda0]
+    return x_sol, f_sol, flag, nb_iters, μs, λs
 
-        
-        return xmin,fxmin,flag,iter, muks, lambdaks
 end
diff --git a/src/Pas_De_Cauchy.jl b/src/Pas_De_Cauchy.jl
deleted file mode 100644
index 83748fe170b333197123ab515ffecf44e7120022..0000000000000000000000000000000000000000
--- a/src/Pas_De_Cauchy.jl
+++ /dev/null
@@ -1,46 +0,0 @@
-@doc doc"""
-
-#### Objet
-Cette fonction calcule une solution approchée du problème
-```math
-\min_{||s||< \Delta} s^{t}g + \frac{1}{2}s^{t}Hs
-```
-par le calcul du pas de Cauchy.
-
-#### Syntaxe
-```julia
-s, e = Pas_De_Cauchy(g,H,delta)
-```
-
-#### Entrées
- - g : (Array{Float,1}) un vecteur de ``\mathbb{R}^n``
- - H : (Array{Float,2}) une matrice symétrique de ``\mathbb{R}^{n\times n}``
- - 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
-g = [0; 0]
-H = [7 0 ; 0 2]
-delta = 1
-s, e = Pas_De_Cauchy(g,H,delta)
-```
-"""
-function Pas_De_Cauchy(g,H,delta)
-
-    e = 0
-    n = length(g)
-    s = zeros(n)
-    
-    return s, e
-end
diff --git a/src/Regions_De_Confiance.jl b/src/Regions_De_Confiance.jl
index 74274a0521e820fb5d2ab6baa940a9333552a8c9..1dfc2f0cd08d72a88c47386f872fb6715881d151 100644
--- a/src/Regions_De_Confiance.jl
+++ b/src/Regions_De_Confiance.jl
@@ -1,91 +1,68 @@
-@doc doc"""
+using LinearAlgebra
+include("../src/cauchy.jl")
+include("../src/gct.jl")
+"""
+Approximation de la solution du problème min f(x), x ∈ Rⁿ.
 
-#### Objet
+L'algorithme des régions de confiance résout à chaque itération, un modèle quadratique
+de la fonction f dans une boule (appelée la région de confiance) de centre l'itéré 
+courant. Cette minimisation se fait soit par un pas de Cauchy ou par l'algorithme 
+du gradient conjugué tronqué.
 
-Minimise une fonction de ``\mathbb{R}^{n}`` à valeurs dans ``\mathbb{R}`` en utilisant l'algorithme des régions de confiance. 
+# Syntaxe
 
-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é
+    x_sol, f_sol, flag, nb_iters, xs = regions_de_confiance(f, gradf, hessf, x0; kwargs...)
 
-#### Syntaxe
-```julia
-xmin, fxmin, flag, nb_iters = Regions_De_Confiance(algo,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
+    - x0      : (Vector{<:Real}) itéré initial
+    - kwargs  : les options sous formes d'arguments "keywords"
+        • max_iter      : (Integer) le nombre maximal d'iterations (optionnel, par défaut 5000)
+        • tol_abs       : (Real) la tolérence absolue (optionnel, par défaut 1e-10)
+        • tol_rel       : (Real) la tolérence relative (optionnel, par défaut 1e-8)
+        • epsilon       : (Real) le epsilon pour les tests de stagnation (optionnel, par défaut 1)
+        • Δ0            : (Real) le rayon initial de la région de confiance (optionnel, par défaut 2)
+        • Δmax          : (Real) le rayon maximal de la région de confiance (optionnel, par défaut 10)
+        • γ1, γ2        : (Real) les facteurs de mise à jour de la région de confiance (optionnel, par défaut 0.5 et 2)
+        • η1, η2        : (Real) les seuils pour la mise à jour de la région de confiance (optionnel, par défaut 0.25 et 0.75)
+        • algo_pas      : (String) l'algorithme de calcul du pas - "cauchy" ou "gct" (optionnel, par défaut "gct")
+        • max_iter_gct  : (Integer) le nombre maximal d'iterations du GCT (optionnel, par défaut 2*length(x0))
 
-   - 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
-     - epsilon       : epsilon pour les tests de stagnation
+# Sorties
 
-#### Sorties:
+    - x_sol : (Vector{<:Real}) une approximation de la solution du problème
+    - f_sol : (Real) f(x_sol)
+    - flag  : (Integer) indique le critère sur lequel le programme s'est arrêté
+        • 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
+    - xs    : (Vector{Vector{<:Real}}) les itérés
 
-   - 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 s'est arrêté (en respectant cet ordre de priorité si plusieurs critères sont vérifiés)
-      - 0    : CN1
-      - 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
 
-#### Exemple d'appel
-```julia
-algo="gct"
-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, fxmin, flag, nb_iters = Regions_De_Confiance(algo,f,gradf,hessf,x0,options)
-```
-"""
-function Regions_De_Confiance(algo,f::Function,gradf::Function,hessf::Function,x0,options)
+    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]
+    x_sol, f_sol, flag, nb_iters, xs = regions_de_confiance(f, gradf, hessf, x0, algo_pas="gct")
 
-    if options == []
-        deltaMax = 10
-        gamma1 = 0.5
-        gamma2 = 2.00
-        eta1 = 0.25
-        eta2 = 0.75
-        delta0 = 2
-        max_iter = 1000
-        Tol_abs = sqrt(eps())
-        Tol_rel = 1e-15
-        epsilon = 1.e-2
-    else
-        deltaMax = options[1]
-        gamma1 = options[2]
-        gamma2 = options[3]
-        eta1 = options[4]
-        eta2 = options[5]
-        delta0 = options[6]
-        max_iter = options[7]
-        Tol_abs = options[8]
-        Tol_rel = options[9]
-        epsilon = options[10]
-    end
+"""
+function regions_de_confiance(f::Function, gradf::Function, hessf::Function, x0::Vector{<:Real};
+    max_iter::Integer=5000, tol_abs::Real=1e-10, tol_rel::Real=1e-8, epsilon::Real=1, 
+    Δ0::Real=2, Δmax::Real=10, γ1::Real=0.5, γ2::Real=2, η1::Real=0.25, η2::Real=0.75, algo_pas::String="gct",
+    max_iter_gct::Integer = 2*length(x0))
 
-    n = length(x0)
-    xmin = zeros(n)
-    fxmin = f(xmin)
-    flag = 0
+    #
+    x_sol = x0
+    f_sol = f(x_sol)
+    flag  = -1
     nb_iters = 0
+    xs = [x0] # vous pouvez faire xs = vcat(xs, [xk]) pour concaténer les valeurs
 
-    return xmin, fxmin, flag, nb_iters
+    return x_sol, f_sol, flag, nb_iters, xs
 end
diff --git a/src/algo_newton.ipynb b/src/algo_newton.ipynb
deleted file mode 100644
index 452eabd42b868eecf594a75641c9f6e464ffa3e8..0000000000000000000000000000000000000000
--- a/src/algo_newton.ipynb
+++ /dev/null
@@ -1,152 +0,0 @@
-{
- "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": null,
-   "metadata": {},
-   "outputs": [],
-   "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": null,
-   "metadata": {},
-   "outputs": [],
-   "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",
-    "include(\"../test/tester_algo_newton.jl\")\n",
-    "include(\"../src/Algorithme_De_Newton.jl\")\n",
-    "\n",
-    "affiche = false # Mettre affiche = true pour afficher les résultats \n",
-    "\t\t\t\t# des appels à l'algorithme de Newton. Cela peut vous\n",
-    "\t\t\t\t# servir pour les réponses aux questions en fin de notebook.\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": null,
-   "metadata": {},
-   "outputs": [],
-   "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 \n",
-    "$$ f_{1} : \\mathbb{R}^3 \\rightarrow \\mathbb{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$$ \n",
-    "\n",
-    "Justifier que l’algorithme implémenté converge en une itération pour $f_{1}$;\n",
-    "\n",
-    "3. Soit \n",
-    "$$ f_{2} : \\mathbb{R}^2 \\rightarrow \\mathbb{R}$$ $$ (x_1,x_2) \\mapsto 100(x_2-x_1^2)^2 + (1-x_1)^2 $$ \n",
-    "\n",
-    "Justifier que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.\n",
-    "\n",
-    "**Remarque.** Vous pouvez mettre `affiche=true` dans les tests de l'algorithme de Newton pour\n",
-    "vous aider.\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Julia 1.8.2",
-   "language": "julia",
-   "name": "julia-1.8"
-  },
-  "language_info": {
-   "file_extension": ".jl",
-   "mimetype": "application/julia",
-   "name": "julia",
-   "version": "1.8.2"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/src/lagrangien_augmente.ipynb b/src/lagrangien_augmente.ipynb
deleted file mode 100644
index a34e257e3b9470a5d08d7ae1aec8c3c34af47064..0000000000000000000000000000000000000000
--- a/src/lagrangien_augmente.ipynb
+++ /dev/null
@@ -1,586 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<center>\n",
-    "<h1> TP-Projet d'optimisation numérique </h1>\n",
-    "<h1> Algorithme du Lagrangien Augmenté </h1>\n",
-    "</center>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Implémentation\n",
-    "\n",
-    "1. Implémenter l'algorithme du lagrangien augmenté, en utilisant les différentes méthodes\n",
-    "qui ont été vues en première partie pour la résolution de la suite de problémes sans\n",
-    "contraintes (fichier `Lagrangien_Augmente.jl`). La spécification de l'algorithme du Lagrangien augmenté est donnée ci-dessous.\n",
-    " "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/latex": [
-       "\\paragraph{Objet}\n",
-       "Résolution des problèmes de minimisation avec une contrainte d'égalité scalaire par l'algorithme du lagrangien augmenté.\n",
-       "\n",
-       "\\paragraph{Syntaxe}\n",
-       "\\begin{verbatim}\n",
-       "xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)\n",
-       "\\end{verbatim}\n",
-       "\\paragraph{Entrées}\n",
-       "\\begin{itemize}\n",
-       "\\item algo : (String) l'algorithme sans contraintes à utiliser:\n",
-       "\n",
-       "\\begin{itemize}\n",
-       "\\item \"newton\"  : pour l'algorithme de Newton\n",
-       "\n",
-       "\n",
-       "\\item \"cauchy\"  : pour le pas de Cauchy\n",
-       "\n",
-       "\n",
-       "\\item \"gct\"     : pour le gradient conjugué tronqué\n",
-       "\n",
-       "\\end{itemize}\n",
-       "\n",
-       "\\item f : (Function) la fonction à minimiser\n",
-       "\n",
-       "\n",
-       "\\item gradf       : (Function) le gradient de la fonction\n",
-       "\n",
-       "\n",
-       "\\item hessf       : (Function) la hessienne de la fonction\n",
-       "\n",
-       "\n",
-       "\\item c     : (Function) la contrainte [x est dans le domaine des contraintes ssi $c(x)=0$]\n",
-       "\n",
-       "\n",
-       "\\item gradc : (Function) le gradient de la contrainte\n",
-       "\n",
-       "\n",
-       "\\item hessc : (Function) la hessienne de la contrainte\n",
-       "\n",
-       "\n",
-       "\\item x0 : (Array\\{Float,1\\}) la première composante du point de départ du Lagrangien\n",
-       "\n",
-       "\n",
-       "\\item options : (Array\\{Float,1\\})\n",
-       "\n",
-       "\\begin{itemize}\n",
-       "\\item[1. ] epsilon     : utilisé dans les critères d'arrêt\n",
-       "\n",
-       "\n",
-       "\\item[2. ] tol         : la tolérance utilisée dans les critères d'arrêt\n",
-       "\n",
-       "\n",
-       "\\item[3. ] itermax     : nombre maximal d'itération dans la boucle principale\n",
-       "\n",
-       "\n",
-       "\\item[4. ] lambda0     : la deuxième composante du point de départ du Lagrangien\n",
-       "\n",
-       "\n",
-       "\\item[5. ] mu0, tho    : valeurs initiales des variables de l'algorithme\n",
-       "\n",
-       "\\end{itemize}\n",
-       "\\end{itemize}\n",
-       "\\paragraph{Sorties}\n",
-       "\\begin{itemize}\n",
-       "\\item xmin : (Array\\{Float,1\\}) une approximation de la solution du problème avec contraintes\n",
-       "\n",
-       "\n",
-       "\\item fxmin : (Float) $f(x_{min})$\n",
-       "\n",
-       "\n",
-       "\\item flag : (Integer) indicateur du déroulement de l'algorithme\n",
-       "\n",
-       "\\begin{itemize}\n",
-       "\\item 0    : convergence\n",
-       "\n",
-       "\n",
-       "\\item 1    : nombre maximal d'itération atteint\n",
-       "\n",
-       "\n",
-       "\\item (-1) : une erreur s'est produite\n",
-       "\n",
-       "\\end{itemize}\n",
-       "\n",
-       "\\item niters : (Integer) nombre d'itérations réalisées\n",
-       "\n",
-       "\n",
-       "\\item muks : (Array\\{Float64,1\\}) tableau des valeurs prises par mu\\_k au cours de l'exécution\n",
-       "\n",
-       "\n",
-       "\\item lambdaks : (Array\\{Float64,1\\}) tableau des valeurs prises par lambda\\_k au cours de l'exécution\n",
-       "\n",
-       "\\end{itemize}\n",
-       "\\paragraph{Exemple d'appel}\n",
-       "\\begin{verbatim}\n",
-       "using LinearAlgebra\n",
-       "algo = \"gct\" # ou newton|gct\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",
-       "c(x) =  (x[1]^2) + (x[2]^2) -1.5\n",
-       "gradc(x) = [2*x[1] ;2*x[2]]\n",
-       "hessc(x) = [2 0;0 2]\n",
-       "x0 = [1; 0]\n",
-       "options = []\n",
-       "xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)\n",
-       "\\end{verbatim}\n",
-       "\\paragraph{Tolérances des algorithmes appelés}\n",
-       "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.\n",
-       "\n"
-      ],
-      "text/markdown": [
-       "#### Objet\n",
-       "\n",
-       "Résolution des problèmes de minimisation avec une contrainte d'égalité scalaire par l'algorithme du lagrangien augmenté.\n",
-       "\n",
-       "#### Syntaxe\n",
-       "\n",
-       "```julia\n",
-       "xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)\n",
-       "```\n",
-       "\n",
-       "#### Entrées\n",
-       "\n",
-       "  * algo : (String) l'algorithme sans contraintes à utiliser:\n",
-       "\n",
-       "      * \"newton\"  : pour l'algorithme de Newton\n",
-       "      * \"cauchy\"  : pour le pas de Cauchy\n",
-       "      * \"gct\"     : pour le gradient conjugué tronqué\n",
-       "  * f : (Function) la fonction à minimiser\n",
-       "  * gradf       : (Function) le gradient de la fonction\n",
-       "  * hessf       : (Function) la hessienne de la fonction\n",
-       "  * c     : (Function) la contrainte [x est dans le domaine des contraintes ssi $c(x)=0$]\n",
-       "  * gradc : (Function) le gradient de la contrainte\n",
-       "  * hessc : (Function) la hessienne de la contrainte\n",
-       "  * x0 : (Array{Float,1}) la première composante du point de départ du Lagrangien\n",
-       "  * options : (Array{Float,1})\n",
-       "\n",
-       "    1. epsilon     : utilisé dans les critères d'arrêt\n",
-       "    2. tol         : la tolérance utilisée dans les critères d'arrêt\n",
-       "    3. itermax     : nombre maximal d'itération dans la boucle principale\n",
-       "    4. lambda0     : la deuxième composante du point de départ du Lagrangien\n",
-       "    5. mu0, tho    : valeurs initiales des variables de l'algorithme\n",
-       "\n",
-       "#### Sorties\n",
-       "\n",
-       "  * xmin : (Array{Float,1}) une approximation de la solution du problème avec contraintes\n",
-       "  * fxmin : (Float) $f(x_{min})$\n",
-       "  * flag : (Integer) indicateur du déroulement de l'algorithme\n",
-       "\n",
-       "      * 0    : convergence\n",
-       "      * 1    : nombre maximal d'itération atteint\n",
-       "      * (-1) : une erreur s'est produite\n",
-       "  * niters : (Integer) nombre d'itérations réalisées\n",
-       "  * muks : (Array{Float64,1}) tableau des valeurs prises par mu_k au cours de l'exécution\n",
-       "  * lambdaks : (Array{Float64,1}) tableau des valeurs prises par lambda_k au cours de l'exécution\n",
-       "\n",
-       "#### Exemple d'appel\n",
-       "\n",
-       "```julia\n",
-       "using LinearAlgebra\n",
-       "algo = \"gct\" # ou newton|gct\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",
-       "c(x) =  (x[1]^2) + (x[2]^2) -1.5\n",
-       "gradc(x) = [2*x[1] ;2*x[2]]\n",
-       "hessc(x) = [2 0;0 2]\n",
-       "x0 = [1; 0]\n",
-       "options = []\n",
-       "xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)\n",
-       "```\n",
-       "\n",
-       "#### Tolérances des algorithmes appelés\n",
-       "\n",
-       "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.\n"
-      ],
-      "text/plain": [
-       "\u001b[1m  Objet\u001b[22m\n",
-       "\u001b[1m  -------\u001b[22m\n",
-       "\n",
-       "  Résolution des problèmes de minimisation avec une contrainte d'égalité\n",
-       "  scalaire par l'algorithme du lagrangien augmenté.\n",
-       "\n",
-       "\u001b[1m  Syntaxe\u001b[22m\n",
-       "\u001b[1m  ---------\u001b[22m\n",
-       "\n",
-       "\u001b[36m  xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)\u001b[39m\n",
-       "\n",
-       "\u001b[1m  Entrées\u001b[22m\n",
-       "\u001b[1m  ---------\u001b[22m\n",
-       "\n",
-       "    •  algo : (String) l'algorithme sans contraintes à utiliser:\n",
-       "       • \"newton\" : pour l'algorithme de Newton\n",
-       "       • \"cauchy\" : pour le pas de Cauchy\n",
-       "       • \"gct\" : pour le gradient conjugué tronqué\n",
-       "\n",
-       "    •  f : (Function) la fonction à minimiser\n",
-       "\n",
-       "    •  gradf : (Function) le gradient de la fonction\n",
-       "\n",
-       "    •  hessf : (Function) la hessienne de la fonction\n",
-       "\n",
-       "    •  c : (Function) la contrainte [x est dans le domaine des\n",
-       "       contraintes ssi \u001b[35mc(x)=0\u001b[39m]\n",
-       "\n",
-       "    •  gradc : (Function) le gradient de la contrainte\n",
-       "\n",
-       "    •  hessc : (Function) la hessienne de la contrainte\n",
-       "\n",
-       "    •  x0 : (Array{Float,1}) la première composante du point de départ du\n",
-       "       Lagrangien\n",
-       "\n",
-       "    •  options : (Array{Float,1})\n",
-       "       1. epsilon : utilisé dans les critères d'arrêt\n",
-       "       2. tol : la tolérance utilisée dans les critères d'arrêt\n",
-       "       3. itermax : nombre maximal d'itération dans la boucle\n",
-       "       principale\n",
-       "       4. lambda0 : la deuxième composante du point de départ du\n",
-       "       Lagrangien\n",
-       "       5. mu0, tho : valeurs initiales des variables de\n",
-       "       l'algorithme\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 avec contraintes\n",
-       "\n",
-       "    •  fxmin : (Float) \u001b[35mf(x_{min})\u001b[39m\n",
-       "\n",
-       "    •  flag : (Integer) indicateur du déroulement de l'algorithme\n",
-       "       • 0 : convergence\n",
-       "       • 1 : nombre maximal d'itération atteint\n",
-       "       • (-1) : une erreur s'est produite\n",
-       "\n",
-       "    •  niters : (Integer) nombre d'itérations réalisées\n",
-       "\n",
-       "    •  muks : (Array{Float64,1}) tableau des valeurs prises par mu_k au\n",
-       "       cours de l'exécution\n",
-       "\n",
-       "    •  lambdaks : (Array{Float64,1}) tableau des valeurs prises par\n",
-       "       lambda_k au cours de l'exécution\n",
-       "\n",
-       "\u001b[1m  Exemple d'appel\u001b[22m\n",
-       "\u001b[1m  -----------------\u001b[22m\n",
-       "\n",
-       "\u001b[36m  using LinearAlgebra\u001b[39m\n",
-       "\u001b[36m  algo = \"gct\" # ou newton|gct\u001b[39m\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  c(x) =  (x[1]^2) + (x[2]^2) -1.5\u001b[39m\n",
-       "\u001b[36m  gradc(x) = [2*x[1] ;2*x[2]]\u001b[39m\n",
-       "\u001b[36m  hessc(x) = [2 0;0 2]\u001b[39m\n",
-       "\u001b[36m  x0 = [1; 0]\u001b[39m\n",
-       "\u001b[36m  options = []\u001b[39m\n",
-       "\u001b[36m  xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)\u001b[39m\n",
-       "\n",
-       "\u001b[1m  Tolérances des algorithmes appelés\u001b[22m\n",
-       "\u001b[1m  ------------------------------------\u001b[22m\n",
-       "\n",
-       "  Pour les tolérances définies dans les algorithmes appelés (Newton et régions\n",
-       "  de confiance), prendre les tolérances par défaut définies dans ces\n",
-       "  algorithmes."
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "using LinearAlgebra\n",
-    "using Documenter\n",
-    "using Markdown  \n",
-    "include(\"Lagrangien_Augmente.jl\")\n",
-    "@doc Lagrangien_Augmente"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "3. Vérifier que les tests ci-dessous passent."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Avec newton: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:42\u001b[22m\n",
-      "  Expression: isapprox(xmin, sol_fct1_augm, atol = tol_erreur)\n",
-      "   Evaluated: isapprox([0.0, 0.0, 0.0], [0.5, 1.25, 0.5]; atol = 0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:42\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec newton: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:50\u001b[22m\n",
-      "  Expression: ≈(xmin, sol_fct1_augm, atol = tol_erreur)\n",
-      "   Evaluated: [0.0, 0.0, 0.0] ≈ [0.5, 1.25, 0.5] (atol=0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:50\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec newton: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:58\u001b[22m\n",
-      "  Expression: ≈(xmin, sol_fct2_augm, atol = tol_erreur)\n",
-      "   Evaluated: [0.0, 0.0] ≈ [0.9072339605110892, 0.82275545631455] (atol=0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:58\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec newton: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:66\u001b[22m\n",
-      "  Expression: ≈(xmin, sol_fct2_augm, atol = tol_erreur)\n",
-      "   Evaluated: [0.0, 0.0] ≈ [0.9072339605110892, 0.82275545631455] (atol=0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:66\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec gct: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:42\u001b[22m\n",
-      "  Expression: isapprox(xmin, sol_fct1_augm, atol = tol_erreur)\n",
-      "   Evaluated: isapprox([0.0, 0.0, 0.0], [0.5, 1.25, 0.5]; atol = 0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:42\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec gct: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:50\u001b[22m\n",
-      "  Expression: ≈(xmin, sol_fct1_augm, atol = tol_erreur)\n",
-      "   Evaluated: [0.0, 0.0, 0.0] ≈ [0.5, 1.25, 0.5] (atol=0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:50\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec gct: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:58\u001b[22m\n",
-      "  Expression: ≈(xmin, sol_fct2_augm, atol = tol_erreur)\n",
-      "   Evaluated: [0.0, 0.0] ≈ [0.9072339605110892, 0.82275545631455] (atol=0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:58\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec gct: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:66\u001b[22m\n",
-      "  Expression: ≈(xmin, sol_fct2_augm, atol = tol_erreur)\n",
-      "   Evaluated: [0.0, 0.0] ≈ [0.9072339605110892, 0.82275545631455] (atol=0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:66\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec cauchy: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:42\u001b[22m\n",
-      "  Expression: isapprox(xmin, sol_fct1_augm, atol = tol_erreur)\n",
-      "   Evaluated: isapprox([0.0, 0.0, 0.0], [0.5, 1.25, 0.5]; atol = 0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:42\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec cauchy: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:50\u001b[22m\n",
-      "  Expression: ≈(xmin, sol_fct1_augm, atol = tol_erreur)\n",
-      "   Evaluated: [0.0, 0.0, 0.0] ≈ [0.5, 1.25, 0.5] (atol=0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:50\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec cauchy: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:58\u001b[22m\n",
-      "  Expression: ≈(xmin, sol_fct2_augm, atol = tol_erreur)\n",
-      "   Evaluated: [0.0, 0.0] ≈ [0.9072339605110892, 0.82275545631455] (atol=0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:58\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "Avec cauchy: \u001b[91m\u001b[1mTest Failed\u001b[22m\u001b[39m at \u001b[39m\u001b[1m/Users/gergaud/git-ENS/optimisation-numerique/projet-optinum/test/tester_lagrangien_augmente.jl:66\u001b[22m\n",
-      "  Expression: ≈(xmin, sol_fct2_augm, atol = tol_erreur)\n",
-      "   Evaluated: [0.0, 0.0] ≈ [0.9072339605110892, 0.82275545631455] (atol=0.0001)\n",
-      "Stacktrace:\n",
-      " [1] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:66\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [2] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1226\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [3] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [4] \u001b[0m\u001b[1mmacro expansion\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[90m/Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/\u001b[39m\u001b[90;4mTest.jl:1151\u001b[0m\u001b[90m [inlined]\u001b[39m\n",
-      " [5] \u001b[0m\u001b[1mtester_lagrangien_augmente\u001b[22m\u001b[0m\u001b[1m(\u001b[22m\u001b[90mafficher\u001b[39m::\u001b[0mBool, \u001b[90mLagrangien_Augmente\u001b[39m::\u001b[0mtypeof(Lagrangien_Augmente)\u001b[0m\u001b[1m)\u001b[22m\n",
-      "\u001b[90m   @ \u001b[39m\u001b[35mMain\u001b[39m \u001b[90m~/git-ENS/optimisation-numerique/projet-optinum/test/\u001b[39m\u001b[90;4mtester_lagrangien_augmente.jl:35\u001b[0m\n",
-      "\u001b[0m\u001b[1mTest Summary:            | \u001b[22m\u001b[91m\u001b[1mFail  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n",
-      "Test lagrangien augmente | \u001b[91m  12  \u001b[39m\u001b[36m   12\u001b[39m\n",
-      "  Lagrangien augmenté    | \u001b[91m  12  \u001b[39m\u001b[36m   12\u001b[39m\n",
-      "    Avec newton          | \u001b[91m   4  \u001b[39m\u001b[36m    4\u001b[39m\n",
-      "    Avec gct             | \u001b[91m   4  \u001b[39m\u001b[36m    4\u001b[39m\n",
-      "    Avec cauchy          | \u001b[91m   4  \u001b[39m\u001b[36m    4\u001b[39m\n"
-     ]
-    },
-    {
-     "ename": "LoadError",
-     "evalue": "\u001b[91mSome tests did not pass: 0 passed, 12 failed, 0 errored, 0 broken.\u001b[39m",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[91mSome tests did not pass: 0 passed, 12 failed, 0 errored, 0 broken.\u001b[39m",
-      "",
-      "Stacktrace:",
-      " [1] finish(ts::Test.DefaultTestSet)",
-      "   @ Test /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/Test.jl:913",
-      " [2] macro expansion",
-      "   @ /Users/julia/buildbot/worker/package_macos64/build/usr/share/julia/stdlib/v1.6/Test/src/Test.jl:1161 [inlined]",
-      " [3] top-level scope",
-      "   @ In[6]:18",
-      " [4] eval",
-      "   @ ./boot.jl:360 [inlined]",
-      " [5] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
-      "   @ Base ./loading.jl:1116"
-     ]
-    }
-   ],
-   "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",
-    "include(\"../test/tester_lagrangien_augmente.jl\")\n",
-    "include(\"../src/Algorithme_De_Newton.jl\")\n",
-    "include(\"../src/Pas_De_Cauchy.jl\")\n",
-    "include(\"../src/Gradient_Conjugue_Tronque.jl\")\n",
-    "include(\"../src/Regions_De_Confiance.jl\")\n",
-    "include(\"../src/Lagrangien_Augmente.jl\")\n",
-    "\n",
-    "affiche = false\n",
-    "\n",
-    "@testset \"Test lagrangien augmente\" begin\n",
-    "\ttester_lagrangien_augmente(affiche, Lagrangien_Augmente)\n",
-    "end;"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Interprétation\n",
-    "\n",
-    " 1. Commenter les résultats obtenus, en étudiant notamment les valeurs de $\\lambda_k$ et $\\mu_k$.\n",
-    " \n",
-    " 2. Étudier l'influence du paramètre $\\tau$ dans la performance de l'algorithme. Pour cela Vous réaliserez des tests numériques.\n",
-    " \n",
-    " 3. **Supplémentaire** : \n",
-    "      Que proposez-vous comme méthode pour la résolution des problèmes avec\n",
-    "      des contraintes à la fois d'égalité et d'inégalité ? Implémenter (si le temps le permet)\n",
-    "      ce nouvel algorithme."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Julia 1.6.6",
-   "language": "julia",
-   "name": "julia-1.6"
-  },
-  "language_info": {
-   "file_extension": ".jl",
-   "mimetype": "application/julia",
-   "name": "julia",
-   "version": "1.6.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/src/regions_confiance.ipynb b/src/regions_confiance.ipynb
deleted file mode 100644
index f87e1b2f096c0ae9fe5bb4996baa534c7ce73297..0000000000000000000000000000000000000000
--- a/src/regions_confiance.ipynb
+++ /dev/null
@@ -1,262 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "<center>\n",
-    "<h1> TP-Projet d'optimisation numérique </h1>\n",
-    "<h1> Algorithme des Régions de Confiance </h1>\n",
-    "</center>"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Régions de confiance avec Pas de Cauchy \n",
-    "\n",
-    "## Implémentation \n",
-    "\n",
-    "1. Coder l'algorithme du pas de Cauchy d’un sous-problème de\n",
-    "régions de confiance (fichier `Pas_De_Cauchy.jl`). La spécification de cet algorithme est donnée ci-dessous."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Pas_De_Cauchy"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "using LinearAlgebra\n",
-    "using Documenter\n",
-    "using Markdown  \n",
-    "include(\"Pas_De_Cauchy.jl\")\n",
-    "# @doc Pas_De_Cauchy"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "2. Ecrire des tests exhaustifs (qui testent tous les cas de figure possibles) pour votre algorithme du Pas de Cauchy. Vous créerez pour cela un fichier `tester_pas_de_Cauchy.jl` dans le répertoire `test` sur le modèle des autres fichiers de tests et vous exécuterez dans la cellule de code ci-après ces tests."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "3. Coder l'algorithme des Régions de Confiance (fichier `Regions_De_Confiance.jl`). Sa spécification est donnée ci-dessous."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "include(\"Regions_De_Confiance.jl\")\n",
-    "# @doc Regions_De_Confiance"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "4. Vérifier que les tests ci-dessous passent."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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",
-    "include(\"../test/tester_regions_de_confiance.jl\")\n",
-    "include(\"../src/Pas_De_Cauchy.jl\")\n",
-    "include(\"../src/Regions_De_Confiance.jl\")\n",
-    "\n",
-    "affiche = false\n",
-    "\n",
-    "@testset \"Test rc avec cauchy\" begin\n",
-    "\ttester_regions_de_confiance(affiche,Regions_De_Confiance)\n",
-    "end;"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Interprétation \n",
-    "\n",
-    "<!-- Pour ces questions, des représentations graphiques sont attendues pour corroborer vos réponses. -->\n",
-    "\n",
-    "1. 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$$ Quelle relation lie la fonction $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.\n",
-    "\n",
-    "2.  Le rayon initial de la région de confiance est un paramètre important dans l’analyse\n",
-    "de la performance de l’algorithme. Sur quel(s) autre(s) paramètre(s) peut-on jouer\n",
-    "pour essayer d’améliorer cette performance ? Étudier l’influence d’au moins deux de\n",
-    "ces paramètres. Pour cela vous ferez des tests numériques et donnerez les résultats sous forme de tableaux et de graphiques."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Régions de confiance avec Gradient Conjugué\n",
-    "## Implémentation \n",
-    "\n",
-    "1. Implémenter l’algorithme du Gradient Conjugué Tronqué (fichier `Gradient_Conjugue_Tronque.jl`). Sa spécification est donnée ci-dessous."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "include(\"Gradient_Conjugue_Tronque.jl\")\n",
-    "# @doc Gradient_Conjugue_Tronque"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "2. Vérifier que les tests ci-dessous passent."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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",
-    "include(\"../test/tester_gct.jl\")\n",
-    "include(\"../src/Gradient_Conjugue_Tronque.jl\")\n",
-    "\n",
-    "affiche = false\n",
-    "\n",
-    "@testset \"Test gct\" begin\n",
-    "\ttester_gct(affiche,Gradient_Conjugue_Tronque)\n",
-    "end;"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "3. Intégrer l’algorithme du Gradient Conjugué Tronqué dans le code de régions de confiance (fichier `Regions_De_Confiance.jl`).\n",
-    "\n",
-    "4. Décommenter les tests avec le gradient conjugué dans `tester_regions_de_confiance.jl` et vérifier que les tests passent."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "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",
-    "include(\"../test/tester_regions_de_confiance.jl\")\n",
-    "include(\"../src/Pas_De_Cauchy.jl\")\n",
-    "include(\"../src/Gradient_Conjugue_Tronque.jl\")\n",
-    "include(\"../src/Regions_De_Confiance.jl\")\n",
-    "\n",
-    "affiche = false\n",
-    "\n",
-    "@testset \"Test rc avec cauchy et gct\" begin\n",
-    "\ttester_regions_de_confiance(affiche,Regions_De_Confiance)\n",
-    "end;"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Interprétation  \n",
-    "\n",
-    "1. Comparer la décroissance obtenue avec celle du pas de Cauchy, en imposant la sortie\n",
-    "dans l’algorithme au bout d’une itération seulement. Vous donnerez ci-après des résultats numériques. \n",
-    "    1. Que remarquez vous ?\n",
-    "    2. Comparer la décroissance obtenue avec celle du pas de Cauchy dans le cas général.\n",
-    "\n",
-    "3. Quels sont les avantages et inconvénients des deux approches ?"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Julia 1.6.6",
-   "language": "julia",
-   "name": "julia-1.6"
-  },
-  "language_info": {
-   "file_extension": ".jl",
-   "mimetype": "application/julia",
-   "name": "julia",
-   "version": "1.6.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/test/cacher_stacktrace.jl b/test/cacher_stacktrace.jl
deleted file mode 100755
index 658bc0576db1cc935896efa2685bbebdde640506..0000000000000000000000000000000000000000
--- a/test/cacher_stacktrace.jl
+++ /dev/null
@@ -1,24 +0,0 @@
-using Test
-@doc doc"""
-
-Cacher les traces d'appels des tests erronés ou échoués, pour les remettre, décommentez les lignes 11 et 16.
-
-"""
-function cacher_stacktrace()
-    Test.eval(quote
-       function record(ts::DefaultTestSet, t::Union{Fail, Error})
-           if myid() == 1               
-               #printstyled(ts.description, ": ", color=:white) # afficher la description du testset
-               # ne pas afficher pour les tests interrompus
-               if !(t isa Error) || t.test_type != :test_interrupted
-                   # print(t) # afficher le resultat et la solution attendu                    
-                   if !isa(t, Error)
-                       # Base.show_backtrace(stdout, scrub_backtrace(backtrace())) # afficher la trace d'appels
-                   end                   
-               end
-           end
-           push!(ts.results, t)
-           t, isa(t, Error) || backtrace()
-       end
-       end)
-end
diff --git a/test/fonctions_de_tests.jl b/test/fonctions_de_tests.jl
index d568f43cd1e1282d9c68ff2a6c7eef8cff6b864f..c9b96df6a14eb22b3c393699f7ed34973d3345d6 100755
--- a/test/fonctions_de_tests.jl
+++ b/test/fonctions_de_tests.jl
@@ -1,8 +1,8 @@
 """
 Ce fichier contient toutes fonctions utilisés dans les tests des algorithmes :
-        - L'algorithme de Newton
-        - Les régions de confiance
-        - Le Lagrangien augmenté
+    - L'algorithme de Newton
+    - Les régions de confiance
+    - Le Lagrangien augmenté
 
 """
 # Les points initiaux
@@ -97,12 +97,13 @@ grad_contrainte2(x) = [2*x[1] ;2*x[2]]
 hess_contrainte2(x) = [2 0;0 2]
 
 # Affichage les sorties de l'algorithme des Régions de confiance
-function 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)
+function afficher_resultats(algo, nom_fct, x0, x_sol, f_sol, flag, nbiters, solution)
+    println("-------------------------------------------------------------------------")
+    printstyled("Résultats de : ",algo, " appliqué à ", nom_fct, ":\n", bold=true, color=:blue)
+    println("  * x0       = ", x0)
+    println("  * x_sol    = ", x_sol)
+    println("  * f(x_sol) = ", f_sol)
+    println("  * nb_iters = ", nbiters)
+    println("  * flag     = ", flag)
+    println("  * solution = ", solution)
 end
diff --git a/test/new_runtests.jl b/test/new_runtests.jl
deleted file mode 100644
index 433737b8990ca22747649e8e3c838f6abf6e276c..0000000000000000000000000000000000000000
--- a/test/new_runtests.jl
+++ /dev/null
@@ -1,49 +0,0 @@
-using Markdown
-using Test
-using LinearAlgebra
-
-include("../src/Algorithme_De_Newton.jl")
-include("../src/Gradient_Conjugue_Tronque.jl")
-include("../src/Lagrangien_Augmente.jl")
-include("../src/Pas_De_Cauchy.jl")#
-include("../src/Regions_De_Confiance.jl")
-
-#include("cacher_stacktrace.jl")
-#cacher_stacktrace()
-
-
-# Tolérance pour les tests d'égalité
-tol_erreur = sqrt(eps())
-
-## ajouter les fonctions de test
-include("./fonctions_de_tests.jl")
-
-include("./tester_algo_newton.jl")
-
-include("tester_pas_de_cauchy.jl")
-#
-include("tester_gct.jl")
-
-include("tester_regions_de_confiance.jl")
-
-include("tester_lagrangien_augmente.jl")
-
-affiche = true
-println("affiche = ",affiche)
-# Tester l'ensemble des algorithmes
-@testset "Test SujetOptinum" begin
-	# Tester l'algorithme de Newton
-	tester_algo_newton(affiche,Algorithme_De_Newton)
-
-	# Tester l'algorithme du pas de Cauchy
-	tester_pas_de_cauchy(affiche,Pas_De_Cauchy)
-
-	# Tester l'algorithme du gradient conjugué tronqué
-	tester_gct(affiche,Gradient_Conjugue_Tronque)
-
-	# Tester l'algorithme des Régions de confiance avec PasdeCauchy | GCT
-	tester_regions_de_confiance(affiche,Regions_De_Confiance)
-
-	# Tester l'algorithme du Lagrangien Augmenté
-	tester_lagrangien_augmente(affiche,Lagrangien_Augmente)
-end
diff --git a/test/tester_algo_newton.jl b/test/tester_algo_newton.jl
deleted file mode 100755
index fdaa7244349b7016a471f266f43dee15f471281b..0000000000000000000000000000000000000000
--- a/test/tester_algo_newton.jl
+++ /dev/null
@@ -1,133 +0,0 @@
-@doc doc"""
-Tester l'algorithme de Newton local
-
-# Entrées :
-   * afficher : (Bool) affichage ou non des résultats de chaque test
-
-# Les cas de test (dans l'ordre)
-   * fct 1 : x011, x012
-   * fct 2 : x021, x022, x023
-"""
-function tester_algo_newton(afficher::Bool, Algorithme_De_Newton::Function)
-    max_iter = 100
-    Tol_abs = sqrt(eps())
-    Tol_rel = 1e-15
-    epsilon = 1.0
-    options = [max_iter, Tol_abs, Tol_rel, epsilon]
-    @testset "L'algo de Newton" begin
-        @testset "Cas test 1 x0 = solution" begin
-            # point de départ x011
-            x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, sol_exacte_fct1, options)
-            if (afficher)
-                afficher_resultats("algorithme de Newton ", "fct1", "x011", x_min, fx_min, flag, sol_exacte_fct1, nb_iters)
-            end
-            @testset "solution" begin
-                @test isapprox(x_min, sol_exacte_fct1, atol=tol_erreur)
-            end
-            @testset "itération" begin
-                @test nb_iters == 0
-            end
-            @testset "flag" begin
-                @test flag == 0
-            end
-        end
-        @testset "Cas test 1 x0 = x011" begin
-            #point de départ x011
-            x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, pts1.x011, options)
-            if (afficher)
-                afficher_resultats("algorithme de Newton ", "fct1", "x011", x_min, fx_min, flag, sol_exacte_fct1, nb_iters)
-            end
-            @testset "solution" begin
-                @test isapprox(x_min, sol_exacte_fct1, atol=tol_erreur)
-            end
-            @testset "itération" begin
-                @test nb_iters == 1
-            end
-            @testset "flag" begin
-                @test flag == 0
-            end
-        end
-        @testset "Cas test 1 x0 = x012" begin
-            x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, pts1.x012, options)
-            if (afficher)
-                afficher_resultats("algorithme de Newton ", "fct1", "x012", x_min, fx_min, flag, sol_exacte_fct1, nb_iters)
-            end
-            @testset "solution" begin
-                @test x_min ≈ sol_exacte_fct1 atol = tol_erreur
-            end
-            @testset "itération" begin
-                @test nb_iters == 1
-            end
-            @testset "flag" begin
-                @test flag == 0
-            end
-        end
-        @testset "Cas test 2 x0 = solution" begin
-            x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, sol_exacte_fct1, options)
-            if (afficher)
-                afficher_resultats("algorithme de Newton ", "fct1", "x011", x_min, fx_min, flag, sol_exacte_fct1, nb_iters)
-            end
-            @testset "solution" begin
-                @test isapprox(x_min, sol_exacte_fct1, atol=tol_erreur)
-            end
-            @testset "itération" begin
-                @test nb_iters == 0
-            end
-            @testset "flag" begin
-                @test flag == 0
-            end
-        end
-        @testset "Cas test 2 x0 = x021" begin
-            x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, pts1.x021, options)
-            if (afficher)
-                afficher_resultats("algorithme de Newton ", "fct2", "x021", x_min, fx_min, flag, sol_exacte_fct2, nb_iters)
-            end
-            @testset "solution" begin
-                @test x_min ≈ sol_exacte_fct2 atol = tol_erreur
-            end
-            @testset "itération" begin
-                @test nb_iters == 6
-            end
-            @testset "flag" begin
-                @test flag == 0
-            end
-        end
-        @testset "Cas test 2 x0 = x022" begin
-            x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, pts1.x022, options)
-            if (afficher)
-                afficher_resultats("algorithme de Newton ", "fct2", "x022", x_min, fx_min, flag, sol_exacte_fct2, nb_iters)
-            end
-            @testset "solution" begin
-                @test x_min ≈ sol_exacte_fct2 atol = tol_erreur
-            end
-            @testset "itération" begin
-                @test nb_iters == 5
-            end
-            @testset "flag" begin
-                @test flag == 0
-            end
-        end
-
-        @testset "Cas test 2 x0 = x023" begin
-            options[1] = 1
-            sol = [-4.99999958629818e9, 8.673617379884035e-19]
-            x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, pts1.x023, options)
-            if (afficher)
-                afficher_resultats("algorithme de Newton ", "fct2", "x023", x_min, fx_min, flag, sol_exacte_fct2, nb_iters)
-            end
-            @testset "solution" begin
-                @test x_min ≈ sol atol = tol_erreur
-            end
-            @testset "flag" begin
-                @test flag == 3
-            end
-            @testset "itération" begin
-                @test nb_iters == 1
-            end
-            @testset "exception" begin
-                options[1] = 100
-                @test_throws SingularException x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, pts1.x023, options)
-            end
-        end
-    end
-end
diff --git a/test/tester_gct.jl b/test/tester_gct.jl
index 5549a89285635fa13ca6971b685c203022761367..ea76a6a15264088db356616414bea66024df37c7 100755
--- a/test/tester_gct.jl
+++ b/test/tester_gct.jl
@@ -1,87 +1,72 @@
-@doc doc"""
-Tester l'algorithme du gradient conjugué tronqué
+using Test
 
-# Entrées :
-   * afficher : (Bool) affichage ou non des résultats de chaque test
+"""
+Tester l'algorithme du gient conjugué tronqué
 
 # Les cas de test (dans l'ordre)
-   * la quadratique 1
-   * la quadratique 2
-   * la quadratique 3
-   * la quadratique 4
-   * la quadratique 5
-   * la quadratique 6
+
+    - la quadratique 1
+    - la quadratique 2
+    - la quadratique 3
+    - la quadratique 4
+    - la quadratique 5
+    - la quadratique 6
+    
 """
-function tester_gct(afficher::Bool,Gradient_Conjugue_Tronque::Function)
+function tester_gct(gct::Function)
 
-    tol = 1e-7
-    max_iter = 100
     # Tolérance utilisé dans les tests
     tol_test = 1e-3
 
-    @testset "Gradient-CT" begin
+    @testset "Gradient conjugué tronqué" begin
         # le cas de test 1
-        grad = [0 ; 0]
-        Hess = [7 0 ; 0 2]
-        delta = 1
-        s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
+        g = [0 ; 0]
+        H = [7 0 ; 0 2]
+        Δ = 1
+        s = gct(g,H,Δ)
         @test  s ≈ [0.0 ; 0.0] atol = tol_test
 
         # le cas de test 2 H definie positive
-        grad = [6 ; 2]
-        Hess = [7 0 ; 0 2]
-        delta = 0.5       # sol = pas de Cauchy  
-        s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
-        @test  s ≈ -delta*grad/norm(grad) atol = tol_test
-        delta = 1.2       # saturation à la 2ieme itération  
-        s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
+        g = [6 ; 2]
+        H = [7 0 ; 0 2]
+        Δ = 0.5       # sol = pas de Cauchy  
+        s = gct(g,H,Δ)
+        @test  s ≈ -Δ*g/norm(g) atol = tol_test
+        Δ = 1.2       # saturation à la 2ieme itération  
+        s = gct(g,H,Δ)
         @test  s ≈ [-0.8740776099190263, -0.8221850958502244] atol = tol_test
-        delta = 3         # sol = min global  
-        s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
-        @test  s ≈ -Hess\grad atol = tol_test
+        Δ = 3         # sol = min global  
+        s = gct(g,H,Δ)
+        @test  s ≈ -H\g atol = tol_test
 
         # le cas test 2 bis matrice avec 1 vp < 0 et 1 vp > 0
-        grad = [1,2]
-        Hess = [1 0 ; 0 -1]
-        delta = 1.       # g^T H g < 0 première direction concave
-        s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
-        @test  s ≈ -delta*grad/norm(grad) atol = tol_test
-        grad = [1,0]
-        delta = 0.5       #  g^T H g > 0 sol pas de Cauchy
-        s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
-        @test  s ≈ -delta*grad/norm(grad) atol = tol_test
-        grad = [2,1]        #  g^T H g > 0 sol à l'itération 2, saturation
-        delta = 6
-        s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
+        g = [1,2]
+        H = [1 0 ; 0 -1]
+        Δ = 1.       # g^T H g < 0 première direction concave
+        s = gct(g,H,Δ)
+        @test  s ≈ -Δ*g/norm(g) atol = tol_test
+        g = [1,0]
+        Δ = 0.5       #  g^T H g > 0 sol pas de Cauchy
+        s = gct(g,H,Δ)
+        @test  s ≈ -Δ*g/norm(g) atol = tol_test
+        g = [2,1]        #  g^T H g > 0 sol à l'itération 2, saturation
+        Δ = 6
+        s = gct(g,H,Δ)
         @test  isapprox(s, [0.48997991959774634, 5.979959839195494], atol = tol_test) || isapprox(s, [-4.489979919597747, -3.979959839195493], atol = tol_test)
-        
-        # le cas de test 3
-        #grad = [-2 ; 1]
-        #Hess = [-2 0 ; 0 10]
-        #delta = 10
-        #s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
-        #@test  s ≈ [9.102342582478453; -4.140937032991381] atol = tol_test
-
-        # le cas de test 4
-        #grad = [0 ; 0]
-        #Hess = [-2 0 ; 0 10]
-        #delta = 1
-        #s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
-        #@test  s ≈ [0.0 ; 0.0]  atol = tol_test
 
         # le cas de test 5
-        grad = [2 ; 3]
-        Hess = [4 6 ; 6 5]
-        delta = 3
-        s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
+        g = [2 ; 3]
+        H = [4 6 ; 6 5]
+        Δ = 3
+        s = gct(g,H,Δ)
         @test  s ≈ [1.9059020876695578 ; -2.3167946029410595] atol = tol_test
 
         # le cas de test 6
-        # Le pas de Cauchy conduit à un gradient nul en 1 itération
-        grad = [2 ; 0]
-        Hess = [4 0 ; 0 -15]
-        delta = 2
-        s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
+        # Le pas de Cauchy conduit à un gient nul en 1 itération
+        g = [2 ; 0]
+        H = [4 0 ; 0 -15]
+        Δ = 2
+        s = gct(g,H,Δ)
         @test  s ≈ [-0.5 ; 0.0] atol = tol_test
     end
 end
diff --git a/test/tester_lagrangien_augmente.jl b/test/tester_lagrangien_augmente.jl
index ea6cf50b880a4461fb9c0fb903d91ac55929b887..30db9d2aa809635dc4a83683c5dd612b6dddd8e3 100755
--- a/test/tester_lagrangien_augmente.jl
+++ b/test/tester_lagrangien_augmente.jl
@@ -1,69 +1,85 @@
-@doc doc"""
-Tester l'algorithme du Lagrangien augmenté
+using Test
+include("../test/fonctions_de_tests.jl")
 
-# Entrées :
-   * affichage : (Bool) affichage ou non des résultats de chaque test
+"""
+Tester l'algorithme du lagrangien augmenté
+
+# Entrées
+
+	- afficher : (Bool) affichage ou non des résultats de chaque test
 
 # Les cas de test (dans l'ordre)
-   * Newton 
-      * fct1 : x01, x02
-	  * fct2 : x03, x04
-   * gct
-      * fct1 : x01, x02
-	  * fct2 : x03, x04
-   * Cauchy
-      * fct1 : x01, x02
-      * fct2 : x03, x04  
+
+	- Newton 
+    	• fct1 : x01, x02
+	  	• fct2 : x03, x04
+  	- gct
+      	• fct1 : x01, x02
+	  	• fct2 : x03, x04
+	- Cauchy
+		• fct1 : x01, x02
+    	• fct2 : x03, x04
+
 """
-function tester_lagrangien_augmente(afficher::Bool,Lagrangien_Augmente::Function)
+function tester_lagrangien_augmente(LA::Function, afficher::Bool)
+
+    println("Affichage des résultats des algorithmes : ", afficher, "\n")
 
-	# initialisation des paramètres
-	lambda0 = 2
-	mu0 = 10
-	tho = 2
-	epsilon = 1.
-	tol = 1e-5
-	max_iters = 1000
-	options = [epsilon, tol, max_iters, lambda0, mu0, tho]
 	# La tolérance utilisée dans les tests
 	tol_erreur = 1e-4
+
+	# initialisation des paramètres
+	tol = 1e-5 # tol_abs et tol_rel
 	
 	# Les trois algorithmes d'optimisations sans contraintes utlisés
-	algos = ["newton", "gct", "cauchy"]
+	algos = ["newton", "rc-cauchy", "rc-gct"]
+
+	#
+	f1 = fct1; gf1 = grad_fct1; Hf1 = hess_fct1; c1 = contrainte1; gc1 = grad_contrainte1; Hc1 = hess_contrainte1
+	f2 = fct2; gf2 = grad_fct2; Hf2 = hess_fct2; c2 = contrainte2; gc2 = grad_contrainte2; Hc2 = hess_contrainte2
+	x01 = pts2.x01
+	x02 = pts2.x02
+	x03 = pts2.x03
+	x04 = pts2.x04
+
+	@testset "Lagrangien augmenté  " begin 	
+
+		@testset "Avec $algo" for algo in algos
 
-	@testset "Lagrangien augmenté  " begin 					
-		@testset "Avec $algo" for algo in algos									
 			# le cas de test 1
-			xmin,fxmin,flag,nbiters = Lagrangien_Augmente(algo,fct1,contrainte1,grad_fct1,hess_fct1,grad_contrainte1,
-			hess_contrainte1,pts2.x01,options)
+			x0 = x01
+			x_sol, f_sol, flag, nb_iters, _ = LA(f1, gf1, Hf1, c1, gc1, Hc1, x0, tol_abs=tol, tol_rel=tol, algo_noc=algo)
 			if (afficher)
-				afficher_resultats("Lagrangien augmenté avec "*algo,"fonction 1","x01",xmin,fxmin,flag,sol_fct1_augm,nbiters)
+				afficher_resultats("LA et " * algo, "f1", x0, x_sol, f_sol, flag, nb_iters, sol_fct1_augm)
 			end
-			@test isapprox(xmin,sol_fct1_augm ,atol=tol_erreur)
+			@test x_sol ≈ sol_fct1_augm atol=tol_erreur
 
 			# le cas de test 2
-			xmin ,fxmin,flag,nbiters = Lagrangien_Augmente(algo,fct1,contrainte1,grad_fct1,hess_fct1,grad_contrainte1,
-			hess_contrainte1,pts2.x02,options)
+			x0 = x02
+			x_sol, f_sol, flag, nb_iters, _ = LA(f1, gf1, Hf1, c1, gc1, Hc1, x0, tol_abs=tol, tol_rel=tol, algo_noc=algo)
 			if (afficher)
-				afficher_resultats("Lagrangien augmenté avec "*algo,"fonction 1","x02",xmin,fxmin,flag,sol_fct1_augm,nbiters)
+				afficher_resultats("LA et " * algo, "f1", x0, x_sol, f_sol, flag, nb_iters, sol_fct1_augm)
 			end
-			@test xmin ≈ sol_fct1_augm atol=tol_erreur
+			@test x_sol ≈ sol_fct1_augm atol=tol_erreur
 
 			# le cas de test 3
-			xmin,fxmin,flag,nbiters = Lagrangien_Augmente(algo,fct2,contrainte2,grad_fct2,hess_fct2,grad_contrainte2,
-			hess_contrainte2,pts2.x03,options)
+			x0 = x03
+			x_sol, f_sol, flag, nb_iters, _ = LA(f2, gf2, Hf2, c2, gc2, Hc2, x0, tol_abs=tol, tol_rel=tol, algo_noc=algo)
 			if (afficher)
-				afficher_resultats("Lagrangien augmenté avec "*algo,"fonction 2","x03",xmin,fxmin,flag,sol_fct2_augm,nbiters)
+				afficher_resultats("LA et " * algo, "f2", x0, x_sol, f_sol, flag, nb_iters, sol_fct2_augm)
 			end
-			@test xmin ≈ sol_fct2_augm atol=tol_erreur
+			@test x_sol ≈ sol_fct2_augm atol=tol_erreur
 
 			# le cas de test 4
-			xmin ,fxmin,flag,nbiters = Lagrangien_Augmente(algo,fct2,contrainte2,grad_fct2,hess_fct2,grad_contrainte2,
-			hess_contrainte2,pts2.x04,options)
+			x0 = x04
+			x_sol, f_sol, flag, nb_iters, _ = LA(f2, gf2, Hf2, c2, gc2, Hc2, x0, tol_abs=tol, tol_rel=tol, algo_noc=algo)
 			if (afficher)
-				afficher_resultats("Lagrangien augmenté avec "*algo,"fonction 2","x04",xmin,fxmin,flag,sol_fct2_augm,nbiters)
+				afficher_resultats("LA et " * algo, "f2", x0, x_sol, f_sol, flag, nb_iters, sol_fct2_augm)
 			end
-			@test xmin ≈ sol_fct2_augm atol=tol_erreur
+			@test x_sol ≈ sol_fct2_augm atol=tol_erreur
+
 		end
+
 	end
+
 end
diff --git a/test/tester_regions_de_confiance.jl b/test/tester_regions_de_confiance.jl
deleted file mode 100755
index efb5eb65781636cd6956fc980662c758e864f3f2..0000000000000000000000000000000000000000
--- a/test/tester_regions_de_confiance.jl
+++ /dev/null
@@ -1,140 +0,0 @@
-@doc doc"""
-Tester l'algorithme des régions de confiance
-
-# Entrées :
-   * affichage : (Bool) affichage ou non des résultats de chaque test
-
-# les cas de test (dans l'ordre)
-   * avec Cauchy :
-	   - fct 1 : x011,x012
-	   - fct 2 : x021,x022,x023
-   * avec gct :
-       - fct 1 : x011,x012
-       - fct 2 : x021,x022,x023
-"""
-function tester_regions_de_confiance(afficher::Bool,Regions_De_Confiance::Function)
-
-	# La tolérance utilisée dans les tests
-	tol_erreur = 1e-2
-	# initialisation des variables de l'algorithme
-	gamma1 = 0.5
-	gamma2 = 2.00
-	eta1 = 0.25
-	eta2 = 0.75
-	deltaMax = 10
-	Tol_abs = sqrt(eps())
-	Tol_rel = 1e-8
-    epsilon = 1
-	maxits = 5000
-	delta0_1 = 2
-	delta0_2 = 2
-	options1 =[deltaMax,gamma1,gamma2,eta1,eta2,delta0_1,maxits,Tol_abs,Tol_rel,epsilon]
-	options2 =[deltaMax,gamma1,gamma2,eta1,eta2,delta0_2,maxits,Tol_abs,Tol_rel,epsilon]
-
-	# l'ensemble de tests
-	@testset "La méthode des RC " begin
-		###################################################
-		#	les tests avec le pas de Cauchy 			  #
-		###################################################
-		# Un premier sous-ensemble de tests
-		@testset "avec Cauchy " begin
-			# cas de test 1
-			x_min11, fmin11, flag11, nb_iters11 = Regions_De_Confiance("cauchy",fct1,grad_fct1,hess_fct1,pts1.x011,options1)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"cauchy","fonction 1","x011",x_min11,fmin11, flag11,sol_exacte_fct1,nb_iters11)
-			end
-			@test isapprox(x_min11,sol_exacte_fct1 ,atol=tol_erreur)
-			@test flag11 == 2
-			@test nb_iters11 == 26
-
-			# cas de test 2
-			x_min12, fmin12, flag12, nb_iters12  = Regions_De_Confiance("cauchy",fct1,grad_fct1,hess_fct1,pts1.x012,options1)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"cauchy","fonction 1","x012",x_min12,fmin12, flag11,sol_exacte_fct1,nb_iters12)
-			end
-			@test x_min12 ≈ sol_exacte_fct1 atol=tol_erreur
-			@test flag12 == 2
-			@test nb_iters12 == 28
-
-			# cas de test 3
-			x_min21, fmin21, flag21, nb_iters21,  = Regions_De_Confiance("cauchy",fct2,grad_fct2,hess_fct2,pts1.x021,options2)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"cauchy","fonction 2","x021",x_min21,fmin21, flag21,sol_exacte_fct2,nb_iters21)
-			end
-			@test x_min21 ≈ sol_exacte_fct2 atol=tol_erreur
-			@test flag21 == 2
-			@test nb_iters21 == 3988
-
-			# cas de test 4
-			x_min22, fmin22, flag22, nb_iters22 = Regions_De_Confiance("cauchy",fct2,grad_fct2,hess_fct2,pts1.x022,options2)
-			println("iters = ", nb_iters22)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"cauchy","fonction 2","x022",x_min22,fmin22, flag22,sol_exacte_fct2,nb_iters22)
-			end
-			@test x_min22 ≈ sol_exacte_fct2 atol=tol_erreur
-			@test flag22 == 0
-			@test nb_iters22 == 864
-
-			# cas de test 5
-			x_min23, fmin23, flag23, nb_iters23 = Regions_De_Confiance("cauchy",fct2,grad_fct2,hess_fct2,pts1.x023,options2)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"cauchy","fonction 2","x023",x_min23,fmin23, flag23,sol_exacte_fct2,nb_iters23)
-			end
-			@test x_min23 ≈ sol_exacte_fct2 atol=tol_erreur
-			@test flag23 == 2
-			@test nb_iters23 == 3198
-		end
-
-		###################################################
-		#	les tests avec le gradient conjugué tronqué   #
-		###################################################
-		# Un deuxième sous-ensemble de tests
-		#= @testset "avec GCT " begin
-			# cas de test 1
-			x_min11, fmin11, flag11, nb_iters11= Regions_De_Confiance("gct",fct1,grad_fct1,hess_fct1,pts1.x011,options1)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"gct","fonction 1","x011",x_min11,fmin11, flag11,sol_exacte_fct1,nb_iters11)
-			end
-			@test isapprox(x_min11,sol_exacte_fct1 ,atol=tol_erreur)
-			@test flag11 == 0
-			@test nb_iters11 == 1
-
-			# cas de test 2
-			x_min12, fmin12, flag12, nb_iters12 = Regions_De_Confiance("gct",fct1,grad_fct1,hess_fct1,pts1.x012,options1)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"gct","fonction 1","x012",x_min12,fmin12, flag12,sol_exacte_fct1,nb_iters12)
-			end
-			@test x_min12 ≈ sol_exacte_fct1 atol=tol_erreur
-			@test flag12 == 0
-			@test nb_iters12 == 3
-
-			# cas de test 3
-			x_min21, fmin21, flag21, nb_iters21 = Regions_De_Confiance("gct",fct2,grad_fct2,hess_fct2,pts1.x021,options2)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"gct","fonction 2","x021",x_min21,fmin21, flag21,sol_exacte_fct2,nb_iters21)
-			end
-			@test x_min21 ≈ sol_exacte_fct2 atol=tol_erreur
-			@test flag21 == 0
-			@test nb_iters21 == 31
-			
-
-			# cas de test 4
-			x_min22, fmin22, flag22, nb_iters22 = Regions_De_Confiance("gct",fct2,grad_fct2,hess_fct2,pts1.x022,options2)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"gct","fonction 2","x022",x_min22,fmin22, flag22,sol_exacte_fct2,nb_iters22)
-			end
-			@test x_min22 ≈ sol_exacte_fct2 atol=tol_erreur
-			@test flag22 == 0
-			@test nb_iters22 == 44
-
-			# cas de test 5
-			x_min23, fmin23, flag23, nb_iters23 = Regions_De_Confiance("gct",fct2,grad_fct2,hess_fct2,pts1.x023,options2)
-			if (afficher)
-				afficher_resultats("régions de confiance avec "*"gct","fonction 2","x023",x_min11,fmin23, flag23,sol_exacte_fct2,nb_iters23)
-			end
-			@test x_min23 ≈ sol_exacte_fct2 atol=tol_erreur
-			@test flag23 == 0
-			@test nb_iters23 == 19
-        end =#
-	end
-end