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