updates
This commit is contained in:
relmo
parent
60561f5950
commit
743fd9250a
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue