From 484273f6833b3fa278ce238729ca03f68b8c3f03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Laure=CE=B7t?= Date: Fri, 17 Dec 2021 17:12:31 +0100 Subject: [PATCH] fin de projet --- src/TP-Projet-Optinum.ipynb | 602 ++++++++++++++++++++-------- test/fonctions_de_tests.jl | 24 +- test/tester_gct.jl | 61 ++- test/tester_pas_de_cauchy.jl | 16 +- test/tester_regions_de_confiance.jl | 2 +- 5 files changed, 523 insertions(+), 182 deletions(-) diff --git a/src/TP-Projet-Optinum.ipynb b/src/TP-Projet-Optinum.ipynb index 66efc63..db77bda 100644 --- a/src/TP-Projet-Optinum.ipynb +++ b/src/TP-Projet-Optinum.ipynb @@ -5,20 +5,62 @@ "metadata": {}, "source": [ "
\n", - "

TP-Projet d'optimisation numérique

\n", - "

Année 2020-2021 - 2e année département Sciences du Numérique

\n", - "

Nom: FAINSIN

\n", - "

Prénom: Laurent

\n", + "

\n", + "TP-Projet d'optimisation numérique
\n", + "2ème année département Sciences du Numérique
\n", + "2021-2022
\n", + "FAINSIN Laurent\n", + "

\n", "
" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Status\u001b[22m\u001b[39m `~/.julia/environments/v1.7/Project.toml`\n", + " \u001b[90m [0c46a032] \u001b[39mDifferentialEquations v6.20.0\n", + " \u001b[90m [bd48cda9] \u001b[39mGraphRecipes v0.5.8\n", + " \u001b[90m [86223c79] \u001b[39mGraphs v1.4.1\n", + " \u001b[90m [91a5bcdd] \u001b[39mPlots v1.25.1\n", + " \u001b[90m [a6016688] \u001b[39mTestOptinum v0.1.0 `https://github.com/mathn7/TestOptinum.git#master`\n", + " \u001b[90m [37e2e46d] \u001b[39mLinearAlgebra\n", + " \u001b[90m [d6f4376e] \u001b[39mMarkdown\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Project.toml`\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Manifest.toml`\n", + "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", + "\u001b[32m ✓ \u001b[39mTestOptinum\n", + " 1 dependency successfully precompiled in 2 seconds (262 already precompiled, 2 skipped during auto due to previous errors)\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Project.toml`\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Manifest.toml`\n", + "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", + "\u001b[32m ✓ \u001b[39mTestOptinum\n", + " 1 dependency successfully precompiled in 2 seconds (262 already precompiled, 2 skipped during auto due to previous errors)\n", + "\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Project.toml`\n", + "\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Manifest.toml`\n", + "\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n", + "\u001b[32m ✓ \u001b[39mTestOptinum\n", + " 1 dependency successfully precompiled in 2 seconds (262 already precompiled, 2 skipped during auto due to previous errors)\n" + ] + } + ], "source": [ - "include(\"../test/imports_boilerplate.jl\")" + "include(\"../test/imports_boilerplate.jl\");\n", + "afficher = true;" ] }, { @@ -26,20 +68,121 @@ "metadata": {}, "source": [ "# Algorithme de Newton\n", - "## Implémentation \n", + "\n", + "### Implémentation \n", " \n", "1. Coder l’algorithme de Newton local tel que décrit dans la section *Algorithme de Newton* (fichier `Algorithme_De_Newton.jl`)\n", - "\n", - "2. Tester l’algorithme sur les fonctions $f_{1}$ , $f_{2}$ avec les points initiaux $x_{011}$ , $x_{012}$ (pour $f_{1}$ ) et $x_{021}$ , $x_{022}$ , $x_{023}$ (pour $f_{2}$ ) donnés en Annexe A." + "2. Tester l’algorithme sur les fonctions $f_{1}$ , $f_{2}$ avec les points initiaux $x_{011}$ , $x_{012}$ (pour $f_{1}$) et $x_{021}$ , $x_{022}$ , $x_{023}$ (pour $f_{2}$) donnés en Annexe A." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct0 au point initial sol_exacte :\u001b[22m\u001b[39m\n", + " * xsol = -1.5707963267948966\n", + " * f(xsol) = -1.0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte = -1.5707963267948966\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct0 au point initial x001 :\u001b[22m\u001b[39m\n", + " * xsol = -1.5707963267949088\n", + " * f(xsol) = -1.0\n", + " * nb_iters = 3\n", + " * flag = 0\n", + " * sol_exacte = -1.5707963267948966\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct0 au point initial x002 :\u001b[22m\u001b[39m\n", + " * xsol = 1.5707963267948966\n", + " * f(xsol) = 1.0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte = -1.5707963267948966\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct1 au point initial sol_exacte :\u001b[22m\u001b[39m\n", + " * xsol = [1, 1, 1]\n", + " * f(xsol) = 0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct1 au point initial x011 :\u001b[22m\u001b[39m\n", + " * xsol = [1.0000000000000002, 1.0, 0.9999999999999998]\n", + " * f(xsol) = 9.860761315262648e-32\n", + " * nb_iters = 1\n", + " * flag = 0\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct1 au point initial x012 :\u001b[22m\u001b[39m\n", + " * xsol = [1.0, 0.9999999999999996, 0.9999999999999982]\n", + " * f(xsol) = 1.1832913578315177e-29\n", + " * nb_iters = 1\n", + " * flag = 0\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct1 au point initial sol_exacte :\u001b[22m\u001b[39m\n", + " * xsol = [1, 1, 1]\n", + " * f(xsol) = 0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct2 au point initial x021 :\u001b[22m\u001b[39m\n", + " * xsol = [0.9999999999999999, 0.9999999999814724]\n", + " * f(xsol) = 3.4326461875363225e-20\n", + " * nb_iters = 6\n", + " * flag = 0\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct2 au point initial x022 :\u001b[22m\u001b[39m\n", + " * xsol = [1.0, 1.0]\n", + " * f(xsol) = 0.0\n", + " * nb_iters = 5\n", + " * flag = 0\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct2 au point initial x022 :\u001b[22m\u001b[39m\n", + " * xsol = [-4.99999958629818e9, 8.673617379884035e-19]\n", + " * f(xsol) = 6.249997931491155e40\n", + " * nb_iters = 1\n", + " * flag = 3\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : stagnation x de Newton appliqué à fct0 au point initial [0.9999, 0.9999, 0.9999] :\u001b[22m\u001b[39m\n", + " * xsol = [0.999899999, 0.999899999, 0.999899999]\n", + " * f(xsol) = 1.8000360001799175e-7\n", + " * nb_iters = 1\n", + " * flag = 1\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : stagnation f(x) de Newton appliqué à fct2 au point initial [100.0, 100.0] :\u001b[22m\u001b[39m\n", + " * xsol = [1.0000000000000073, 0.9999999975412127]\n", + " * f(xsol) = 6.045706979316412e-16\n", + " * nb_iters = 4\n", + " * flag = 2\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : itermax de Newton appliqué à fct2 au point initial x021 :\u001b[22m\u001b[39m\n", + " * xsol = [0.7631148711762008, -3.1750338547475616]\n", + " * f(xsol) = 1411.8451793091335\n", + " * nb_iters = 2\n", + " * flag = 3\n", + " * sol_exacte = [1, 1]\n", + "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n", + "L'algo de Newton | \u001b[32m 24 \u001b[39m\u001b[36m 24\u001b[39m\n" + ] + } + ], "source": [ - "tester_algo_newton(false, Algorithme_De_Newton)" + "# les fonctions de l'annexe A + f0 sont dans les tests\n", + "tester_algo_newton(afficher, Algorithme_De_Newton);" ] }, { @@ -48,140 +191,356 @@ "source": [ "## Interprétation \n", "\n", - "Justifier\n", + "### Justifier\n", "\n", "1. les résultats obtenus pour l'exemple $f_0$ ci-dessus;\n", - "\n", "2. que l’algorithme implémenté converge en une itération pour $f_{1}$;\n", + "3. que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.\n", "\n", - "3. que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Vos réponses?\n", + "### Vos réponses?\n", "La méthode de Newton repose sur la recherche des solutions de $\\nabla f(x) = 0$, cet algorithme recherche donc les extremums de $f$ et non uniquement ses minimas.\n", "\n", - "1. \n", - " 1. Dans le cas où $x_0 = x_{sol}$, les tests de convergence arretent l'algorithme (et rien ne se passe)\n", + "\n", + "1.\n", + " 1. Dans le cas où $x_0 = x_{sol}$, les tests de convergence arretent l'algorithme (et rien ne se passe, on a déjà la solution)\n", + " \n", " 2. Dans le cas où $x_0 = \\frac{1-\\pi}{2}$, l'algorithme trouve une racine de $cos(x)$ en seulement 2 itérations.\n", + " \n", " 3. Dans le cas où $x_0 = \\frac\\pi2$, l'algorithme tombe immédiatement sur une racine de $cos(x)$, il s'arrête mais la solution est un maximum et non un minimum.\n", "\n", "2. \n", " 1. $x_0 = x_{sol}$, donc la convergence en une itération est cohérent.\n", + " \n", " 2. $x_0 = [1, 0, 0]$, $\\nabla^2f(x_0) \\setminus \\nabla f (x_0) ~= [0, -1, -1]$. Ainsi après une itération, on retombe sur $[1, 1, 1]$, qui est un minimum de f1.\n", + " \n", " 3. $x_0 = [10, 3, -2.2]$, on a le même scénario que précédemment : $\\nabla^2f(x_0) \\setminus \\nabla f (x_0) ~= [9, 2, -3.2]$.\n", "\n", - "3. $f_2$ ne peut pas converger dans le cas où $x_0= [0, \\frac1{200} + 10^{-12}]$ puisque à partir d'une certaine itération, la hessienne possède des coefficients trop grand et devient numériquement non inversible." + "3. $f_2$ ne peut pas converger dans le cas où $x_0= [0, \\frac1{200} + 10^{-12}]$ puisqu'à partir d'une certaine itération, la hessienne possède des coefficients trop grand et devient numériquement non inversible." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Régions de confiance avec pas de cauchy \n", + "# Régions de confiance\n", "\n", - "## Implémentation \n", + "## Pas de Cauchy\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`). Tester sur les quadratiques proposées en Annexe B.\n", + "### Implémentation\n", "\n", - "2. Coder l'algorithme de régions de confiance (fichier `Regions_De_Confiance.jl`). Tester sur les problèmes de l’Annexe A." + "Coder l'algorithme du pas de Cauchy d’un sous-problème de régions de confiance (fichier `Pas_De_Cauchy.jl`).\n", + "Tester sur les quadratiques proposées en Annexe B." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 1 :\u001b[22m\u001b[39m\n", + " * sol = [0, 0]\n", + " * sol_exacte = [0, 0]\n", + " * flag = 0\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 2 :\u001b[22m\u001b[39m\n", + " * sol = [-0.9230769230769234, -0.30769230769230776]\n", + " * sol_exacte = [-0.9230769230769234, -0.30769230769230776]\n", + " * flag = 1\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 3 :\u001b[22m\u001b[39m\n", + " * sol = [-0.8538149682454623, -0.2846049894151541]\n", + " * sol_exacte = [-0.8538149682454623, -0.2846049894151541]\n", + " * flag = -1\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 4 :\u001b[22m\u001b[39m\n", + " * sol = [5.000000000000001, -2.5000000000000004]\n", + " * sol_exacte = [5.000000000000001, -2.5000000000000004]\n", + " * flag = 1\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 5 :\u001b[22m\u001b[39m\n", + " * sol = [4.47213595499958, -2.23606797749979]\n", + " * sol_exacte = [4.47213595499958, -2.23606797749979]\n", + " * flag = -1\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 6 :\u001b[22m\u001b[39m\n", + " * sol = [-4.743416490252569, -1.5811388300841895]\n", + " * sol_exacte = [-4.743416490252569, -1.5811388300841895]\n", + " * flag = -1\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 7 :\u001b[22m\u001b[39m\n", + " * sol = [-2.23606797749979, -4.47213595499958]\n", + " * sol_exacte = [-2.23606797749979, -4.47213595499958]\n", + " * flag = -1\n", + "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n", + "Pas de Cauchy | \u001b[32m 7 \u001b[39m\u001b[36m 7\u001b[39m\n" + ] + } + ], "source": [ - "tester_pas_de_cauchy(false, Pas_De_Cauchy)" + "# les quadratiques de l'annexe B sont dans les tests\n", + "tester_pas_de_cauchy(afficher, Pas_De_Cauchy);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Interprétation \n", + "### Interprétation \n", "\n", "1. Quelle relation lie la fonction test $f_1$ et son modèle de Taylor à l’ordre 2 ? Comparer alors les performances de Newton et RC-Pas de Cauchy sur cette fonction.\n", "\n", - "2. Le rayon initial de la région de confiance est un paramètre important dans l’analyse de la performance de l’algorithme. Sur quel(s) autre(s) paramètre(s) peut-on jouer pour essayer d’améliorer cette performance ? Étudier l’influence d’au moins deux de ces paramètres." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Vos réponses?\n", + "2. Le rayon initial de la région de confiance est un paramètre important dans l’analyse de la performance de l’algorithme. Sur quel(s) autre(s) paramètre(s) peut-on jouer pour essayer d’améliorer cette performance ? Étudier l’influence d’au moins deux de ces paramètres.\n", + "\n", + "### Vos réponses ?\n", + "\n", + "| Point | Newton | RC-Cauchy |\n", + "| :-------- | :----: | :-------: |\n", + "| $x_{sol}$ | 0 | 0 |\n", + "| $x_{011}$ | 1 | 26 |\n", + "| $x_{012}$ | 1 | 28 |\n", + "\n", "1. Si on note $q_1$ le modèle de Taylor à l'ordre 2 de $f_1$, alors $m^1_k(x_k+s) = q_1(s) = f_1(x_k) + g_1^T s + \\frac12 s^T H_k s$.\n", + "On observe que RC-Cauchy est plus lent que la méthode de Newton sur la fonction $f1$.\n", "\n", - "2. Pour essayer d'améliorer les performances de l'algorithme des régions de confiance avec Cauchy, on peut aussi essayer d'agrandir $\\Delta_{max}$ pour que l'algorithme converge plus rapidement, dans le cas où on observe un grand nombre d'itérations lors de la résolution." + "2. Pour essayer d'améliorer les performances de l'algorithme des régions de confiance avec Cauchy, on peut aussi essayer d'agrandir $\\Delta_{max}$ pour que l'algorithme converge plus rapidement dans les cas où on observe un grand nombre d'itérations lors de la résolution." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# Régions de confiance avec gradient conjugué tronqué\n", + "## Gradient conjugué tronqué\n", "\n", - "## Implémentation \n", + "### Implémentation \n", "\n", - "1. Implémenter l’algorithme du Gradient Conjugué Tronqué, en se basant sur le cours (fichier `Gradient_Conjugue_Tronque.jl`).\n", - "On validera les résultats sur les fonctions de l’Annexe C.\n", - "\n", - "2. Intégrer finalement l’algorithme du Gradient Conjugué Tronqué dans le code de\n", - "régions de confiance, et appliquer ce code pour résoudre les exemples proposés en\n", - "Annexe A." + "Implémenter l’algorithme du Gradient Conjugué Tronqué, en se basant sur le cours (fichier `Gradient_Conjugue_Tronque.jl`).\n", + "On validera les résultats sur les fonctions de l’Annexe C." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 1 :\u001b[22m\u001b[39m\n", + " * sol = [0.0, 0.0]\n", + " * sol_exacte = [0.0, 0.0]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 2 :\u001b[22m\u001b[39m\n", + " * sol = [-0.4743416490252569, -0.15811388300841897]\n", + " * sol_exacte = [-0.4743416490252569, -0.15811388300841897]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 3 :\u001b[22m\u001b[39m\n", + " * sol = [-0.8740776099190263, -0.8221850958502243]\n", + " * sol_exacte = [-0.8740776099190263, -0.8221850958502244]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 4 :\u001b[22m\u001b[39m\n", + " * sol = [-0.8571428571428571, -0.9999999999999998]\n", + " * sol_exacte = [-0.8571428571428571, -1.0]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 5 :\u001b[22m\u001b[39m\n", + " * sol = [-0.447213595499958, -0.894427190999916]\n", + " * sol_exacte = [-0.4472135954999579, -0.8944271909999159]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 6 :\u001b[22m\u001b[39m\n", + " * sol = [-0.5, 0.0]\n", + " * sol_exacte = [-0.5, -0.0]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 7 :\u001b[22m\u001b[39m\n", + " * sol = [9.102342582478453, -4.140937032991381]\n", + " * sol_exacte = [9.102342582478453, -4.140937032991381]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 8 :\u001b[22m\u001b[39m\n", + " * sol = [0.0, 0.0]\n", + " * sol_exacte = [0.0, 0.0]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 9 :\u001b[22m\u001b[39m\n", + " * sol = [1.9059020876695598, -2.3167946029410578]\n", + " * sol_exacte = [1.9059020876695578, -2.3167946029410595]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : GCT 10 :\u001b[22m\u001b[39m\n", + " * sol = [-0.5, 0.0]\n", + " * sol_exacte = [-0.5, 0.0]\n", + "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n", + "Gradient-CT | \u001b[32m 11 \u001b[39m\u001b[36m 11\u001b[39m\n" + ] + } + ], "source": [ - "tester_gct(false, Gradient_Conjugue_Tronque)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "tester_regions_de_confiance(true, Regions_De_Confiance)" + "# les quadratiques de l'annexe C sont dans les tests\n", + "tester_gct(afficher, Gradient_Conjugue_Tronque);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Interprétation \n", + "### Interprétation \n", "\n", - "1. Comparer la décroissance obtenue avec celle du pas de Cauchy, en retournant, dans\n", - "un premier temps le dernier itéré admissible à courbure positive (c’est à dire, que si\n", - "l’une ou l’autre des deux conditions (b) ou (d) sont rencontrées dans l’algorithme 3,\n", - "alors on ne calcule pas ``σ_{j}`` et on retourne le dernier itéré ``s_{j}`` directement).\n", + "1. Comparer la décroissance obtenue avec celle du pas de Cauchy, en retournant, dans un premier temps le dernier itéré admissible à courbure positive (c’est à dire, que si l’une ou l’autre des deux conditions (b) ou (d) sont rencontrées dans l’algorithme 3, alors on ne calcule pas ``σ_{j}`` et on retourne le dernier itéré ``s_{j}`` directement).\n", "\n", - "2. Comparer la décroissance obtenue avec celle du pas de Cauchy, en imposant la sortie\n", - "dans l’algorithme 3 au bout d’une itération seulement. Que remarquez vous ?\n", + "2. Comparer la décroissance obtenue avec celle du pas de Cauchy, en imposant la sortie dans l’algorithme 3 au bout d’une itération seulement. Que remarquez vous ?\n", "\n", "3. Comparer la décroissance obtenue avec celle du pas de Cauchy dans le cas général.\n", "\n", - "4. Quels sont les avantages et inconvénients des deux approches ?" + "4. Quels sont les avantages et inconvénients des deux approches ?\n", + "\n", + "### Vos réponses ?\n", + "\n", + "1. \n", + "\n", + "| Solution | RC-Cauchy | RC-GCT |\n", + "| :-------: | :-----------------: | :-----------------: |\n", + "| [1, 1, 1] | [1, 1, 1] | [1, 1, 1] |\n", + "| [1, 1, 1] | [1.51, 0.85, 0.68] | [1.0, 1.0, 1.0] |\n", + "| [1, 1, 1] | [8.41, 2.02, -2.93] | [4.66, 0.62, -3.12] |\n", + "| [1, 1] | [-1.05, 1.05] | [-1.17, 1.38] |\n", + "| [1, 1] | [8.00, 0.09] | [5.46, 3.19] |\n", + "| [1, 1] | [0.04, -0.01] | [0.0, 0.005] |\n", + "\n", + "2. Si on limite à une itération, on observe que l'algorithme des régions de confiance avec GCT converge plus rapidement.\n", + "\n", + "Test | RC-Cauchy | RC-GCT |\n", + "| :----- | :-------: | :----: |\n", + "| test 1 | 0 | 0 |\n", + "| test 2 | 26 | 1 |\n", + "| test 3 | 28 | 3 |\n", + "| test 4 | 3988 | 31 |\n", + "| test 5 | 864 | 44 |\n", + "| test 6 | 3198 | 19 |\n", + "3. Dans le cas général on remarque que RC-GCT est nettement plus efficace que RC-Cauchy. \n", + "\n", + "4. Cauchy est plus simple mais moins efficace, et GCT est plus efficace mais nécéssite plus de calculs par itération." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "1. dqzd\n", - "2. dzqd\n", - "3. 3dqzdzd\n", - "4. dqzd" + "## Implémentation\n", + "\n", + "1. Coder l'algorithme de régions de confiance (fichier `Regions_De_Confiance.jl`). Tester sur les problèmes de l’Annexe A.\n", + "2. Intégrer finalement l’algorithme du Gradient Conjugué Tronqué dans le code de régions de confiance, et appliquer ce code pour résoudre les exemples proposés en Annexe A." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 1 au point initial sol_exacte :\u001b[22m\u001b[39m\n", + " * xsol = [1, 1, 1]\n", + " * f(xsol) = 0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 1 au point initial x011 :\u001b[22m\u001b[39m\n", + " * xsol = [1.0000558873349883, 0.999992420017735, 0.9999289527004819]\n", + " * f(xsol) = 9.090411079109608e-9\n", + " * nb_iters = 26\n", + " * flag = 2\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 1 au point initial x012 :\u001b[22m\u001b[39m\n", + " * xsol = [1.000049795462743, 0.9999961002424803, 0.9999424049876057]\n", + " * f(xsol) = 6.0401046516733e-9\n", + " * nb_iters = 28\n", + " * flag = 2\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 2 au point initial x021 :\u001b[22m\u001b[39m\n", + " * xsol = [0.9975992881487654, 0.9951970760634036]\n", + " * f(xsol) = 5.768693455998473e-6\n", + " * nb_iters = 3988\n", + " * flag = 2\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 2 au point initial x022 :\u001b[22m\u001b[39m\n", + " * xsol = [0.9961677295964368, 0.9923393628804894]\n", + " * f(xsol) = 1.4697922911344958e-5\n", + " * nb_iters = 864\n", + " * flag = 0\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance (itermax) avec cauchy appliqué à fonction 2 au point initial x022 :\u001b[22m\u001b[39m\n", + " * xsol = [0.9906938429133161, 0.981448447768753]\n", + " * f(xsol) = 8.667134381048603e-5\n", + " * nb_iters = 10\n", + " * flag = 3\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 2 au point initial x023 :\u001b[22m\u001b[39m\n", + " * xsol = [0.998024983312937, 0.9960352320641266]\n", + " * f(xsol) = 3.935418178353333e-6\n", + " * nb_iters = 3198\n", + " * flag = 2\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à sol_exacte au point initial x011 :\u001b[22m\u001b[39m\n", + " * xsol = [1, 1, 1]\n", + " * f(xsol) = 0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 1 au point initial x011 :\u001b[22m\u001b[39m\n", + " * xsol = [1.0000000000000007, 1.0, 1.0]\n", + " * f(xsol) = 2.0214560696288428e-30\n", + " * nb_iters = 1\n", + " * flag = 0\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 1 au point initial x012 :\u001b[22m\u001b[39m\n", + " * xsol = [0.9999999999999996, 1.0000000000000002, 1.0000000000000004]\n", + " * f(xsol) = 4.930380657631324e-31\n", + " * nb_iters = 3\n", + " * flag = 0\n", + " * sol_exacte = [1, 1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 2 au point initial x021 :\u001b[22m\u001b[39m\n", + " * xsol = [0.9999996743780089, 0.9999993478371609]\n", + " * f(xsol) = 1.0611413038132374e-13\n", + " * nb_iters = 31\n", + " * flag = 0\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 2 au point initial x022 :\u001b[22m\u001b[39m\n", + " * xsol = [1.0000035183009863, 1.0000066949336202]\n", + " * f(xsol) = 2.4053014026923312e-11\n", + " * nb_iters = 44\n", + " * flag = 0\n", + " * sol_exacte = [1, 1]\n", + "--------------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 2 au point initial x023 :\u001b[22m\u001b[39m\n", + " * xsol = [0.9999999999998994, 0.9999999999996207]\n", + " * f(xsol) = 3.1813581453548166e-24\n", + " * nb_iters = 19\n", + " * flag = 0\n", + " * sol_exacte = [1, 1]\n", + "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n", + "La méthode des RC | \u001b[32m 13 \u001b[39m\u001b[36m 13\u001b[39m\n" + ] + } + ], + "source": [ + "# les fonctions de l'annexe A sont dans les tests\n", + "tester_regions_de_confiance(afficher, Regions_De_Confiance);" ] }, { @@ -190,91 +549,21 @@ "source": [ "# Lagrangien augmenté\n", "\n", - "## Implémentation\n", - "1.Choisir des critères d’arrêt pour la convergence de l'algorithme.\n", + "### Implémentation\n", "\n", - "2.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`)\n", - " \n", - "3.Tester les différentes variantes sur les problèmes en Annexe D.\n", - " " + "1. Choisir des critères d’arrêt pour la convergence de l'algorithme.\n", + "2. Implémenter l'algorithme du lagrangien augmenté, en utilisant les différentes méthodes qui ont été vues en première partie pour la résolution de la suite de problémes sans contraintes (fichier `Lagrangien_Augmente.jl`)\n", + "3. Tester les différentes variantes sur les problèmes en Annexe D." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ - "function 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", - "fct1(x) = 2 * (x[1] + x[2] + x[3] - 3)^2 + (x[1] - x[2])^2 + (x[2] - x[3])^2\n", - "# la gradient de la fonction fct1\n", - "function grad_fct1(x)\n", - " y1 = 4 * (x[1] + x[2] + x[3] - 3) + 2 * (x[1] - x[2])\n", - " y2 = 4 * (x[1] + x[2] + x[3] - 3) - 2 * (x[1] - x[2]) + 2 * (x[2] - x[3])\n", - " y3 = 4 * (x[1] + x[2] + x[3] - 3) - 2 * (x[2] - x[3])\n", - " return [y1; y2; y3]\n", - "end\n", - "# la hessienne de la fonction fct1\n", - "hess_fct1(x) = [6 2 4; 2 8 2; 4 2 6]\n", - "\n", - "contrainte1(x) = x[1] + x[3] - 1\n", - "grad_contrainte1(x) = [1; 0; 1]\n", - "hess_contrainte1(x) = [0 0 0; 0 0 0; 0 0 0]\n", - "\n", - "x01 = [0; 1; 1]\n", - "x02 = [0.5; 1.25; 1]\n", - "x03 = [1; 0]\n", - "x04 = [sqrt(3) / 2; sqrt(3) / 2]\n", - "pts2 = Pts_avec_contraintes(x01, x02, x03, x04)\n", - "\n", - "# sol_fct1_augm = [0.5 ; 1.25 ; 0.5]\n", - "\n", - "algo = \"newton\"\n", - "xmin, fxmin, flag, nbiters = Lagrangien_Augmente(algo, fct1, contrainte1, grad_fct1, hess_fct1, grad_contrainte1, hess_contrainte1, pts2.x01, options)\n", - "afficher_resultats(\"Lagrangien augmenté avec \" * algo, \"fonction 1\", \"x01\", xmin, fxmin, flag, sol_fct1_augm, nbiters)\n", - "\n", - "algo = \"cauchy\"\n", - "xmin, fxmin, flag, nbiters = Lagrangien_Augmente(algo, fct1, contrainte1, grad_fct1, hess_fct1, grad_contrainte1, hess_contrainte1, pts2.x01, options)\n", - "afficher_resultats(\"Lagrangien augmenté avec \" * algo, \"fonction 1\", \"x01\", xmin, fxmin, flag, sol_fct1_augm, nbiters)\n", - "\n", - "algo = \"gct\"\n", - "xmin, fxmin, flag, nbiters = Lagrangien_Augmente(algo, fct1, contrainte1, grad_fct1, hess_fct1, grad_contrainte1, hess_contrainte1, pts2.x01, options)\n", - "afficher_resultats(\"Lagrangien augmenté avec \" * algo, \"fonction 1\", \"x01\", xmin, fxmin, flag, sol_fct1_augm, nbiters)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "tester_lagrangien_augmente(true, Lagrangien_Augmente)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "for algo in [\"newton\" \"cauchy\" \"gct\"]\n", - " for tau in [0.01; 0.1; 1; 10; 100; 1000]\n", - " options = [1e-8 1e-5 1 10 10 tau]\n", - " xmin, fxmin, flag, nbiters = Lagrangien_Augmente(algo, fct1, contrainte1, grad_fct1, hess_fct1, grad_contrainte1, hess_contrainte1, zeros(3), options)\n", - " println(\"algo=\" * algo * \", tau=\" * string(tau) * \" \\t--> iter=\" * string(nbiters) * \" fxmin=\" * string(fxmin) * \" flag=\" * string(flag))\n", - " end\n", - "end" + "# les fonctions de l'annexe D sont dans les tests\n", + "tester_lagrangien_augmente(afficher, Lagrangien_Augmente);" ] }, { @@ -290,8 +579,7 @@ "source": [ "1. Commenter les résultats obtenus, en étudiant notamment les valeurs de $\\lambda_k$ et $\\mu_k$.\n", "2. Étudier l'influence du paramètre $\\tau$ dans la performance de l'algorithme.\n", - "3. **Supplémentaire** : \n", - "Que proposez-vous comme méthode pour la résolution des problèmes avec des contraintes à la fois d'égalité et d'inégalité ? Implémenter (si le temps le permet) ce nouvel algorithme" + "3. **Supplémentaire** : Que proposez-vous comme méthode pour la résolution des problèmes avec des contraintes à la fois d'égalité et d'inégalité ? Implémenter (si le temps le permet) ce nouvel algorithme" ] }, { @@ -319,8 +607,8 @@ "1. On observe que lorsque:\n", " - l'algorithme converge (flag = 0), alors $\\lambda_k$ tend vers $2 \\times f(x_{min})$.\n", " - l'algorithme ne converge pas (flag = 1), alors $\\mu_k$ tend vers 0. \n", - "\n", - "2. Il semblerait que plus $\\tau$ est élevé, plus l'algorithme converge rapidement" + "2. Il semblerait que plus $\\tau$ est élevé, plus l'algorithme converge rapidement.\n", + "3. " ] } ], diff --git a/test/fonctions_de_tests.jl b/test/fonctions_de_tests.jl index 790d5c9..8899b07 100755 --- a/test/fonctions_de_tests.jl +++ b/test/fonctions_de_tests.jl @@ -123,11 +123,23 @@ 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("---------------------------------------------------------------------------------") + println("-"^80) 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) + println(" * xsol = ", xmin) + println(" * f(xsol) = ", fxmin) + println(" * nb_iters = ", nbiters) + println(" * flag = ", flag) + println(" * sol_exacte = ", sol_exacte) end + +function afficher_resultats_gct(algo, sol, sol_exacte) + println("-"^80) + printstyled("Résultats de : " * algo, " :\n", bold = true, color = :blue) + println(" * sol = ", sol) + println(" * sol_exacte = ", sol_exacte) +end + +function afficher_resultats_cauchy(algo, flag, sol, sol_exacte) + afficher_resultats_gct(algo, sol, sol_exacte) + println(" * flag = ", flag) +end \ No newline at end of file diff --git a/test/tester_gct.jl b/test/tester_gct.jl index 6946af9..17f4876 100755 --- a/test/tester_gct.jl +++ b/test/tester_gct.jl @@ -25,55 +25,92 @@ function tester_gct(afficher::Bool, Gradient_Conjugue_Tronque::Function) Hess = [7 0; 0 2] delta = 1 s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol]) - @test isapprox(s, [0.0; 0.0], atol = tol_test) + sol = [0.0; 0.0] + if afficher + afficher_resultats_gct("GCT 1", s, sol) + end + @test isapprox(s, sol, 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 isapprox(s, -delta * grad / norm(grad), atol = tol_test) + sol = -delta * grad / norm(grad) + if afficher + afficher_resultats_gct("GCT 2", s, sol) + end + @test isapprox(s, sol, atol = tol_test) delta = 1.2 # saturation à la 2ieme itération s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol]) - @test isapprox(s, [-0.8740776099190263, -0.8221850958502244], atol = tol_test) + sol = [-0.8740776099190263, -0.8221850958502244] + if afficher + afficher_resultats_gct("GCT 3", s, sol) + end + @test isapprox(s, sol, atol = tol_test) delta = 3 # sol = min global s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol]) - @test isapprox(s, -Hess \ grad, atol = tol_test) + sol = -Hess \ grad + if afficher + afficher_resultats_gct("GCT 4", s, sol) + end + @test isapprox(s, sol, 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.0 # g^T H g < 0 première direction concave s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol]) - @test isapprox(s, -delta * grad / norm(grad), atol = tol_test) + sol = -delta * grad / norm(grad) + if afficher + afficher_resultats_gct("GCT 5", s, sol) + end + @test isapprox(s, sol, 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 isapprox(s, -delta * grad / norm(grad), atol = tol_test) + sol = -delta * grad / norm(grad) + if afficher + afficher_resultats_gct("GCT 6", s, sol) + end + @test isapprox(s, sol, 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]) @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 isapprox(s, [9.102342582478453; -4.140937032991381], atol = tol_test) + sol = [9.102342582478453; -4.140937032991381] + if afficher + afficher_resultats_gct("GCT 7", s, sol) + end + @test isapprox(s, sol, 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 isapprox(s, [0.0; 0.0], atol = tol_test) + sol = [0.0; 0.0] + if afficher + afficher_resultats_gct("GCT 8", s, sol) + end + @test isapprox(s, sol, 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]) - @test isapprox(s, [1.9059020876695578; -2.3167946029410595], atol = tol_test) + sol = [1.9059020876695578; -2.3167946029410595] + if afficher + afficher_resultats_gct("GCT 9", s, sol) + end + @test isapprox(s, sol, atol = tol_test) # le cas de test 6 # Le pas de Cauchy conduit à un gradient nul en 1 itération @@ -81,6 +118,10 @@ function tester_gct(afficher::Bool, Gradient_Conjugue_Tronque::Function) Hess = [4 0; 0 -15] delta = 2 s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol]) - @test isapprox(s, [-0.5; 0.0], atol = tol_test) + sol = [-0.5; 0.0] + if afficher + afficher_resultats_gct("GCT 10", s, sol) + end + @test isapprox(s, sol, atol = tol_test) end end diff --git a/test/tester_pas_de_cauchy.jl b/test/tester_pas_de_cauchy.jl index 3e9eccc..88dc9bd 100755 --- a/test/tester_pas_de_cauchy.jl +++ b/test/tester_pas_de_cauchy.jl @@ -23,9 +23,9 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function) s, e = Pas_De_Cauchy(g, H, delta) sol = [0; 0] if afficher - println("Cauchy 1= ", sol) + afficher_resultats_cauchy("Cauchy 1", e, s, sol) end - @test (e == 0) && (isapprox(s, [0; 0], atol = tol_erreur)) + @test (e == 0) && (isapprox(s, sol, atol = tol_erreur)) end @testset "quad 2, non saturé" begin @@ -35,7 +35,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function) s, e = Pas_De_Cauchy(g, H, delta) sol = -(norm(g)^2 / (g' * H * g)) * g if afficher - println("Cauchy 2= ", sol) + afficher_resultats_cauchy("Cauchy 2", e, s, sol) end @test (e == 1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776] end @@ -46,7 +46,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function) s, e = Pas_De_Cauchy(g, H, delta) sol = -(delta / norm(g)) * g if afficher - println("Cauchy 3= ", sol) + afficher_resultats_cauchy("Cauchy 3", e, s, sol) end @test (e == -1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776] end @@ -57,7 +57,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function) s, e = Pas_De_Cauchy(g, H, delta) sol = -(norm(g)^2 / (g' * H * g)) * g if afficher - println("Cauchy 4= ", sol) + afficher_resultats_cauchy("Cauchy 4", e, s, sol) end @test (e == 1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776] end @@ -68,7 +68,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function) s, e = Pas_De_Cauchy(g, H, delta) sol = -(delta / norm(g)) * g if afficher - println("Cauchy 5= ", sol) + afficher_resultats_cauchy("Cauchy 5", e, s, sol) end @test (e == -1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776] end @@ -79,7 +79,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function) s, e = Pas_De_Cauchy(g, H, delta) sol = -(delta / norm(g)) * g if afficher - println("Cauchy 6= ", sol) + afficher_resultats_cauchy("Cauchy 6", e, s, sol) end @test (e == -1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776] end @@ -90,7 +90,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function) s, e = Pas_De_Cauchy(g, H, delta) sol = -(delta / norm(g)) * g if afficher - println("Cauchy 7= ", sol) + afficher_resultats_cauchy("Cauchy 7", e, s, sol) end @test (e == -1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776] end diff --git a/test/tester_regions_de_confiance.jl b/test/tester_regions_de_confiance.jl index c275bb9..f5f5a9d 100755 --- a/test/tester_regions_de_confiance.jl +++ b/test/tester_regions_de_confiance.jl @@ -76,7 +76,7 @@ function tester_regions_de_confiance(afficher::Bool, Regions_De_Confiance::Funct # cas de test max_iter x_min22, fmin22, flag22, nb_iters22 = Regions_De_Confiance("cauchy", fct2, grad_fct2, hess_fct2, pts1.x022, options_max_iter) if (afficher) - afficher_resultats("régions de confiance avec " * "cauchy", "fonction 2", "x022", x_min22, fmin22, flag22, sol_exacte_fct2, nb_iters22) + afficher_resultats("régions de confiance (itermax) avec " * "cauchy", "fonction 2", "x022", x_min22, fmin22, flag22, sol_exacte_fct2, nb_iters22) end @test flag22 == 3