Initialisation depot

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"

Project.toml

@@ -0,0 +1,10 @@
+name = "Sujet_Optinum"
+uuid = "3a392a93-80c0-4dde-80ff-95b69cdbace1"
+authors = ["nsaloua <naamasaloua1998@gmail.com>"]
+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"

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

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

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

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

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

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

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)
+