From b27a6f8044889ac37332b756c88ac1146bb325cc Mon Sep 17 00:00:00 2001 From: nsaloua Date: Mon, 15 Jun 2020 19:20:15 +0200 Subject: [PATCH] Initialisation depot --- Manifest.toml | 47 ++++++++++++++++++ Project.toml | 10 ++++ src/Algorithme_De_Newton.jl | 60 +++++++++++++++++++++++ src/Gradient_Conjugue_Tronque.jl | 49 +++++++++++++++++++ src/Lagrangien_Augmente.jl | 81 +++++++++++++++++++++++++++++++ src/Pas_De_Cauchy.jl | 42 ++++++++++++++++ src/Regions_De_Confiance.jl | 83 ++++++++++++++++++++++++++++++++ src/Sujet_Optinum.jl | 23 +++++++++ test/runtests.jl | 7 +++ 9 files changed, 402 insertions(+) create mode 100644 Manifest.toml create mode 100644 Project.toml create mode 100644 src/Algorithme_De_Newton.jl create mode 100644 src/Gradient_Conjugue_Tronque.jl create mode 100755 src/Lagrangien_Augmente.jl create mode 100644 src/Pas_De_Cauchy.jl create mode 100644 src/Regions_De_Confiance.jl create mode 100644 src/Sujet_Optinum.jl create mode 100644 test/runtests.jl diff --git a/Manifest.toml b/Manifest.toml new file mode 100644 index 0000000..1f6d26d --- /dev/null +++ b/Manifest.toml @@ -0,0 +1,47 @@ +# This file is machine-generated - editing it directly is not advised + +[[Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" + +[[InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[LinearAlgebra]] +deps = ["Libdl"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[Random]] +deps = ["Serialization"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[Test]] +deps = ["Distributed", "InteractiveUtils", "Logging", "Random"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[Test_Optinum]] +git-tree-sha1 = "bd750cc6a66d4b1eb66cd2a5ec58bd786966f63d" +repo-rev = "master" +repo-url = "https://github.com/mathn7/Test_Optinum.git" +uuid = "f01acfed-6be5-49b9-8763-0b41ea537fc3" +version = "0.1.0" diff --git a/Project.toml b/Project.toml new file mode 100644 index 0000000..bc74008 --- /dev/null +++ b/Project.toml @@ -0,0 +1,10 @@ +name = "Sujet_Optinum" +uuid = "3a392a93-80c0-4dde-80ff-95b69cdbace1" +authors = ["nsaloua "] +version = "0.1.0" + +[deps] +LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a" +Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" +Test_Optinum = "f01acfed-6be5-49b9-8763-0b41ea537fc3" diff --git a/src/Algorithme_De_Newton.jl b/src/Algorithme_De_Newton.jl new file mode 100644 index 0000000..379b4d1 --- /dev/null +++ b/src/Algorithme_De_Newton.jl @@ -0,0 +1,60 @@ +@doc doc""" +Approximation de la solution du problème ``\min_{x \in \mathbb{R}^{n}} f(x)`` en utilisant l'algorithme de Newton + +# Syntaxe +```julia +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 + +# 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 + * **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 + +# Exemple d'appel +```@example +using Optinum +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] +options = [] +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" + if options == [] + eps = 1e-8 + max_iter = 100 + tol = 1e-15 + else + eps = options[1] + max_iter = options[2] + tol = options[3] + + end + + n = length(x0) + xmin = zeros(n) + f_min = 0 + flag = 0 + nb_iters = 0 + return xmin,f_min,flag,nb_iters +end diff --git a/src/Gradient_Conjugue_Tronque.jl b/src/Gradient_Conjugue_Tronque.jl new file mode 100644 index 0000000..61146f3 --- /dev/null +++ b/src/Gradient_Conjugue_Tronque.jl @@ -0,0 +1,49 @@ +@doc doc""" +Minimise le problème : ``min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs`` + pour la ``k^{ème}`` itération de l'algorithme des régions de confiance + +# Syntaxe +```julia +sk = Gradient_Conjugue_Tronque(fk,gradfk,hessfk,option) +``` + +# Entrées : + * **fk** : la fonction à minimiser appliqué au point xk + * **gradfk** : le gradient de la fonction f appliqué au point xk + * **hessfk** : la Hessienne de la fonction f appliqué au point xk + * **options** + - **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)`` + +# Exemple d'appel: +```julia +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] +xk = [1; 0] +options = [] +s = Gradient_Conjugue_Tronque(f(xk),gradf(xk),hessf(xk),options) +``` +""" +function Gradient_Conjugue_Tronque(fk,gradfk,hessfk,options) + + "# Si option est vide on initialise les 3 paramètres par défaut" + if options == [] + deltak = 2 + max_iter = 100 + tol = 1e-6 + else + deltak = options[1] + max_iter = options[2] + tol = options[3] + end + + n = length(gradfk) + s = zeros(n) + return s +end diff --git a/src/Lagrangien_Augmente.jl b/src/Lagrangien_Augmente.jl new file mode 100755 index 0000000..23cbd5d --- /dev/null +++ b/src/Lagrangien_Augmente.jl @@ -0,0 +1,81 @@ +@doc doc""" +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,phi,x0,option) +``` + +# Entrées + * **algo** : 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 + * **phi(x)** : utilisée dans le calcul du gradient du Lagrangien (égale 0 dans le cas des contraintes d'égalités) + * **x0** : la première composante du point de départ du Lagrangien + * **options** + 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 + 4. **lambda0** : la deuxième composante du point de départ du Lagrangien + 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 + - **0** : convergence + - **1** : nombre maximal d'itération atteint + - **(-1)** : une erreur s'est produite +* **niters** : nombre d'itérations réalisées + +# Exemple d'appel +```julia +using LinearAlgebra +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] +algo = "gct" # ou newton|gct +x0 = [1; 0] +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] +phi(x) = 0 +output = Lagrangien_Augmente(algo,f,contrainte,gradf,hessf,grad_contrainte,hess_contrainte,phi,x0,options) +``` +""" +function Lagrangien_Augmente(algo,fonc::Function,contrainte::Function,gradfonc::Function, + hessfonc::Function,grad_contrainte::Function,hess_contrainte::Function,phi::Function,x0,options) + + if options == [] + epsilon = 1e-30 + tol = 1e-3 + itermax = 1000 + lambda0 = 0.3 + mu0 = 0.5 + tho = 2 + else + epsilon = options[1] + tol = options[2] + itermax = options[3] + lambda0 = options[4] + mu0 = options[5] + tho = options[6] + end + + n = length(x0) + xmin = zeros(n) + fxmin = 0 + flag = 0 + iter = 0 + + return xmin,fxmin,flag,iter +end diff --git a/src/Pas_De_Cauchy.jl b/src/Pas_De_Cauchy.jl new file mode 100644 index 0000000..074e061 --- /dev/null +++ b/src/Pas_De_Cauchy.jl @@ -0,0 +1,42 @@ +@doc doc""" +Approximation de la solution du sous-problème ``q_k(s) = s^{t}g + (1/2)s^{t}Hs`` + avec ``s=-t g_k,t > 0,||s||< \delta_k `` + + +# Syntaxe +```julia +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 + +# Sorties + * **s** : une approximation de la solution du sous-problème + * **e** : indice indiquant l'état de sortie: + si g != 0 + si on ne sature pas la boule + e <- 1 + sinon + e <- -1 + sinon + e <- 0 + +# Exemple d'appel +```julia +g1 = [0; 0] +H1 = [7 0 ; 0 2] +delta1 = 1 +s1, e1 = Pas_De_Cauchy(g1,H1,delta1) +``` +""" +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 new file mode 100644 index 0000000..106fd73 --- /dev/null +++ b/src/Regions_De_Confiance.jl @@ -0,0 +1,83 @@ +@doc doc""" +Minimise une fonction en utilisant l'algorithme des régions de confiance avec + - le pas de Cauchy +ou + - le pas issu de l'algorithme du gradient conjugue tronqué + +# Syntaxe +```julia +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 + - **"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** + * **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 + + +# 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 + - **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 + +# Exemple d'appel +```julia +algo="gct" +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] +options = [] +xmin, fxmin, flag,nb_iters = Regions_De_Confiance(algo,f,gradf,hessf,x0,options) +``` +""" +function Regions_De_Confiance(algo,f::Function,gradf::Function,hessf::Function,x0,options) + + if options == [] + deltaMax = 10 + gamma1 = 0.5 + gamma2 = 2.00 + eta1 = 0.25 + eta2 = 0.75 + delta0 = 2 + max_iter = 1000 + tol = 1e-15 + else + deltaMax = options[1] + gamma1 = options[2] + gamma2 = options[3] + eta1 = options[4] + eta2 = options[5] + delta0 = options[6] + max_iter = options[7] + tol = options[8] + end + + + n = length(x0) + xmin = zeros(n) + fxmin = 0 + flag = 0 + nb_iters = 0 + + + return xmin, fxmin, flag, nb_iters +end diff --git a/src/Sujet_Optinum.jl b/src/Sujet_Optinum.jl new file mode 100644 index 0000000..15c8dc0 --- /dev/null +++ b/src/Sujet_Optinum.jl @@ -0,0 +1,23 @@ +module Sujet_Optinum + +using LinearAlgebra +using Test +using Markdown + + +include("Algorithme_De_Newton.jl") +export Algorithme_De_Newton + +include("Regions_De_Confiance.jl") +export Regions_De_Confiance + +include("Pas_De_Cauchy.jl") +export Pas_De_Cauchy + +include("Gradient_Conjugue_Tronque.jl") +export Gradient_Conjugue_Tronque + +include("Lagrangien_Augmente.jl") +export Lagrangien_Augmente + +end # module diff --git a/test/runtests.jl b/test/runtests.jl new file mode 100644 index 0000000..5d27aa0 --- /dev/null +++ b/test/runtests.jl @@ -0,0 +1,7 @@ +using Test_Optinum + +Test_Optinum.test_Algo_Newton(false,Algorithme_De_Newton) +Test_Optinum.test_pas_de_cauchy(false,Pas_De_Cauchy) +Test_Optinum.test_regions_de_confiance(false,Regions_De_Confiance) +Test_Optinum.test_Lagrangien_Augmente(false,Lagrangien_Augmente) +