diff --git a/notebooks/lagrangien_augmente.ipynb b/notebooks/lagrangien_augmente.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..507a33d49914dd225d4defb92519ae7aaa52c39c
--- /dev/null
+++ b/notebooks/lagrangien_augmente.ipynb
@@ -0,0 +1,78 @@
+{
+ "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 `src/lagrangien_augmente.jl`). La spécification est donnée dans le fichier.\n",
+    "2. Vérifier que les tests ci-dessous passent.\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "include(\"../src/lagrangien_augmente.jl\")\n",
+    "include(\"../test/tester_lagrangien_augmente.jl\")\n",
+    "\n",
+    "#\n",
+    "afficher = false # si true, alors affiche les résultats des algorithmes\n",
+    "\n",
+    "#\n",
+    "tester_lagrangien_augmente(lagrangien_augmente, afficher);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Interprétation\n",
+    "\n",
+    " 1. Commenter les résultats obtenus, en étudiant notamment les valeurs en sortie de $\\lambda_k$ et $\\mu_k$.\n",
+    " 2. Étudier l'influence du paramètre $\\tau$ dans la performance de l'algorithme. Pour cela Vous réaliserez des tests numériques."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Expérimentations numériques à faire ici.\n",
+    "# Vous pouvez utiliser le package Plots pour les affichages de courbes: using Plots"
+   ]
+  }
+ ],
+ "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/notebooks/newton.ipynb b/notebooks/newton.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..5ccb61f56b6ec00c4cb96191e1bf286e9e227670
--- /dev/null
+++ b/notebooks/newton.ipynb
@@ -0,0 +1,160 @@
+{
+ "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 dans le fichier `src/newton.jl` en respectant la spécification donnée dans ce même fichier ;\n",
+    "2. Exécuter les tests ci-dessous et vérifier qu'ils passent.\n",
+    "\n",
+    "Pour les tests, nous avons défini les fonctions suivantes $f_1 \\colon \\mathbb{R}^3 \\to \\mathbb{R}$\n",
+    "et $f_2 \\colon \\mathbb{R}^2 \\to \\mathbb{R}$.\n",
+    "\n",
+    "$$\n",
+    "    f_{1}(x_1, x_2, x_3) = 2 (x_1 +x_2 + x_3 -3)^2 + (x_1-x_2)^2 + (x_2 - x_3)^2\n",
+    "$$\n",
+    "et\n",
+    "$$\n",
+    "    f_{2}(x_1,x_2) = 100(x_2-x_1^2)^2 + (1-x_1)^2.\n",
+    "$$\n",
+    "\n",
+    "**Remarque.** On peut retrouver ces fonctions dans le fichier `test/fonctions_de_tests.jl`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Affichage des résultats des algorithmes : false\n",
+      "\n",
+      "\u001b[0m\u001b[1mTest Summary:        | \u001b[22m\u001b[32m\u001b[1mPass  \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal  \u001b[22m\u001b[39m\u001b[0m\u001b[1mTime\u001b[22m\n",
+      "algorithme de Newton | \u001b[32m  19  \u001b[39m\u001b[36m   19  \u001b[39m\u001b[0m0.6s\n"
+     ]
+    }
+   ],
+   "source": [
+    "include(\"../src/newton.jl\")         # votre algorithme de Newton\n",
+    "include(\"../test/tester_newton.jl\") # la fonction pour tester votre algorithme de Newton\n",
+    "\n",
+    "#\n",
+    "afficher = false # si true, alors affiche les résultats des algorithmes\n",
+    "\n",
+    "#\n",
+    "tester_newton(newton, afficher); # tester l'algorithme de Newton"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "-------------------------------------------------------------------------\n",
+      "\u001b[34m\u001b[1mRésultats de : Newton appliqué à f0:\u001b[22m\u001b[39m\n",
+      "  * x0       = -1.5707963267948966\n",
+      "  * x_sol    = -1.5707963267948966\n",
+      "  * f(x_sol) = -1.0\n",
+      "  * nb_iters = 0\n",
+      "  * flag     = 0\n",
+      "  * solution = -1.5707963267948966\n",
+      "-------------------------------------------------------------------------\n",
+      "\u001b[34m\u001b[1mRésultats de : Newton appliqué à f0:\u001b[22m\u001b[39m\n",
+      "  * x0       = -1.0707963267948966\n",
+      "  * x_sol    = -1.5707963267949088\n",
+      "  * f(x_sol) = -1.0\n",
+      "  * nb_iters = 3\n",
+      "  * flag     = 0\n",
+      "  * solution = -1.5707963267948966\n",
+      "-------------------------------------------------------------------------\n",
+      "\u001b[34m\u001b[1mRésultats de : Newton appliqué à f0:\u001b[22m\u001b[39m\n",
+      "  * x0       = 1.5707963267948966\n",
+      "  * x_sol    = 1.5707963267948966\n",
+      "  * f(x_sol) = 1.0\n",
+      "  * nb_iters = 0\n",
+      "  * flag     = 0\n",
+      "  * solution = -1.5707963267948966\n"
+     ]
+    }
+   ],
+   "source": [
+    "include(\"../src/newton.jl\") # votre algorithme de Newton\n",
+    "include(\"../test/fonctions_de_tests.jl\") # pour avoir la fonction d'affichage des résultats\n",
+    "\n",
+    "# Fonction f0\n",
+    "# -----------\n",
+    "f0(x)      =  sin(x)\n",
+    "grad_f0(x) =  cos(x) # la gradient de la fonction f0\n",
+    "hess_f0(x) = -sin(x) # la hessienne de la fonction f0\n",
+    "solution   = -pi/2\n",
+    "\n",
+    "x0 = solution\n",
+    "x_sol, f_sol, flag, nb_iters = newton(f0, grad_f0, hess_f0, x0)\n",
+    "afficher_resultats(\"Newton\", \"f0\", x0, x_sol, f_sol, flag, nb_iters, solution)\n",
+    "\n",
+    "x0 = -pi/2+0.5\n",
+    "x_sol, f_sol, flag, nb_iters = newton(f0, grad_f0, hess_f0, x0)\n",
+    "afficher_resultats(\"Newton\", \"f0\", x0, x_sol, f_sol, flag, nb_iters, solution)\n",
+    "\n",
+    "x0 = pi/2\n",
+    "x_sol, f_sol, flag, nb_iters = newton(f0, grad_f0, hess_f0, x0)\n",
+    "afficher_resultats(\"Newton\", \"f0\", x0, x_sol, f_sol, flag, nb_iters, solution)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Interprétation \n",
+    "\n",
+    "1. Justifier les résultats obtenus pour l'exemple $f_0$ ci-dessus;\n",
+    "2. Justifier que l’algorithme implémenté converge en une itération pour $f_{1}$;\n",
+    "3. 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"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Julia 1.8.3",
+   "language": "julia",
+   "name": "julia-1.8"
+  },
+  "language_info": {
+   "file_extension": ".jl",
+   "mimetype": "application/julia",
+   "name": "julia",
+   "version": "1.8.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/notebooks/regions_de_confiance.ipynb b/notebooks/regions_de_confiance.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..8185931f7c579dd20b71e8a0e6ac9dd3cd4cfcd3
--- /dev/null
+++ b/notebooks/regions_de_confiance.ipynb
@@ -0,0 +1,187 @@
+{
+ "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 dans le fichier `src/cauchy.jl`). La spécification de cet algorithme est donnée dans le fichier.\n",
+    "2. Ecrire des tests exhaustifs (qui testent tous les cas de figure possibles) pour votre algorithme du pas de Cauchy. Vous remplirez pour cela le fichier `test/tester_cauchy.jl` 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": [
+    "include(\"../src/cauchy.jl\")         # votre algorithme\n",
+    "include(\"../test/tester_cauchy.jl\") # la fonction pour tester votre algorithme\n",
+    "\n",
+    "#\n",
+    "tester_cauchy(cauchy); # tester l'algorithme"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3. Coder l'algorithme des régions de confiance (fichier `src/regions_de_confiance.jl`). Sa spécification est donnée dans le fichier.\n",
+    "4. Vérifier que les tests ci-dessous passent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "include(\"../src/regions_de_confiance.jl\")\n",
+    "include(\"../test/tester_rc_cauchy.jl\")\n",
+    "\n",
+    "#\n",
+    "afficher = false # si true, alors affiche les résultats des algorithmes\n",
+    "\n",
+    "#\n",
+    "tester_rc_cauchy(regions_de_confiance, afficher);"
+   ]
+  },
+  {
+   "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 la fonction $f_1 \\colon \\mathbb{R}^3 \\to \\mathbb{R}$ définie par\n",
+    "$$ \n",
+    "    f_1(x_1,x_2, x_3) = 2 (x_1 +x_2 + x_3 -3)^2 + (x_1-x_2)^2 + (x_2 - x_3)^2\n",
+    "$$ \n",
+    "Quelle relation lie la fonction $f_1$ et son modèle de Taylor à l’ordre 2 ? Comparer alors les performances de l'algorithme de Newton et celui des régions de confiance avec le 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": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Expérimentations numériques à faire ici\n",
+    "# Vous pouvez utiliser le package Plots pour les affichages de courbes: using Plots"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Régions de confiance avec gradient conjugué tronqué\n",
+    "\n",
+    "## Implémentation \n",
+    "\n",
+    "1. Implémenter l’algorithme du gradient conjugué tronqué (fichier `src/gct.jl`). Sa spécification est dans le fichier.\n",
+    "2. Vérifier que les tests ci-dessous passent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "include(\"../src/gct.jl\")\n",
+    "include(\"../test/tester_gct.jl\")\n",
+    "\n",
+    "#\n",
+    "tester_gct(gct);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "3. Intégrer l’algorithme du gradient conjugué tronqué dans le code des régions de confiance.\n",
+    "4. Vérifier que les tests ci-dessous passent."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "include(\"../src/regions_de_confiance.jl\")\n",
+    "include(\"../test/tester_rc_gct.jl\")\n",
+    "\n",
+    "#\n",
+    "afficher = false # si true, alors affiche les résultats des algorithmes\n",
+    "\n",
+    "#\n",
+    "tester_rc_gct(regions_de_confiance, afficher);"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Interprétation  \n",
+    "\n",
+    "Nous proposons de comparer l'utilisation du pas de Cauchy avec celle du gradient conjugué tronqué dans l'algorithme des régions de confiance.\n",
+    "\n",
+    "**Remarques.**\n",
+    "* Nous vous demandons de réaliser des expérimentations numériques pour les comparaisons demandées ci-après.\n",
+    "* Vous devez utiliser l'argument optionnel `max_iter_gct` et la sortie `xs` de l'algorithme des régions de confiance.\n",
+    "* Vous pouvez comparer l'écart en norme entre les itérés de l'algorithme et la solution du problème.\n",
+    "* Vous trouverez des choses utiles dans le fichier `test/fonctions_de_tests.jl`.\n",
+    "\n",
+    "1. Comparer dans le cas où l'on force le gradient conjugué tronqué à ne faire qu'une seule itération. Que remarquez vous ?\n",
+    "2. Comparer dans le cas général. Que remarquez vous ?\n",
+    "3. Quels sont les avantages et inconvénients des deux approches ?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Expérimentations numériques à faire ici.\n",
+    "# Vous pouvez utiliser le package Plots pour les affichages de courbes: using Plots"
+   ]
+  }
+ ],
+ "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/cauchy.jl b/src/cauchy.jl
new file mode 100644
index 0000000000000000000000000000000000000000..f97fa1686bb148242f198c04196d61bb4ed47a36
--- /dev/null
+++ b/src/cauchy.jl
@@ -0,0 +1,38 @@
+using LinearAlgebra
+"""
+Approximation de la solution du problème 
+
+    min qₖ(s) = s'gₖ + 1/2 s' Hₖ s
+
+        sous les contraintes s = -t gₖ, t > 0, ‖s‖ ≤ Δₖ
+
+# Syntaxe
+
+    s = cauchy(g, H, Δ; kwargs...)
+
+# Entrées
+
+    - g : (Vector{<:Real}) le vecteur gₖ
+    - H : (Matrix{<:Real}) la matrice Hₖ
+    - Δ : (Real) le scalaire Δₖ
+    - kwargs  : les options sous formes d'arguments "keywords", c'est-à-dire des arguments nommés
+        • tol_abs  : la tolérence absolue (optionnel, par défaut 1e-10)
+
+# Sorties
+
+    - s : (Vector{<:Real}) la solution du problème
+
+# Exemple d'appel
+
+    g = [0; 0]
+    H = [7 0 ; 0 2]
+    Δ = 1
+    s = cauchy(g, H, Δ)
+
+"""
+function cauchy(g::Vector{<:Real}, H::Matrix{<:Real}, Δ::Real; tol_abs::Real = 1e-10)
+
+    s = zeros(length(g))
+
+    return s
+end
diff --git a/src/gct.jl b/src/gct.jl
new file mode 100644
index 0000000000000000000000000000000000000000..ec44e852c253f6f9131cb2f5aa623ab45eadf811
--- /dev/null
+++ b/src/gct.jl
@@ -0,0 +1,41 @@
+using LinearAlgebra
+"""
+Approximation de la solution du problème 
+
+    min qₖ(s) = s'gₖ + 1/2 s' Hₖ s, sous la contrainte ‖s‖ ≤ Δₖ
+
+# Syntaxe
+
+    s = gct(g, H, Δ; kwargs...)
+
+# Entrées
+
+    - g : (Vector{<:Real}) le vecteur gₖ
+    - H : (Matrix{<:Real}) la matrice Hₖ
+    - Δ : (Real) le scalaire Δₖ
+    - kwargs  : les options sous formes d'arguments "keywords", c'est-à-dire des arguments nommés
+        • max_iter : le nombre maximal d'iterations (optionnel, par défaut 100)
+        • tol_abs  : la tolérence absolue (optionnel, par défaut 1e-10)
+        • tol_rel  : la tolérence relative (optionnel, par défaut 1e-8)
+
+# Sorties
+
+    - s : (Vector{<:Real}) une approximation de la solution du problème
+
+# Exemple d'appel
+
+    g = [0; 0]
+    H = [7 0 ; 0 2]
+    Δ = 1
+    s = gct(g, H, Δ)
+
+"""
+function gct(g::Vector{<:Real}, H::Matrix{<:Real}, Δ::Real; 
+    max_iter::Integer = 100, 
+    tol_abs::Real = 1e-10, 
+    tol_rel::Real = 1e-8)
+
+    s = zeros(length(g))
+
+   return s
+end
diff --git a/src/newton.jl b/src/newton.jl
new file mode 100644
index 0000000000000000000000000000000000000000..b111aa9eb82bfc45310aae0fb181c85b0f0a612d
--- /dev/null
+++ b/src/newton.jl
@@ -0,0 +1,56 @@
+using LinearAlgebra
+"""
+Approximation d'une solution du problème min f(x), x ∈ Rⁿ, en utilisant l'algorithme de Newton.
+
+# Syntaxe
+
+   x_sol, f_sol, flag, nb_iters, xs = newton(f, gradf, hessf, x0; kwargs...)
+
+# Entrées
+
+   - f       : (Function) la fonction à minimiser
+   - gradf   : (Function) le gradient de la fonction f
+   - hessf   : (Function) la Hessienne de la fonction f
+   - x0      : (Union{Real,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)
+      • epsilon  : (Real) le epsilon pour les tests de stagnation (optionnel, par défaut 1)
+
+# Sorties
+
+   - x_sol : (Union{Real,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
+
+# Exemple d'appel
+
+   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 = newton(f, gradf, hessf, x0)
+
+"""
+function newton(f::Function, gradf::Function, hessf::Function, x0::Union{Real,Vector{<:Real}}; 
+    max_iter::Integer = 1000, 
+    tol_abs::Real = 1e-10, 
+    tol_rel::Real = 1e-8, 
+    epsilon::Real = 1)
+
+    #
+    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 x_sol, f_sol, flag, nb_iters, xs
+end
\ No newline at end of file
diff --git a/test/tester_cauchy.jl b/test/tester_cauchy.jl
new file mode 100644
index 0000000000000000000000000000000000000000..cc403cc4ae2aed6b671b1b8e3e0c0ab0589cc401
--- /dev/null
+++ b/test/tester_cauchy.jl
@@ -0,0 +1,10 @@
+# Ecrire les tests de l'algorithme du pas de Cauchy
+using Test
+
+function tester_cauchy(cauchy::Function)
+
+	@testset "Pas de Cauchy" begin
+        @test 1==1
+    end
+
+end
\ No newline at end of file
diff --git a/test/tester_newton.jl b/test/tester_newton.jl
new file mode 100755
index 0000000000000000000000000000000000000000..a927930d357332eacd961fb1f049d08535b7e6c6
--- /dev/null
+++ b/test/tester_newton.jl
@@ -0,0 +1,133 @@
+using Test
+include("../test/fonctions_de_tests.jl")
+
+"""
+Tester l'algorithme de Newton
+
+# 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_newton(newton::Function, afficher::Bool)
+
+    println("Affichage des résultats des algorithmes : ", afficher, "\n")
+
+    # tolérance pour les tests
+    tol_erreur = sqrt(eps())
+
+    # options pour Newton
+    max_iter = 100
+    tol_abs = sqrt(eps())
+    tol_rel = 1e-15
+    epsilon = 1.0
+
+    #
+    @testset "algorithme de Newton" begin
+        @testset "test f1 : x0 = solution" begin
+            x_sol, f_sol, flag, nb_iters, _ = newton(fct1, grad_fct1, hess_fct1, sol_exacte_fct1, 
+                            max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
+            if (afficher)
+                afficher_resultats("newton", "f1", sol_exacte_fct1, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
+            end
+            @testset "solution" begin
+                @test x_sol ≈ 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 "test f1 : x0 = x011" begin
+            x_sol, f_sol, flag, nb_iters, _ = newton(fct1, grad_fct1, hess_fct1, pts1.x011,  
+                            max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
+            if (afficher)
+                afficher_resultats("newton", "f1", pts1.x011, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
+            end
+            @testset "solution" begin
+                @test x_sol ≈ 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 "test f1 : x0 = x012" begin
+            x_sol, f_sol, flag, nb_iters, _ = newton(fct1, grad_fct1, hess_fct1, pts1.x012, 
+                            max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
+            if (afficher)
+                afficher_resultats("newton", "f1", pts1.x012, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
+            end
+            @testset "solution" begin
+                @test x_sol ≈ 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 "test f2 : x0 = x021" begin
+            x_sol, f_sol, flag, nb_iters, _ = newton(fct2, grad_fct2, hess_fct2, pts1.x021, 
+                            max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
+            if (afficher)
+                afficher_resultats("newton", "f2", pts1.x021, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
+            end
+            @testset "solution" begin
+                @test x_sol ≈ 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 "test f2 : x0 = x022" begin
+            x_sol, f_sol, flag, nb_iters, _ = newton(fct2, grad_fct2, hess_fct2, pts1.x022, 
+                            max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
+            if (afficher)
+                afficher_resultats("newton", "f2", pts1.x022, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
+            end
+            @testset "solution" begin
+                @test x_sol ≈ 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 "test f2 : x0 = x023" begin
+            x_sol, f_sol, flag, nb_iters, _ = newton(fct2, grad_fct2, hess_fct2, pts1.x023, 
+                            max_iter=1, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
+            if (afficher)
+                afficher_resultats("newton", "f2", pts1.x023, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
+            end
+            @testset "solution" begin
+                @test x_sol ≈ [-4.99999958629818e9, 8.673617379884035e-19] atol = tol_erreur
+            end
+            @testset "flag" begin
+                @test flag == 3
+            end
+            @testset "itération" begin
+                @test nb_iters == 1
+            end
+            @testset "exception" begin
+                @test_throws SingularException _, _, _, _ = newton(fct2, grad_fct2, hess_fct2, pts1.x023, 
+                        max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
+            end
+        end
+    end
+end
diff --git a/test/tester_rc_cauchy.jl b/test/tester_rc_cauchy.jl
new file mode 100755
index 0000000000000000000000000000000000000000..d6cdc0426ac72ae58c4ab49c16857ee3ba3c1730
--- /dev/null
+++ b/test/tester_rc_cauchy.jl
@@ -0,0 +1,76 @@
+using Test
+include("../test/fonctions_de_tests.jl")
+
+"""
+Tester l'algorithme des régions de confiance avec le pas de Cauchy
+
+# 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_rc_cauchy(rc::Function, afficher::Bool)
+
+    println("Affichage des résultats des algorithmes : ", afficher, "\n")
+
+	# La tolérance utilisée dans les tests
+	tol_erreur = 1e-2
+
+	# 
+	algo_pas = "cauchy"
+
+	# l'ensemble de tests
+	@testset "RC et pas de Cauchy " begin
+
+		# cas de test 1
+		x_sol, f_sol, flag, nb_iters, _ = rc(fct1, grad_fct1, hess_fct1, pts1.x011, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f1", pts1.x011, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
+		end
+		@test x_sol ≈ sol_exacte_fct1 atol=tol_erreur
+		@test flag == 2
+		@test nb_iters == 33
+
+		# cas de test 2
+		x_sol, f_sol, flag, nb_iters  = rc(fct1, grad_fct1, hess_fct1, pts1.x012, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f1", pts1.x012, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
+		end
+		@test x_sol ≈ sol_exacte_fct1 atol=tol_erreur
+		@test flag == 2
+		@test nb_iters == 34
+
+		# cas de test 3
+		x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x021, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f2", pts1.x021, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
+		end
+		@test x_sol ≈ sol_exacte_fct2 atol=tol_erreur
+		@test flag == 3
+		@test nb_iters == 5000
+
+		# cas de test 4
+		x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x022, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f2", pts1.x022, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
+		end
+		@test x_sol ≈ sol_exacte_fct2 atol=tol_erreur
+		@test flag == 0
+		@test nb_iters == 864
+
+		# cas de test 5
+		x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x023, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f2", pts1.x023, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
+		end
+		@test x_sol ≈ sol_exacte_fct2 atol=tol_erreur
+		@test flag == 2
+		@test nb_iters == 4512
+	
+	end
+end
diff --git a/test/tester_rc_gct.jl b/test/tester_rc_gct.jl
new file mode 100755
index 0000000000000000000000000000000000000000..8cf941a42b22857b6e24c3d6cb73e924cc16f72c
--- /dev/null
+++ b/test/tester_rc_gct.jl
@@ -0,0 +1,76 @@
+using Test
+include("../test/fonctions_de_tests.jl")
+
+"""
+Tester l'algorithme des régions de confiance avec le gradient conjugué tronqué
+
+# 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_rc_gct(rc::Function, afficher::Bool)
+
+    println("Affichage des résultats des algorithmes : ", afficher, "\n")
+
+	# La tolérance utilisée dans les tests
+	tol_erreur = 1e-2
+
+	# 
+	algo_pas = "gct"
+
+	# l'ensemble de tests
+	@testset "RC et gct" begin
+
+		# cas de test 1
+		x_sol, f_sol, flag, nb_iters, _ = rc(fct1, grad_fct1, hess_fct1, pts1.x011, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f1", pts1.x011, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
+		end
+		@test x_sol ≈ sol_exacte_fct1 atol=tol_erreur
+		@test flag == 0
+		@test nb_iters == 1
+
+		# cas de test 2
+		x_sol, f_sol, flag, nb_iters  = rc(fct1, grad_fct1, hess_fct1, pts1.x012, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f1", pts1.x012, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
+		end
+		@test x_sol ≈ sol_exacte_fct1 atol=tol_erreur
+		@test flag == 0
+		@test nb_iters == 3
+
+		# cas de test 3
+		x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x021, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f2", pts1.x021, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
+		end
+		@test x_sol ≈ sol_exacte_fct2 atol=tol_erreur
+		@test flag == 0
+		@test nb_iters == 31
+
+		# cas de test 4
+		x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x022, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f2", pts1.x022, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
+		end
+		@test x_sol ≈ sol_exacte_fct2 atol=tol_erreur
+		@test flag == 0
+		@test nb_iters == 44
+
+		# cas de test 5
+		x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x023, algo_pas=algo_pas)
+		if (afficher)
+			afficher_resultats("RC et " * algo_pas, "f2", pts1.x023, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
+		end
+		@test x_sol ≈ sol_exacte_fct2 atol=tol_erreur
+		@test flag == 0
+		@test nb_iters == 19
+	
+	end
+end