From c071194284604b471d735e06d4393679a677f76a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Laure=CE=B7t?= Date: Thu, 16 Dec 2021 10:34:56 +0100 Subject: [PATCH] feat: avancement --- src/Lagrangien_Augmente.jl | 10 +- src/Regions_De_Confiance.jl | 4 +- src/TP-Projet-Optinum.ipynb | 627 ++++++++++++++++++++++++++++-------- test/fonctions_de_tests.jl | 125 ++++--- test/imports_boilerplate.jl | 30 ++ test/new_runtests.jl | 60 +--- 6 files changed, 625 insertions(+), 231 deletions(-) create mode 100644 test/imports_boilerplate.jl diff --git a/src/Lagrangien_Augmente.jl b/src/Lagrangien_Augmente.jl index 3ca707f..17113f8 100755 --- a/src/Lagrangien_Augmente.jl +++ b/src/Lagrangien_Augmente.jl @@ -68,13 +68,10 @@ function Lagrangien_Augmente(algo, f::Function, c::Function, gradf::Function, he tau = options[6] end - delta = 2 # TODO: changer ? - _L(x, lambda, mu) = f(x) + lambda' * c(x) + mu / 2 * norm(c(x))^2 _gradL(x, lambda, mu) = gradf(x) + lambda' * grad_c(x) + mu * c(x) * grad_c(x) _hessL(x, lambda, mu) = hessf(x) + lambda' * hess_c(x) + mu * (c(x) * hess_c(x) + grad_c(x) * grad_c(x)') - n = length(x_0) flag = -1 eta_chap_0 = 0.1258925 @@ -101,7 +98,7 @@ function Lagrangien_Augmente(algo, f::Function, c::Function, gradf::Function, he if algo == "newton" x_k1, _, _, _ = Algorithme_De_Newton(L, gradL, hessL, x_k, [itermax epsilon tol]) elseif algo == "cauchy" || algo == "gct" - x_k1, _, _, _ = Regions_De_Confiance(algo, L, gradL, hessL, x_k, [10 0.5 2 0.25 0.75 2 itermax epsilon tol]) + x_k1, _, _, _ = Regions_De_Confiance(algo, L, gradL, hessL, x_k, [10.0 0.5 2 0.25 0.75 2.0 itermax epsilon tol]) end if norm(c(x_k1)) <= eta_k # b @@ -121,7 +118,7 @@ function Lagrangien_Augmente(algo, f::Function, c::Function, gradf::Function, he flag = 0 break elseif k >= max_iter - flag = 3 + flag = 1 break end @@ -132,6 +129,9 @@ function Lagrangien_Augmente(algo, f::Function, c::Function, gradf::Function, he end + # println("lambda_k=", lambda_k) + # println("mu_k=", mu_k) + xmin = x_k1 f_min = f(xmin) return xmin, f_min, flag, k diff --git a/src/Regions_De_Confiance.jl b/src/Regions_De_Confiance.jl index 0de695a..70cd324 100644 --- a/src/Regions_De_Confiance.jl +++ b/src/Regions_De_Confiance.jl @@ -86,7 +86,7 @@ function Regions_De_Confiance(algo, f::Function, gradf::Function, hessf::Functio delta_k = delta0 delta_k1 = delta0 - m_k(x, s) = f(x) + gradf(x)' * s + 0.5 * s' * hessf(x) * s + m_k(x, s) = f(x) + gradf(x)' * s + s' * hessf(x) * s / 2 if norm(gradf(x_k1)) <= max(Tol_rel * norm(gradf(x0)), Tol_abs) flag = 0 @@ -99,7 +99,7 @@ function Regions_De_Confiance(algo, f::Function, gradf::Function, hessf::Functio if algo == "gct" s_k = Gradient_Conjugue_Tronque(gradf(x_k), hessf(x_k), [delta_k max_iter Tol_rel]) elseif algo == "cauchy" - s_k, e_k = Pas_De_Cauchy(gradf(x_k), hessf(x_k), delta_k) + s_k, _ = Pas_De_Cauchy(gradf(x_k), hessf(x_k), delta_k) end # b. Evaluer f(x_k + s_k) diff --git a/src/TP-Projet-Optinum.ipynb b/src/TP-Projet-Optinum.ipynb index 1e739dd..a0148c7 100644 --- a/src/TP-Projet-Optinum.ipynb +++ b/src/TP-Projet-Optinum.ipynb @@ -14,66 +14,60 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 66, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------------------------\n", + "\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 3 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 3 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 3 seconds (262 already precompiled, 2 skipped during auto due to previous errors)\n" + ] + }, + { + "data": { + "text/plain": [ + "tester_lagrangien_augmente" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "using Pkg\n", - "Pkg.status()\n", - "Pkg.add(\"DifferentialEquations\")\n", - "# Pkg.add(\"LinearAlgebra\");\n", - "# Pkg.add(\"Markdown\")\n", - "# using Documenter\n", - "using LinearAlgebra\n", - "using Markdown\n", - "# using TestOptinum\n", - "using Test\n", - "\n", - "include(\"../test/new_runtests.jl\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# 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_f0 = -pi / 2\n", - "\n", - "# Fonction f1\n", - "# -----------\n", - "f1(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 f1\n", - "grad_f1(x) = [\n", - " 4 * (x[1] + x[2] + x[3] - 3) + 2 * (x[1] - x[2])\n", - " 4 * (x[1] + x[2] + x[3] - 3) - 2 * (x[1] - x[2]) + 2 * (x[2] - x[3])\n", - " 4 * (x[1] + x[2] + x[3] - 3) - 2 * (x[2] - x[3])\n", - "]\n", - "# la hessienne de la fonction f1\n", - "hess_f1(x) = [6 2 4; 2 8 2; 4 2 6]\n", - "sol_exacte_f1 = [1, 1, 1]\n", - "\n", - "# Fonction f2\n", - "# -----------\n", - "f2(x) = (100 * x[2] - x[1]^2)^2 + (1 - x[1])^2\n", - "# la gradient de la fonction f2\n", - "grad_f2(x) = [\n", - " (2 * (200 * x[1]^3 - 200 * x[1] * x[2] + x[1] - 1))\n", - " (200 * (x[2] - x[1]^2))\n", - "]\n", - "# la hessienne de la fonction f2\n", - "hess_f2(x) = [\n", - " (-400*(x[2]-x[1]^2)+800*x[1]^2+2) (-400*x[1])\n", - " (-400*x[1]) (200)\n", - "]\n", - "sol_exacte_f2 = [1, 1 / 100]" + "include(\"../test/imports_boilerplate.jl\")" ] }, { @@ -90,62 +84,139 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Newton appliqué à fct0 au point initial -1.5707963267948966 :\u001b[22m\u001b[39m\n", + " * xsol = -1.5707963267948966\n", + " * f(xsol) = -1.0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte : -1.5707963267948966\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Newton appliqué à fct0 au point initial -1.0707963267948966 :\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 : Newton appliqué à fct0 au point initial 1.5707963267948966 :\u001b[22m\u001b[39m\n", + " * xsol = 1.5707963267948966\n", + " * f(xsol) = 1.0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte : -1.5707963267948966\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Newton appliqué à fct1 au point initial [1, 1, 1] :\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 : Newton appliqué à fct1 au point initial [1, 0, 0] :\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 : Newton appliqué à fct1 au point initial [10.0, 3.0, -2.2] :\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 : Newton appliqué à fct2 au point initial [1, 1] :\u001b[22m\u001b[39m\n", + " * xsol = [1, 1]\n", + " * f(xsol) = 0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte : [1, 1]\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Newton appliqué à fct2 au point initial [-1.2, 1.0] :\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 : Newton appliqué à fct2 au point initial [10, 0] :\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" + ] + } + ], "source": [ - "# Affichage les sorties de l'algorithme de Newton\n", - "function my_afficher_resultats(algo, nom_fct, point_init, xmin, fxmin, flag, sol_exacte, nbiters)\n", - " println(\"-------------------------------------------------------------------------\")\n", - " printstyled(\"Résultats de : \", algo, \" appliqué à \", nom_fct, \" au point initial \", point_init, \":\\n\", bold = true, color = :blue)\n", - " println(\" * xsol = \", xmin)\n", - " println(\" * f(xsol) = \", fxmin)\n", - " println(\" * nb_iters = \", nbiters)\n", - " println(\" * flag = \", flag)\n", - " println(\" * sol_exacte : \", sol_exacte)\n", - "end\n", - "\n", "options = []\n", "\n", - "x0 = sol_exacte_f0\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_f0, nb_iters)\n", + "x0 = sol_exacte_fct0\n", + "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct0, grad_fct0, hess_fct0, x0, options)\n", + "afficher_resultats(\"Newton\", \"fct0\", x0, xmin, f_min, flag, sol_exacte_fct0, 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_f0, nb_iters)\n", + "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct0, grad_fct0, hess_fct0, x0, options)\n", + "afficher_resultats(\"Newton\", \"fct0\", x0, xmin, f_min, flag, sol_exacte_fct0, 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_f0, nb_iters)\n", + "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct0, grad_fct0, hess_fct0, x0, options)\n", + "afficher_resultats(\"Newton\", \"fct0\", x0, xmin, f_min, flag, sol_exacte_fct0, nb_iters)\n", "\n", - "x0 = sol_exacte_f1\n", - "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(f1, grad_f1, hess_f1, x0, options)\n", - "my_afficher_resultats(\"Newton\", \"f1\", x0, xmin, f_min, flag, sol_exacte_f1, nb_iters)\n", + "x0 = sol_exacte_fct1\n", + "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, x0, options)\n", + "afficher_resultats(\"Newton\", \"fct1\", x0, xmin, f_min, flag, sol_exacte_fct1, nb_iters)\n", "x0 = [1, 0, 0]\n", - "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(f1, grad_f1, hess_f1, x0, options)\n", - "my_afficher_resultats(\"Newton\", \"f1\", x0, xmin, f_min, flag, sol_exacte_f1, nb_iters)\n", + "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, x0, options)\n", + "afficher_resultats(\"Newton\", \"fct1\", x0, xmin, f_min, flag, sol_exacte_fct1, nb_iters)\n", "x0 = [10, 3, -2.2]\n", - "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(f1, grad_f1, hess_f1, x0, options)\n", - "my_afficher_resultats(\"Newton\", \"f1\", x0, xmin, f_min, flag, sol_exacte_f1, nb_iters)\n", + "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, x0, options)\n", + "afficher_resultats(\"Newton\", \"fct1\", x0, xmin, f_min, flag, sol_exacte_fct1, nb_iters)\n", "\n", - "x0 = sol_exacte_f2\n", - "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(f2, grad_f2, hess_f2, x0, options)\n", - "my_afficher_resultats(\"Newton\", \"f2\", x0, xmin, f_min, flag, sol_exacte_f2, nb_iters)\n", + "x0 = sol_exacte_fct2\n", + "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, x0, options)\n", + "afficher_resultats(\"Newton\", \"fct2\", x0, xmin, f_min, flag, sol_exacte_fct2, nb_iters)\n", "x0 = [-1.2, 1]\n", - "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(f2, grad_f2, hess_f2, x0, options)\n", - "my_afficher_resultats(\"Newton\", \"f2\", x0, xmin, f_min, flag, sol_exacte_f2, nb_iters)\n", + "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, x0, options)\n", + "afficher_resultats(\"Newton\", \"fct2\", x0, xmin, f_min, flag, sol_exacte_fct2, nb_iters)\n", "x0 = [10, 0]\n", - "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(f2, grad_f2, hess_f2, x0, options)\n", - "my_afficher_resultats(\"Newton\", \"f2\", x0, xmin, f_min, flag, sol_exacte_f2, nb_iters)\n", + "xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, x0, options)\n", + "afficher_resultats(\"Newton\", \"fct2\", x0, xmin, f_min, flag, sol_exacte_fct2, nb_iters)\n", "# x0 = [0, 1 / 200 + 1 / 10^12] # explose !\n", - "# xmin, f_min, flag, nb_iters = Algorithme_De_Newton(f2, grad_f2, hess_f2, x0, options)\n", - "# my_afficher_resultats(\"Newton\", \"f2\", x0, xmin, f_min, flag, sol_exacte_f2, nb_iters)" + "# xmin, f_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, x0, options)\n", + "# afficher_resultats(\"Newton\", \"fct2\", x0, xmin, f_min, flag, sol_exacte_fct2, nb_iters)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 48, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\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 14 \u001b[39m\u001b[36m 14\u001b[39m\n" + ] + }, + { + "data": { + "text/plain": [ + "Test.DefaultTestSet(\"L'algo de Newton\", Any[Test.DefaultTestSet(\"Cas test 1 x0 = solution\", Any[Test.DefaultTestSet(\"solution\", Any[], 1, false, false), Test.DefaultTestSet(\"itération\", Any[], 1, false, false)], 0, false, false), Test.DefaultTestSet(\"Cas test 1 x0 = x011\", Any[Test.DefaultTestSet(\"solution\", Any[], 1, false, false), Test.DefaultTestSet(\"itération\", Any[], 1, false, false)], 0, false, false), Test.DefaultTestSet(\"Cas test 1 x0 = x012\", Any[Test.DefaultTestSet(\"solution\", Any[], 1, false, false), Test.DefaultTestSet(\"itération\", Any[], 1, false, false)], 0, false, false), Test.DefaultTestSet(\"Cas test 2 x0 = solution\", Any[Test.DefaultTestSet(\"solution\", Any[], 1, false, false), Test.DefaultTestSet(\"itération\", Any[], 1, false, false)], 0, false, false), Test.DefaultTestSet(\"Cas test 2 x0 = x021\", Any[Test.DefaultTestSet(\"solution\", Any[], 1, false, false), Test.DefaultTestSet(\"itération\", Any[], 1, false, false)], 0, false, false), Test.DefaultTestSet(\"Cas test 2 x0 = x022\", Any[Test.DefaultTestSet(\"solution\", Any[], 1, false, false), Test.DefaultTestSet(\"itération\", Any[], 1, false, false)], 0, false, false), Test.DefaultTestSet(\"Cas test 2 x0 = x023\", Any[Test.DefaultTestSet(\"solution\", Any[], 1, false, false), Test.DefaultTestSet(\"exception\", Any[], 1, false, false)], 0, false, false)], 0, false, false)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "tester_algo_newton(false, Algorithme_De_Newton)" ] @@ -201,9 +272,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 1\u001b[22m\u001b[39m\n", + " * s = [0, 0]\n", + " * e = 0\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 2\u001b[22m\u001b[39m\n", + " * s = [-0.9230769230769234, -0.30769230769230776]\n", + " * e = 1\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 3\u001b[22m\u001b[39m\n", + " * s = [0.8944271909999159, -0.4472135954999579]\n", + " * e = -1\n" + ] + } + ], "source": [ "function my_afficher_resultats_cauchy(algo, s, e)\n", " println(\"-------------------------------------------------------------------------\")\n", @@ -233,18 +323,68 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cauchy 4 = [5.000000000000001, -2.5000000000000004]\n", + "Cauchy 5= [4.47213595499958, -2.23606797749979]\n", + "Cauchy 6= [-4.743416490252569, -1.5811388300841895]\n", + "Cauchy 6= [-2.23606797749979, -4.47213595499958]\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" + ] + }, + { + "data": { + "text/plain": [ + "Test.DefaultTestSet(\"Pas de Cauchy\", Any[Test.DefaultTestSet(\"g = 0\", Any[], 1, false, false), Test.DefaultTestSet(\"quad 2, non saturé\", Any[], 1, false, false), Test.DefaultTestSet(\"quad 2, saturé\", Any[], 1, false, false), Test.DefaultTestSet(\"quad 3, non saturé\", Any[], 1, false, false), Test.DefaultTestSet(\"quad 3, saturé\", Any[], 1, false, false), Test.DefaultTestSet(\"quad 3, g'*H*g <0 saturé\", Any[], 1, false, false), Test.DefaultTestSet(\"quad 3, g'*H*g = 0 saturé\", Any[], 1, false, false)], 0, false, false)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "tester_pas_de_cauchy(false, Pas_De_Cauchy)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : RC-Cauchy appliqué à f0 au point initial -1.5707963267948966:\u001b[22m\u001b[39m\n", + " * xsol = -1.5707963267948966\n", + " * f(xsol) = -1.0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte : -1.5707963267948966\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : RC-Cauchy appliqué à f1 au point initial [1, 1, 1]:\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 : RC-Cauchy appliqué à f2 au point initial [1.0, 0.01]:\u001b[22m\u001b[39m\n", + " * xsol = [1.0, 0.01]\n", + " * f(xsol) = 0.0\n", + " * nb_iters = 10000\n", + " * flag = 3\n", + " * sol_exacte : [1.0, 0.01]\n" + ] + } + ], "source": [ "options = [10, 0.5, 2.00, 0.25, 0.75, 2, 10000, sqrt(eps()), 1e-15]\n", "algo = \"cauchy\"\n", @@ -301,9 +441,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 1\u001b[22m\u001b[39m\n", + " * s = [2.220446049250313e-16, 1.0]\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 2\u001b[22m\u001b[39m\n", + " * s = [0.0, 0.0]\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 3\u001b[22m\u001b[39m\n", + " * s = [-0.4743416490252569, -0.15811388300841897]\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 4\u001b[22m\u001b[39m\n", + " * s = [-0.8740776099190263, -0.8221850958502243]\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Cauchy 5\u001b[22m\u001b[39m\n", + " * s = [-0.8571428571428571, -0.9999999999999998]\n" + ] + } + ], "source": [ "function my_afficher_resultats_gct(algo, s)\n", " println(\"-------------------------------------------------------------------------\")\n", @@ -344,18 +506,64 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\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 9 \u001b[39m\u001b[36m 9\u001b[39m\n" + ] + }, + { + "data": { + "text/plain": [ + "Test.DefaultTestSet(\"Gradient-CT\", Any[], 9, false, false)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "tester_gct(false, Gradient_Conjugue_Tronque)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 54, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : RC-GCT appliqué à f0 au point initial -1.5707963267948966:\u001b[22m\u001b[39m\n", + " * xsol = -1.5707963267948966\n", + " * f(xsol) = -1.0\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte : -1.5707963267948966\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : RC-GCT appliqué à f1 au point initial [1, 1, 1]:\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 : RC-GCT appliqué à f2 au point initial [1.0, 0.01]:\u001b[22m\u001b[39m\n", + " * xsol = [1.0, 0.01]\n", + " * f(xsol) = 0.0\n", + " * nb_iters = 10000\n", + " * flag = 3\n", + " * sol_exacte : [1.0, 0.01]\n" + ] + } + ], "source": [ "options = [10, 0.5, 2.00, 0.25, 0.75, 2, 10000, sqrt(eps()), 1e-15]\n", "algo = \"gct\"\n", @@ -375,9 +583,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iters = 864\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 10 \u001b[39m\u001b[36m 10\u001b[39m\n" + ] + }, + { + "data": { + "text/plain": [ + "Test.DefaultTestSet(\"La méthode des RC \", Any[Test.DefaultTestSet(\"avec Cauchy \", Any[], 5, false, false), Test.DefaultTestSet(\"avec GCT \", Any[], 5, false, false)], 0, false, false)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "tester_regions_de_confiance(false, Regions_De_Confiance)" ] @@ -430,9 +657,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 56, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Lagrangien augmenté avec newton appliqué à fonction 1 au point initial x01 :\u001b[22m\u001b[39m\n", + " * xsol = [0, 1, 1]\n", + " * f(xsol) = 3\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte : [0.5, 1.25, 0.5]\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Lagrangien augmenté avec cauchy appliqué à fonction 1 au point initial x01 :\u001b[22m\u001b[39m\n", + " * xsol = [0, 1, 1]\n", + " * f(xsol) = 3\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte : [0.5, 1.25, 0.5]\n", + "-------------------------------------------------------------------------\n", + "\u001b[34m\u001b[1mRésultats de : Lagrangien augmenté avec gct appliqué à fonction 1 au point initial x01 :\u001b[22m\u001b[39m\n", + " * xsol = [0, 1, 1]\n", + " * f(xsol) = 3\n", + " * nb_iters = 0\n", + " * flag = 0\n", + " * sol_exacte : [0.5, 1.25, 0.5]\n" + ] + } + ], "source": [ "function afficher_resultats(algo,nom_fct,point_init,xmin,fxmin,flag,sol_exacte,nbiters)\n", "\tprintln(\"-------------------------------------------------------------------------\")\n", @@ -482,42 +737,158 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 57, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n", + "Lagrangien augmenté | \u001b[32m 12 \u001b[39m\u001b[36m 12\u001b[39m\n" + ] + }, + { + "data": { + "text/plain": [ + "Test.DefaultTestSet(\"Lagrangien augmenté \", Any[Test.DefaultTestSet(\"Avec newton\", Any[], 4, false, false), Test.DefaultTestSet(\"Avec gct\", Any[], 4, false, false), Test.DefaultTestSet(\"Avec cauchy\", Any[], 4, false, false)], 0, false, false)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "tester_lagrangien_augmente(false, Lagrangien_Augmente)" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 58, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "algo=newton, tau=0.01 \t--> iter=100 fxmin=11.111111108395063 flag=1\n", + "algo=newton, tau=0.1 \t--> iter=100 fxmin=11.111111108395065 flag=1\n", + "algo=newton, tau=1.0 \t--> iter=100 fxmin=4.280618311533889 flag=1\n", + "algo=newton, tau=10.0 \t--> iter=5 fxmin=2.250000814411402 flag=0\n", + "algo=newton, tau=100.0 \t--> iter=4 fxmin=2.2500000022152014 flag=0\n", + "algo=newton, tau=1000.0 \t--> iter=3 fxmin=2.2500000005005116 flag=0\n", + "algo=cauchy, tau=0.01 \t--> iter=100 fxmin=9.972299093706013 flag=1\n", + "algo=cauchy, tau=0.1 \t--> iter=100 fxmin=9.972299137559094 flag=1\n", + "algo=cauchy, tau=1.0 \t--> iter=100 fxmin=4.058286995337872 flag=1\n", + "algo=cauchy, tau=10.0 \t--> iter=100 fxmin=2.2502165830370076 flag=1\n", + "algo=cauchy, tau=100.0 \t--> iter=100 fxmin=2.314845242402915 flag=1\n", + "algo=cauchy, tau=1000.0 \t--> iter=100 fxmin=2.412284973385117 flag=1\n", + "algo=gct, tau=0.01 \t--> iter=100 fxmin=11.111111108395058 flag=1\n", + "algo=gct, tau=0.1 \t--> iter=100 fxmin=11.111110839506175 flag=1\n", + "algo=gct, tau=1.0 \t--> iter=100 fxmin=4.280618311533889 flag=1\n", + "algo=gct, tau=10.0 \t--> iter=5 fxmin=2.250000814411402 flag=0\n", + "algo=gct, tau=100.0 \t--> iter=4 fxmin=2.250000002215201 flag=0\n", + "algo=gct, tau=1000.0 \t--> iter=3 fxmin=2.2500000005005116 flag=0\n" + ] + } + ], "source": [ - "## Interprétation\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.\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\n" + "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" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "# TODO\n", - "COMPLETER LES TESTS pour avoir tous les flags, tous les if \\\n", - "répondre aux question" + "## Interprétation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Vos réponses?\n" + "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" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------------------------------\n", + "algo=newton, tau=0.01 \t--> iter=100 fxmin=11.111111108395063 flag=1\n", + "-----------------------------------------\n", + "algo=newton, tau=0.1 \t--> iter=100 fxmin=11.111111108395065 flag=1\n", + "-----------------------------------------\n", + "algo=newton, tau=1.0 \t--> iter=100 fxmin=4.280618311533889 flag=1\n", + "-----------------------------------------\n", + "algo=newton, tau=10.0 \t--> iter=5 fxmin=2.250000814411402 flag=0\n", + "-----------------------------------------\n", + "algo=newton, tau=100.0 \t--> iter=4 fxmin=2.2500000022152014 flag=0\n", + "-----------------------------------------\n", + "algo=newton, tau=1000.0 \t--> iter=3 fxmin=2.2500000005005116 flag=0\n", + "-----------------------------------------\n", + "algo=cauchy, tau=0.01 \t--> iter=100 fxmin=9.972299093706013 flag=1\n", + "-----------------------------------------\n", + "algo=cauchy, tau=0.1 \t--> iter=100 fxmin=9.972299137559094 flag=1\n", + "-----------------------------------------\n", + "algo=cauchy, tau=1.0 \t--> iter=100 fxmin=4.058286995337872 flag=1\n", + "-----------------------------------------\n", + "algo=cauchy, tau=10.0 \t--> iter=100 fxmin=2.2502165830370076 flag=1\n", + "-----------------------------------------\n", + "algo=cauchy, tau=100.0 \t--> iter=100 fxmin=2.314845242402915 flag=1\n", + "-----------------------------------------\n", + "algo=cauchy, tau=1000.0 \t--> iter=100 fxmin=2.412284973385117 flag=1\n", + "-----------------------------------------\n", + "algo=gct, tau=0.01 \t--> iter=100 fxmin=11.111111108395058 flag=1\n", + "-----------------------------------------\n", + "algo=gct, tau=0.1 \t--> iter=100 fxmin=11.111110839506175 flag=1\n", + "-----------------------------------------\n", + "algo=gct, tau=1.0 \t--> iter=100 fxmin=4.280618311533889 flag=1\n", + "-----------------------------------------\n", + "algo=gct, tau=10.0 \t--> iter=5 fxmin=2.250000814411402 flag=0\n", + "-----------------------------------------\n", + "algo=gct, tau=100.0 \t--> iter=4 fxmin=2.250000002215201 flag=0\n", + "-----------------------------------------\n", + "algo=gct, tau=1000.0 \t--> iter=3 fxmin=2.2500000005005116 flag=0\n" + ] + } + ], + "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", + " println(\"-----------------------------------------\")\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" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Vos réponses\n", + "\n", + "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" ] } ], diff --git a/test/fonctions_de_tests.jl b/test/fonctions_de_tests.jl index d568f43..54d42d1 100755 --- a/test/fonctions_de_tests.jl +++ b/test/fonctions_de_tests.jl @@ -6,7 +6,7 @@ Ce fichier contient toutes fonctions utilisés dans les tests des algorithmes : """ # Les points initiaux -# pour les problèmes sans contraintes +## pour les problèmes sans contraintes struct Pts_sans_contraintes x011 x012 @@ -14,77 +14,98 @@ struct Pts_sans_contraintes x022 x023 end -x011 = [1; 0; 0] -x012 = [10; 3; -2.2] -x021 = [-1.2; 1] -x022 = [10; 0] -x023 = [0; 1/200 + 1/10^12] -# les points initiaux utilisés dans les problèmes sans contraintes -pts1 = Pts_sans_contraintes(x011,x012,x021,x022,x023) +pts1 = Pts_sans_contraintes( + [1; 0; 0], + [10; 3; -2.2], + [-1.2; 1], + [10; 0], + [0; 1 / 200 + 1 / 10^12] +) -# pour les problèmes avec contraintes +## pour les problèmes avec contraintes struct Pts_avec_contraintes x01 x02 x03 x04 end -x01 = [0; 1; 1] -x02 = [0.5; 1.25; 1] -x03 = [1; 0] -x04 = [sqrt(3)/2 ;sqrt(3)/2] +pts2 = Pts_avec_contraintes( + [0; 1; 1], + [0.5; 1.25; 1], + [1; 0], + [sqrt(3) / 2; sqrt(3) / 2] +) -pts2 = Pts_avec_contraintes(x01,x02,x03,x04) +# Fonctions de test -# Les solutions exactes -# sol_exacte_fct1 = -hess_fct1(x011)\grad_fct1(zero(similar(x011))) -sol_exacte_fct1 = [1;1;1] -sol_exacte_fct2 = [1;1] +""" +La zéroième fonction de test + +# Expression + fct0(x) = sin(x) +""" +fct0(x) = sin.(x) +# la gradient de la fonction fct0 +grad_fct0(x) = cos.(x) +# la hessienne de la fonction fct0 +hess_fct0(x) = -sin.(x) +# solutions de la fonction fct0 +sol_exacte_fct0 = -pi / 2 """ La première fonction de test # Expression - fct1(x) = 2*(x[1]+x[2]+x[3]-3)^2 + (x[1]-x[2])^2 + (x[2]-x[3])^2 - + fct1(x) = 2 * (x[1] + x[2] + x[3] - 3)^2 + (x[1] - x[2])^2 + (x[2] - x[3])^2 """ -fct1(x) = 2*(x[1]+x[2]+x[3]-3)^2 + (x[1]-x[2])^2 + (x[2]-x[3])^2 +fct1(x) = 2 * (x[1] + x[2] + x[3] - 3)^2 + (x[1] - x[2])^2 + (x[2] - x[3])^2 # la gradient de la fonction fct1 -function grad_fct1(x) - y1 = 4*(x[1]+x[2]+x[3]-3) + 2*(x[1]-x[2]) - y2 = 4*(x[1]+x[2]+x[3]-3) - 2*(x[1]-x[2]) +2*(x[2]-x[3]) - y3 = 4*(x[1]+x[2]+x[3]-3) - 2*(x[2]-x[3]) - return [y1;y2;y3] -end +grad_fct1(x) = [ + 4 * (x[1] + x[2] + x[3] - 3) + 2 * (x[1] - x[2]) + 4 * (x[1] + x[2] + x[3] - 3) - 2 * (x[1] - x[2]) + 2 * (x[2] - x[3]) + 4 * (x[1] + x[2] + x[3] - 3) - 2 * (x[2] - x[3]) +] # la hessienne de la fonction fct1 -hess_fct1(x) = [6 2 4;2 8 2;4 2 6] +hess_fct1(x) = [ + 6 2 4 + 2 8 2 + 4 2 6 +] +# solutions de la fonction fct1 +sol_exacte_fct1 = [1; 1; 1] # = -hess_fct1(x011) \ grad_fct1(zero(similar(x011))) +sol_fct1_augm = [0.5; 1.25; 0.5] # pour les problèmes avec contraintes + """ -La première fonction de test +La deuxième fonction de test # Expression - fct2(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2 - + fct2(x) = 100 * (x[2] - x[1]^2)^2 + (1 - x[1])^2 """ -fct2(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2 +fct2(x) = 100 * (x[2] - x[1]^2)^2 + (1 - x[1])^2 # la gradient de la fonction fct2 -grad_fct2(x)=[-400*x[1]*(x[2]-x[1]^2)-2*(1-x[1]) ; 200*(x[2]-x[1]^2)] +grad_fct2(x) = [ + -400 * x[1] * (x[2] - x[1]^2) - 2 * (1 - x[1]) + 200 * (x[2] - x[1]^2) +] #la hessienne de la fonction fct2 -hess_fct2(x)=[-400*(x[2]-3*x[1]^2)+2 -400*x[1];-400*x[1] 200] +hess_fct2(x) = [ + -400*(x[2]-3*x[1]^2)+2 -400*x[1] + -400*x[1] 200 +] +# solutions de la fonction fct2 +sol_exacte_fct2 = [1; 1] +sol_fct2_augm = [0.9072339605110892; 0.82275545631455] # pour les problèmes avec contraintes -# Pour les problèmes avec contraintes -# solutions -sol_fct1_augm = [0.5 ; 1.25 ; 0.5] -sol_fct2_augm = [0.9072339605110892; 0.82275545631455] """ La première contrainte # Expression contrainte1(x) = x[1]+x[3]-1 """ -contrainte1(x) = x[1]+x[3]-1 -grad_contrainte1(x) = [1 ;0; 1] -hess_contrainte1(x) = [0 0 0;0 0 0;0 0 0] +contrainte1(x) = x[1] + x[3] - 1 +grad_contrainte1(x) = [1; 0; 1] +hess_contrainte1(x) = [0 0 0; 0 0 0; 0 0 0] """ La deuxième contrainte @@ -92,17 +113,17 @@ La deuxième contrainte # Expression contrainte2(x) = (x[1]^2) + (x[2]^2) -1.5 """ -contrainte2(x) = (x[1]^2) + (x[2]^2) -1.5 -grad_contrainte2(x) = [2*x[1] ;2*x[2]] -hess_contrainte2(x) = [2 0;0 2] +contrainte2(x) = (x[1]^2) + (x[2]^2) - 1.5 +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, point_init, xmin, fxmin, flag, sol_exacte, nbiters) + println("-------------------------------------------------------------------------") + printstyled("Résultats de : " * algo * " appliqué à " * nom_fct * " au point initial ", point_init, " :\n", bold = true, color = :blue) + println(" * xsol = ", xmin) + println(" * f(xsol) = ", fxmin) + println(" * nb_iters = ", nbiters) + println(" * flag = ", flag) + println(" * sol_exacte : ", sol_exacte) end diff --git a/test/imports_boilerplate.jl b/test/imports_boilerplate.jl new file mode 100644 index 0000000..e5778ca --- /dev/null +++ b/test/imports_boilerplate.jl @@ -0,0 +1,30 @@ +using Pkg +Pkg.status() +Pkg.add("DifferentialEquations") +Pkg.add("LinearAlgebra"); +Pkg.add("Markdown") +using LinearAlgebra +using Markdown +using Test +# using TestOptinum +# using Documenter + +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") \ No newline at end of file diff --git a/test/new_runtests.jl b/test/new_runtests.jl index 5456299..39f453a 100644 --- a/test/new_runtests.jl +++ b/test/new_runtests.jl @@ -1,49 +1,21 @@ -using Markdown -using Test -using LinearAlgebra +include("imports_boilerplate.jl") -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") +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) -#include("cacher_stacktrace.jl") -#cacher_stacktrace() + # 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) -# Tolérance pour les tests d'égalité -tol_erreur = sqrt(eps()) + # Tester l'algorithme des Régions de confiance avec PasdeCauchy | GCT + tester_regions_de_confiance(affiche, Regions_De_Confiance) -## 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 + # Tester l'algorithme du Lagrangien Augmenté + tester_lagrangien_augmente(affiche, Lagrangien_Augmente) +end