ENSEEIHT/TP-optimisation-numerique-2
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

updates

Browse source
This commit is contained in:
relmo 2020-07-05 16:59:57 +02:00
parent 60561f5950
commit 743fd9250a
6 changed files with 72 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
src/Algorithme_De_Newton.jl
View file

@ -7,24 +7,24 @@ xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
``` ```
# Entrées : # Entrées :
* **f** : la fonction à minimiser * **f** : (Function) la fonction à minimiser
* **gradf** : le gradient de la fonction f * **gradf** : (Function) le gradient de la fonction f
* **hessf** : la Hessienne de la fonction f * **hessf** : (Function) la Hessienne de la fonction f
* **x0** : première approximation de la solution cherchée * **x0** : (Array{Float,1}) première approximation de la solution cherchée
* **options** : * **options** : (Array{Float,1})
* **eps** : pour fixer les conditions d'arrêt
* **max_iter** : le nombre maximal d'iterations * **max_iter** : le nombre maximal d'iterations
* **tol** : pour les conditions d'arrêts * **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: # Sorties:
* **xmin** : une approximation de la solution du problème : ``\min_{x \in \mathbb{R}^{n}} f(x)`` * **xmin** : (Array{Float,1}) une approximation de la solution du problème : ``\min_{x \in \mathbb{R}^{n}} f(x)``
* **f_min** : ``f(x_{min})`` * **f_min** : (Float) ``f(x_{min})``
* **flag** : entier indiquant le critère sur lequel le programme à arrêter * **flag** : (Integer) indique le critère sur lequel le programme à arrêter
* **0** : Convergence * **0** : Convergence
* **1** : stagnation du xk * **1** : stagnation du xk
* **2** : stagnation du f * **2** : stagnation du f
* **3** : nombre maximal d'itération dépassé * **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 # Exemple d'appel
```@example ```@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) 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 == [] if options == []
eps = 1e-8
max_iter = 100 max_iter = 100
tolCN1 = 1e-15
tol = 1e-15 tol = 1e-15
else else
eps = options[1] max_iter = options[1]
max_iter = options[2] tolCN1 = options[2]
tol = options[3] tol = options[3]
end end
eps = 1e-8
n = length(x0) n = length(x0)
xmin = zeros(n) xmin = zeros(n)

10
src/Gradient_Conjugue_Tronque.jl
View file

@ -4,20 +4,20 @@ Minimise le problème : ``min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs
# Syntaxe # Syntaxe
```julia ```julia
sk = Gradient_Conjugue_Tronque(gradfk,hessfk,option) sk = Gradient_Conjugue_Tronque(fk,gradfk,hessfk,option)
``` ```
# Entrées : # Entrées :
* **gradfk** : le gradient de la fonction f appliqué au point xk * **gradfk** : (Array{Float,1}) le gradient de la fonction f appliqué au point xk
* **hessfk** : la Hessienne de la fonction f appliqué au point xk * **hessfk** : (Array{Float,2}) la Hessienne de la fonction f appliqué au point xk
* **options** * **options** : (Array{Float,1})
- **delta** : le rayon de la région de confiance - **delta** : le rayon de la région de confiance
- **max_iter** : le nombre maximal d'iterations - **max_iter** : le nombre maximal d'iterations
- **tol** : la tolérance pour la condition d'arrêt sur le gradient - **tol** : la tolérance pour la condition d'arrêt sur le gradient
# Sorties: # 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: # Exemple d'appel:
```julia ```julia

32
src/Lagrangien_Augmente.jl
View file

@ -4,22 +4,22 @@ Résolution des problèmes de minimisation sous contraintes d'égalités
# Syntaxe # Syntaxe
```julia ```julia
Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte, Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
hess_contrainte,x0,option) hess_contrainte,x0,options)
``` ```
# Entrées # Entrées
* **algo** : l'algorithme sans contraintes à utiliser: * **algo** : (String) l'algorithme sans contraintes à utiliser:
- **"newton"** : pour l'algorithme de Newton - **"newton"** : pour l'algorithme de Newton
- **"cauchy"** : pour le pas de Cauchy - **"cauchy"** : pour le pas de Cauchy
- **"gct"** : pour le gradient conjugué tronqué - **"gct"** : pour le gradient conjugué tronqué
* **fonc** : la fonction à minimiser * **fonc** : (Function) la fonction à minimiser
* **contrainte** : la contrainte [x est dans le domaine des contraintes ssi ``c(x)=0``] * **contrainte** : (Function) la contrainte [x est dans le domaine des contraintes ssi ``c(x)=0``]
* **gradfonc** : le gradient de la fonction * **gradfonc** : (Function) le gradient de la fonction
* **hessfonc** : la hessienne de la fonction * **hessfonc** : (Function) la hessienne de la fonction
* **grad_contrainte** : le gradient de la contrainte * **grad_contrainte** : (Function) le gradient de la contrainte
* **hess_contrainte** : la hessienne de la contrainte * **hess_contrainte** : (Function) la hessienne de la contrainte
* **x0** : la première composante du point de départ du Lagrangien * **x0** : (Array{Float,1}) la première composante du point de départ du Lagrangien
* **options** * **options** : (Array{Float,1})
1. **epsilon** : utilisé dans les critères d'arrêt 1. **epsilon** : utilisé dans les critères d'arrêt
2. **tol** : la tolérance utilisée 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 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 5. **mu0,tho** : valeurs initiales des variables de l'algorithme
# Sorties # Sorties
* **xmin** : une approximation de la solution du problème avec contraintes * **xmin** : (Array{Float,1}) une approximation de la solution du problème avec contraintes
* **fxmin** : ``f(x_{min})`` * **fxmin** : (Float) ``f(x_{min})``
* **flag** : indicateur du déroulement de l'algorithme * **flag** : (Integer) indicateur du déroulement de l'algorithme
- **0** : convergence - **0** : convergence
- **1** : nombre maximal d'itération atteint - **1** : nombre maximal d'itération atteint
- **(-1)** : une erreur s'est produite - **(-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 # Exemple d'appel
```julia ```julia
@ -47,7 +47,7 @@ options = []
contrainte(x) = (x[1]^2) + (x[2]^2) -1.5 contrainte(x) = (x[1]^2) + (x[2]^2) -1.5
grad_contrainte(x) = [2*x[1] ;2*x[2]] grad_contrainte(x) = [2*x[1] ;2*x[2]]
hess_contrainte(x) = [2 0;0 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, 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 tol = 1e-5
itermax = 1000 itermax = 1000
lambda0 = 2 lambda0 = 2
mu0 = 10 mu0 = 100
tho = 2 tho = 2
else else
epsilon = options[1] epsilon = options[1]

12
src/Pas_De_Cauchy.jl
View file

@ -9,13 +9,13 @@ s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
``` ```
# Entrées # Entrées
* **gradfk** : le gradient de la fonction f appliqué au point ``x_k`` * **gradfk** : (Array{Float,1}) le gradient de la fonction f appliqué au point ``x_k``
* **hessfk** : la Hessienne 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** : le rayon de la région de confiance * **delta** : (Float) le rayon de la région de confiance
# Sorties # Sorties
* **s** : une approximation de la solution du sous-problème * **s** : (Array{Float,1}) une approximation de la solution du sous-problème
* **e** : indice indiquant l'état de sortie: * **e** : (Integer) indice indiquant l'état de sortie:
si g != 0 si g != 0
si on ne sature pas la boule si on ne sature pas la boule
e <- 1 e <- 1
@ -37,6 +37,6 @@ function Pas_De_Cauchy(g,H,delta)
e = 0 e = 0
n = length(g) n = length(g)
s = zeros(n) s = zeros(n)
return s, e
return s, e
end end

34
src/Regions_De_Confiance.jl
View file

@ -10,33 +10,34 @@ xk, nb_iters, f(xk), flag = Regions_De_Confiance(algo,f,gradf,hessf,x0,option)
``` ```
# Entrées : # 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é - **"gct"** : pour l'algorithme du gradient conjugué tronqué
- **"cauchy"**: pour le pas de Cauchy - **"cauchy"**: pour le pas de Cauchy
* **f** : la fonction à minimiser * **f** : (Function) la fonction à minimiser
* **gradf** : le gradient de la fonction f * **gradf** : (Function) le gradient de la fonction f
* **hessf** : la hessiene de la fonction à minimiser * **hessf** : (Function) la hessiene de la fonction à minimiser
* **x0** : point de départ * **x0** : (Array{Float,1}) point de départ
* **options** * **options** : (Array{Float,1})
* **deltaMax** : utile pour les m-à-j de la région de confiance * **deltaMax** : utile pour les m-à-j de la région de confiance
``R_{k}=\left\{x_{k}+s ;\|s\| \leq \Delta_{k}\right\}`` ``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}`` * **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}`` * **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 * **delta0** : le rayon de départ de la région de confiance
* **max_iter** : le nombre maximale d'iterations * **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: # Sorties:
* **xmin** : une approximation de la solution du problème : ``min_{x \in \mathbb{R}^{n}} f(x)`` * **xmin** : (Array{Float,1}) une approximation de la solution du problème : ``min_{x \in \mathbb{R}^{n}} f(x)``
* **fxmin** : ``f(x_{min})`` * **fxmin** : (Float) ``f(x_{min})``
* **flag** : un entier indiquant le critère sur lequel le programme à arrêter * **flag** : (Integer) un entier indiquant le critère sur lequel le programme à arrêter
- **0** : Convergence - **0** : Convergence
- **1** : stagnation du ``x`` - **1** : stagnation du ``x``
- **2** : stagnation du ``f`` - **2** : stagnation du ``f``
- **3** : nombre maximal d'itération dépassé - **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 # Exemple d'appel
```julia ```julia
@ -59,6 +60,7 @@ function Regions_De_Confiance(algo,f::Function,gradf::Function,hessf::Function,x
eta2 = 0.75 eta2 = 0.75
delta0 = 2 delta0 = 2
max_iter = 1000 max_iter = 1000
tolCN1 = 1e-15
tol = 1e-15 tol = 1e-15
else else
deltaMax = options[1] deltaMax = options[1]
@ -68,16 +70,16 @@ function Regions_De_Confiance(algo,f::Function,gradf::Function,hessf::Function,x
eta2 = options[5] eta2 = options[5]
delta0 = options[6] delta0 = options[6]
max_iter = options[7] max_iter = options[7]
tol = options[8] tolCN1 = options[8]
tol = options[9]
end 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) n = length(x0)
xmin = zeros(n) xmin = zeros(n)
fxmin = f(xmin) fxmin = f(xmin)
flag = 0 flag = 0
nb_iters = 0 nb_iters = 0
return xmin, fxmin, flag, nb_iters return xmin, fxmin, flag, nb_iters
end end

4
test/runtests.jl
View file

@ -16,7 +16,7 @@ TestOptinum.cacher_stacktrace()
@testset "Test SujetOptinum" begin @testset "Test SujetOptinum" begin
# Tester l'algorithme de Newton # 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 l'algorithme du pas de Cauchy
tester_pas_de_cauchy(false,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_regions_de_confiance(false,Regions_De_Confiance)
# Tester l'algorithme du Lagrangien Augmenté # Tester l'algorithme du Lagrangien Augmenté
tester_Lagrangien_Augmente(false,Lagrangien_Augmente) tester_lagrangien_augmente(false,Lagrangien_Augmente)
end end