From 743fd9250a5429e13aa049ee4c6bf3c2353246ab Mon Sep 17 00:00:00 2001 From: relmo Date: Sun, 5 Jul 2020 16:59:57 +0200 Subject: [PATCH] updates --- src/Algorithme_De_Newton.jl | 40 ++++++++++++++++---------------- src/Gradient_Conjugue_Tronque.jl | 12 +++++----- src/Lagrangien_Augmente.jl | 36 ++++++++++++++-------------- src/Pas_De_Cauchy.jl | 12 +++++----- src/Regions_De_Confiance.jl | 38 ++++++++++++++++-------------- test/runtests.jl | 4 ++-- 6 files changed, 72 insertions(+), 70 deletions(-) diff --git a/src/Algorithme_De_Newton.jl b/src/Algorithme_De_Newton.jl index 379b4d1..909f8bf 100644 --- a/src/Algorithme_De_Newton.jl +++ b/src/Algorithme_De_Newton.jl @@ -7,24 +7,24 @@ xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option) ``` # Entrées : - * **f** : la fonction à minimiser - * **gradf** : le gradient de la fonction f - * **hessf** : la Hessienne de la fonction f - * **x0** : première approximation de la solution cherchée - * **options** : - * **eps** : pour fixer les conditions d'arrêt - * **max_iter** : le nombre maximal d'iterations - * **tol** : pour les conditions d'arrêts + * **f** : (Function) la fonction à minimiser + * **gradf** : (Function) le gradient de la fonction f + * **hessf** : (Function) la Hessienne de la fonction f + * **x0** : (Array{Float,1}) première approximation de la solution cherchée + * **options** : (Array{Float,1}) + * **max_iter** : le nombre maximal d'iterations + * **tolCN1** : la tolérence pour la condition nécessaire d'ordre 1 + * **tol** : la tolérence pour les autres critères d'arrêt # Sorties: - * **xmin** : une approximation de la solution du problème : ``\min_{x \in \mathbb{R}^{n}} f(x)`` - * **f_min** : ``f(x_{min})`` - * **flag** : entier indiquant le critère sur lequel le programme à arrêter + * **xmin** : (Array{Float,1}) une approximation de la solution du problème : ``\min_{x \in \mathbb{R}^{n}} f(x)`` + * **f_min** : (Float) ``f(x_{min})`` + * **flag** : (Integer) indique le critère sur lequel le programme à arrêter * **0** : Convergence * **1** : stagnation du xk * **2** : stagnation du f * **3** : nombre maximal d'itération dépassé - * **nb_iters** : le nombre d'itérations faites par le programme + * **nb_iters** : (Integer) le nombre d'itérations faites par le programme # Exemple d'appel ```@example @@ -39,17 +39,17 @@ xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f,gradf,hessf,x0,options) """ function Algorithme_De_Newton(f::Function,gradf::Function,hessf::Function,x0,options) - "# Si option est vide on initialise les 3 paramètres par défaut" + "# Si options == [] on prends les paramètres par défaut" if options == [] - eps = 1e-8 - max_iter = 100 - tol = 1e-15 + max_iter = 100 + tolCN1 = 1e-15 + tol = 1e-15 else - eps = options[1] - max_iter = options[2] - tol = options[3] - + max_iter = options[1] + tolCN1 = options[2] + tol = options[3] end + eps = 1e-8 n = length(x0) xmin = zeros(n) diff --git a/src/Gradient_Conjugue_Tronque.jl b/src/Gradient_Conjugue_Tronque.jl index a03f577..7e69c67 100644 --- a/src/Gradient_Conjugue_Tronque.jl +++ b/src/Gradient_Conjugue_Tronque.jl @@ -4,20 +4,20 @@ Minimise le problème : ``min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs # Syntaxe ```julia -sk = Gradient_Conjugue_Tronque(gradfk,hessfk,option) +sk = Gradient_Conjugue_Tronque(fk,gradfk,hessfk,option) ``` -# Entrées : - * **gradfk** : le gradient de la fonction f appliqué au point xk - * **hessfk** : la Hessienne de la fonction f appliqué au point xk - * **options** +# Entrées : + * **gradfk** : (Array{Float,1}) le gradient de la fonction f appliqué au point xk + * **hessfk** : (Array{Float,2}) la Hessienne de la fonction f appliqué au point xk + * **options** : (Array{Float,1}) - **delta** : le rayon de la région de confiance - **max_iter** : le nombre maximal d'iterations - **tol** : la tolérance pour la condition d'arrêt sur le gradient # Sorties: - * **s** : le pas s qui approche la solution du problème : ``min_{||s||< \delta_{k}} q(s)`` + * **s** : (Array{Float,1}) le pas s qui approche la solution du problème : ``min_{||s||< \delta_{k}} q(s)`` # Exemple d'appel: ```julia diff --git a/src/Lagrangien_Augmente.jl b/src/Lagrangien_Augmente.jl index 43c073e..1804ff6 100755 --- a/src/Lagrangien_Augmente.jl +++ b/src/Lagrangien_Augmente.jl @@ -4,22 +4,22 @@ Résolution des problèmes de minimisation sous contraintes d'égalités # Syntaxe ```julia Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte, - hess_contrainte,x0,option) + hess_contrainte,x0,options) ``` # Entrées - * **algo** : l'algorithme sans contraintes à utiliser: + * **algo** : (String) l'algorithme sans contraintes à utiliser: - **"newton"** : pour l'algorithme de Newton - **"cauchy"** : pour le pas de Cauchy - **"gct"** : pour le gradient conjugué tronqué - * **fonc** : la fonction à minimiser - * **contrainte** : la contrainte [x est dans le domaine des contraintes ssi ``c(x)=0``] - * **gradfonc** : le gradient de la fonction - * **hessfonc** : la hessienne de la fonction - * **grad_contrainte** : le gradient de la contrainte - * **hess_contrainte** : la hessienne de la contrainte - * **x0** : la première composante du point de départ du Lagrangien - * **options** + * **fonc** : (Function) la fonction à minimiser + * **contrainte** : (Function) la contrainte [x est dans le domaine des contraintes ssi ``c(x)=0``] + * **gradfonc** : (Function) le gradient de la fonction + * **hessfonc** : (Function) la hessienne de la fonction + * **grad_contrainte** : (Function) le gradient de la contrainte + * **hess_contrainte** : (Function) la hessienne de la contrainte + * **x0** : (Array{Float,1}) la première composante du point de départ du Lagrangien + * **options** : (Array{Float,1}) 1. **epsilon** : utilisé dans les critères d'arrêt 2. **tol** : la tolérance utilisée dans les critères d'arrêt 3. **itermax** : nombre maximal d'itération dans la boucle principale @@ -27,13 +27,13 @@ Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte, 5. **mu0,tho** : valeurs initiales des variables de l'algorithme # Sorties -* **xmin** : une approximation de la solution du problème avec contraintes -* **fxmin** : ``f(x_{min})`` -* **flag** : indicateur du déroulement de l'algorithme +* **xmin** : (Array{Float,1}) une approximation de la solution du problème avec contraintes +* **fxmin** : (Float) ``f(x_{min})`` +* **flag** : (Integer) indicateur du déroulement de l'algorithme - **0** : convergence - **1** : nombre maximal d'itération atteint - **(-1)** : une erreur s'est produite -* **niters** : nombre d'itérations réalisées +* **niters** : (Integer) nombre d'itérations réalisées # Exemple d'appel ```julia @@ -47,7 +47,7 @@ options = [] contrainte(x) = (x[1]^2) + (x[2]^2) -1.5 grad_contrainte(x) = [2*x[1] ;2*x[2]] hess_contrainte(x) = [2 0;0 2] -output = Lagrangien_Augmente(algo,f,contrainte,gradf,hessf,grad_contrainte,hess_contrainte,phi,x0,options) +output = Lagrangien_Augmente(algo,f,contrainte,gradf,hessf,grad_contrainte,hess_contrainte,x0,options) ``` """ function Lagrangien_Augmente(algo,fonc::Function,contrainte::Function,gradfonc::Function, @@ -58,7 +58,7 @@ function Lagrangien_Augmente(algo,fonc::Function,contrainte::Function,gradfonc:: tol = 1e-5 itermax = 1000 lambda0 = 2 - mu0 = 10 + mu0 = 100 tho = 2 else epsilon = options[1] @@ -69,8 +69,8 @@ function Lagrangien_Augmente(algo,fonc::Function,contrainte::Function,gradfonc:: tho = options[6] end - n = length(x0) - xmin = zeros(n) + n = length(x0) + xmin = zeros(n) fxmin = 0 flag = 0 iter = 0 diff --git a/src/Pas_De_Cauchy.jl b/src/Pas_De_Cauchy.jl index 074e061..44c1dae 100644 --- a/src/Pas_De_Cauchy.jl +++ b/src/Pas_De_Cauchy.jl @@ -9,13 +9,13 @@ s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta) ``` # Entrées - * **gradfk** : le gradient de la fonction f appliqué au point ``x_k`` - * **hessfk** : la Hessienne de la fonction f appliqué au point ``x_k`` - * **delta** : le rayon de la région de confiance + * **gradfk** : (Array{Float,1}) le gradient de la fonction f appliqué au point ``x_k`` + * **hessfk** : (Array{Float,2}) la Hessienne de la fonction f appliqué au point ``x_k`` + * **delta** : (Float) le rayon de la région de confiance # Sorties - * **s** : une approximation de la solution du sous-problème - * **e** : indice indiquant l'état de sortie: + * **s** : (Array{Float,1}) une approximation de la solution du sous-problème + * **e** : (Integer) indice indiquant l'état de sortie: si g != 0 si on ne sature pas la boule e <- 1 @@ -37,6 +37,6 @@ function Pas_De_Cauchy(g,H,delta) e = 0 n = length(g) s = zeros(n) + return s, e - end diff --git a/src/Regions_De_Confiance.jl b/src/Regions_De_Confiance.jl index d1a7952..e40f007 100644 --- a/src/Regions_De_Confiance.jl +++ b/src/Regions_De_Confiance.jl @@ -10,33 +10,34 @@ xk, nb_iters, f(xk), flag = Regions_De_Confiance(algo,f,gradf,hessf,x0,option) ``` # Entrées : - * **algo** : string indicant la méthode à utiliser pour calculer le pas + + * **algo** : (String) string indicant la méthode à utiliser pour calculer le pas - **"gct"** : pour l'algorithme du gradient conjugué tronqué - **"cauchy"**: pour le pas de Cauchy - * **f** : la fonction à minimiser - * **gradf** : le gradient de la fonction f - * **hessf** : la hessiene de la fonction à minimiser - * **x0** : point de départ - * **options** + * **f** : (Function) la fonction à minimiser + * **gradf** : (Function) le gradient de la fonction f + * **hessf** : (Function) la hessiene de la fonction à minimiser + * **x0** : (Array{Float,1}) point de départ + * **options** : (Array{Float,1}) * **deltaMax** : utile pour les m-à-j de la région de confiance ``R_{k}=\left\{x_{k}+s ;\|s\| \leq \Delta_{k}\right\}`` * **gamma1,gamma2** : ``0 < \gamma_{1} < 1 < \gamma_{2}`` pour les m-à-j de ``R_{k}`` * **eta1,eta2** : ``0 < \eta_{1} < \eta_{2} < 1`` pour les m-à-j de ``R_{k}`` * **delta0** : le rayon de départ de la région de confiance * **max_iter** : le nombre maximale d'iterations - * **tol** : la tolérence pour les critères d'arrêt - + * **tolCN1** : la tolérence pour la condition nécessaire d'ordre 1 + * **tol** : la tolérence pour les autres critères d'arrêt # Sorties: - * **xmin** : une approximation de la solution du problème : ``min_{x \in \mathbb{R}^{n}} f(x)`` - * **fxmin** : ``f(x_{min})`` - * **flag** : un entier indiquant le critère sur lequel le programme à arrêter + * **xmin** : (Array{Float,1}) une approximation de la solution du problème : ``min_{x \in \mathbb{R}^{n}} f(x)`` + * **fxmin** : (Float) ``f(x_{min})`` + * **flag** : (Integer) un entier indiquant le critère sur lequel le programme à arrêter - **0** : Convergence - **1** : stagnation du ``x`` - **2** : stagnation du ``f`` - **3** : nombre maximal d'itération dépassé - * **nb_iters** : le nombre d'iteration qu'à fait le programme + * **nb_iters** : (Integer)le nombre d'iteration qu'à fait le programme # Exemple d'appel ```julia @@ -59,7 +60,8 @@ function Regions_De_Confiance(algo,f::Function,gradf::Function,hessf::Function,x eta2 = 0.75 delta0 = 2 max_iter = 1000 - tol = 1e-15 + tolCN1 = 1e-15 + tol = 1e-15 else deltaMax = options[1] gamma1 = options[2] @@ -68,16 +70,16 @@ function Regions_De_Confiance(algo,f::Function,gradf::Function,hessf::Function,x eta2 = options[5] delta0 = options[6] max_iter = options[7] - tol = options[8] + tolCN1 = options[8] + tol = options[9] end - - + # eps = sqrt(epsilon_machine) à utiliser pour compenser les éventuelles erreurs de la machine lors de l'évaluation des critères d'arrêt + eps = 1e-8 n = length(x0) xmin = zeros(n) fxmin = f(xmin) flag = 0 nb_iters = 0 - return xmin, fxmin, flag, nb_iters -end +end \ No newline at end of file diff --git a/test/runtests.jl b/test/runtests.jl index 5601c39..b82d9bd 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -16,7 +16,7 @@ TestOptinum.cacher_stacktrace() @testset "Test SujetOptinum" begin # Tester l'algorithme de Newton - tester_Algo_Newton(false,Algorithme_De_Newton) + tester_algo_newton(false,Algorithme_De_Newton) # Tester l'algorithme du pas de Cauchy tester_pas_de_cauchy(false,Pas_De_Cauchy) @@ -28,6 +28,6 @@ TestOptinum.cacher_stacktrace() tester_regions_de_confiance(false,Regions_De_Confiance) # Tester l'algorithme du Lagrangien Augmenté - tester_Lagrangien_Augmente(false,Lagrangien_Augmente) + tester_lagrangien_augmente(false,Lagrangien_Augmente) end