Skip to content
Snippets Groups Projects
Commit 4a516096 authored by Olivier Cots's avatar Olivier Cots
Browse files

foo

parent b45490c8
Branches
No related tags found
1 merge request!5Refonte ok
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 26 additions and 1385 deletions
src/Algorithme_De_Newton.jl
+ 5
− 5
View file @ 4a516096
@doc doc"""
# Objet
#### Objet
Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contrainte
# Syntaxe
#### Syntaxe
```julia
xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
```
# Entrées :
#### Entrées :
- f : (Function) la fonction à minimiser
- gradf : (Function) le gradient de la fonction f
- hessf : (Function) la Hessienne de la fonction f
......@@ -18,7 +18,7 @@ xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
- Tol_abs : la tolérence absolue
- Tol_rel : la tolérence relative
# Sorties:
#### Sorties:
- 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
......@@ -28,7 +28,7 @@ xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
- 3 : nombre maximal d'itération dépassé
- nb_iters : (Integer) le nombre d'itérations faites par le programme
# Exemple d'appel
#### Exemple d'appel
```@example
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)]
......
src/Gradient_Conjugue_Tronque.jl
+ 5
− 5
View file @ 4a516096
@doc doc"""
# Objet
#### Objet
Cette fonction calcule une solution approchée du problème
```math
......@@ -8,12 +8,12 @@ Cette fonction calcule une solution approchée du problème
par l'algorithme du gradient conjugué tronqué
# Syntaxe
#### Syntaxe
```julia
sk = Gradient_Conjugue_Tronque(fk,gradfk,hessfk,option)
```
# Entrées :
#### 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})
......@@ -22,10 +22,10 @@ sk = Gradient_Conjugue_Tronque(fk,gradfk,hessfk,option)
- tol : la tolérance pour la condition d'arrêt sur le gradient
# Sorties:
#### Sorties:
- 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
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]
......
src/Lagrangien_Augmente.jl
+ 6
− 6
View file @ 4a516096
@doc doc"""
# Objet
#### Objet
Résolution des problèmes de minimisation sous contraintes d'égalités par l'algorithme du lagrangien augmenté
# Syntaxe
#### Syntaxe
```julia
Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
hess_contrainte,x0,options)
```
# Entrées
#### Entrées
- algo : (String) l'algorithme sans contraintes à utiliser:
- "newton" : pour l'algorithme de Newton
- "cauchy" : pour le pas de Cauchy
......@@ -28,7 +28,7 @@ Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
4. lambda0 : la deuxième composante du point de départ du Lagrangien
5. mu0,tho : valeurs initiales des variables de l'algorithme
# Sorties
#### Sorties
- 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
......@@ -39,7 +39,7 @@ Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
- muk : (Float) valeur de mu_k à la sortie
- lambdak : (Float) valeur de lambda_k à la sortie
# Exemple d'appel
#### Exemple d'appel
```julia
using LinearAlgebra
f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2
......@@ -54,7 +54,7 @@ hess_contrainte(x) = [2 0;0 2]
output = Lagrangien_Augmente(algo,f,contrainte,gradf,hessf,grad_contrainte,hess_contrainte,x0,options)
```
# Tolérances des algorithmes appelés
#### Tolérances des algorithmes appelés
Pour les tolérances définies dans les algorithmes appelés (Newton et régions de confiance), prendre les tolérances
par défaut définies dans ces algorithmes.
......
src/Pas_De_Cauchy.jl
+ 5
− 5
View file @ 4a516096
@doc doc"""
# Objet
#### Objet
Cette fonction calcule une solution approchée du problème
```math
\min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs
```
par le calcul du pas de Cauchy
# Syntaxe
#### Syntaxe
```julia
s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
```
# Entrées
#### Entrées
- 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
#### Sorties
- s : (Array{Float,1}) une approximation de la solution du sous-problème
- e : (Integer) indice indiquant l'état de sortie:
si g != 0
......@@ -28,7 +28,7 @@ s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
sinon
e <- 0
# Exemple d'appel
#### Exemple d'appel
```julia
g1 = [0; 0]
H1 = [7 0 ; 0 2]
......
src/Regions_De_Confiance.jl
+ 5
− 5
View file @ 4a516096
@doc doc"""
# Objet
#### Objet
Minimise une fonction de R^n à valeurs dans R en utilisant l'algorithme des régions de confiance.
La solution approchées des sous-problèmes quadratiques est calculé
par le pas de Cauchy ou le pas issu de l'algorithme du gradient conjugue tronqué
# Syntaxe
#### Syntaxe
```julia
xk, nb_iters, f(xk), flag = Regions_De_Confiance(algo,f,gradf,hessf,x0,option)
```
# Entrées :
#### Entrées :
- algo : (String) string indicant la méthode à utiliser pour calculer le pas
- "gct" : pour l'algorithme du gradient conjugué tronqué
......@@ -31,7 +31,7 @@ xk, nb_iters, f(xk), flag = Regions_De_Confiance(algo,f,gradf,hessf,x0,option)
- Tol_abs : la tolérence absolue
- Tol_rel : la tolérence relative
# Sorties:
#### Sorties:
- 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})``
......@@ -42,7 +42,7 @@ xk, nb_iters, f(xk), flag = Regions_De_Confiance(algo,f,gradf,hessf,x0,option)
- 3 : nombre maximal d'itération dépassé
- nb_iters : (Integer)le nombre d'iteration qu'à fait le programme
# Exemple d'appel
#### Exemple d'appel
```julia
algo="gct"
f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2
......
src/notebook_algo_newton.ipynb deleted 100644 → 0
+ 0
− 373
View file @ b45490c8
%% Cell type:markdown id: tags:
<center>
<h1> TP-Projet d'optimisation numérique </h1>
<h1> Algorithme de Newton </h1>
</center>
%% Cell type:markdown id: tags:
## Implémentation
1. Coder l’algorithme de Newton local en respectant la spécification ci-dessous (fichier `Algorithme_De_Newton.jl`)
%% Cell type:code id: tags:
``` julia
using LinearAlgebra
using Documenter
using Markdown
include("Algorithme_De_Newton.jl")
@doc Algorithme_De_Newton
```
%% Output
┌ Info: Precompiling Documenter [e30172f5-a6a5-5a46-863b-614d45cd2de4]
└ @ Base loading.jl:1342
# Objet
Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contrainte
# Syntaxe
```julia
xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
```
# Entrées :
* 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
* Tol_abs : la tolérence absolue
* Tol_rel : la tolérence relative
# Sorties:
* 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 : (Integer) le nombre d'itérations faites par le programme
# Exemple d'appel
```@example
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)
```
\section{Objet}
Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contrainte
\section{Syntaxe}
\begin{verbatim}
xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
\end{verbatim}
\section{Entrées :}
\begin{itemize}
\item f : (Function) la fonction à minimiser
\item gradf : (Function) le gradient de la fonction f
\item hessf : (Function) la Hessienne de la fonction f
\item x0 : (Array\{Float,1\}) première approximation de la solution cherchée
\item options : (Array\{Float,1\})
\begin{itemize}
\item max\_iter : le nombre maximal d'iterations
\item Tol\_abs : la tolérence absolue
\item Tol\_rel : la tolérence relative
\end{itemize}
\end{itemize}
\section{Sorties:}
\begin{itemize}
\item xmin : (Array\{Float,1\}) une approximation de la solution du problème : $\min_{x \in \mathbb{R}^{n}} f(x)$
\item f\emph{min : (Float) ``f(x}\{min\})``
\item flag : (Integer) indique le critère sur lequel le programme à arrêter
\begin{itemize}
\item 0 : Convergence
\item 1 : stagnation du xk
\item 2 : stagnation du f
\item 3 : nombre maximal d'itération dépassé
\end{itemize}
\item nb\_iters : (Integer) le nombre d'itérations faites par le programme
\end{itemize}
\section{Exemple d'appel}
\begin{verbatim}
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)
\end{verbatim}
 Objet
 ≡≡≡≡≡≡≡
Cette fonction implémente l'algorithme de Newton pour résoudre un problème
d'optimisation sans contrainte
 Syntaxe
 ≡≡≡≡≡≡≡≡≡
 xk,f_min,flag,nb_iters = Algorithme_de_Newton(f,gradf,hessf,x0,option)
 Entrées :
 ≡≡≡≡≡≡≡≡≡≡≡
• 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
• Tol_abs : la tolérence absolue
• Tol_rel : la tolérence relative
 Sorties:
 ≡≡≡≡≡≡≡≡≡≡
• xmin : (Array{Float,1}) une approximation de la solution du
problème : \min_{x \in \mathbb{R}^{n}} f(x)
• fmin : (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 : (Integer) le nombre d'itérations faites par le
programme
 Exemple d'appel
 ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
 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)
%% Cell type:markdown id: tags:
2. Vérifier que les tests ci-dessous passent.
%% Cell type:code id: tags:
``` julia
using Test
# Tolérance pour les tests d'égalité
tol_erreur = sqrt(eps())
## ajouter les fonctions de test
include("../test/fonctions_de_tests.jl")
include("../test/tester_algo_newton.jl")
include("../src/Algorithme_De_Newton.jl")
affiche = false
@testset "Test algo newton" begin
# Tester l'algorithme de Newton
tester_algo_newton(affiche,Algorithme_De_Newton)
end;
```
%% Output
Test Summary: | Pass Total
Test algo newton |  14  14
%% Cell type:code id: tags:
``` julia
#using Pkg; Pkg.add("LinearAlgebra"); Pkg.add("Markdown")
# using Documenter
using LinearAlgebra
using Markdown # Pour que les docstrings en début des fonctions ne posent
# pas de soucis. Ces docstrings sont utiles pour générer
# la documentation sous GitHub
include("Algorithme_De_Newton.jl")
# Affichage les sorties de l'algorithme des Régions de confiance
function my_afficher_resultats(algo,nom_fct,point_init,xmin,fxmin,flag,sol_exacte,nbiters)
println("-------------------------------------------------------------------------")
printstyled("Résultats de : ",algo, " appliqué à ",nom_fct, " au point initial ", point_init, ":\n",bold=true,color=:blue)
println(" * xsol = ",xmin)
println(" * f(xsol) = ",fxmin)
println(" * nb_iters = ",nbiters)
println(" * flag = ",flag)
println(" * sol_exacte : ", sol_exacte)
end
# Fonction f0
# -----------
f0(x) = sin(x)
# la gradient de la fonction f0
grad_f0(x) = cos(x)
# la hessienne de la fonction f0
hess_f0(x) = -sin(x)
sol_exacte = -pi/2
options = []
x0 = sol_exacte
xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f0,grad_f0,hess_f0,x0,options)
my_afficher_resultats("Newton","f0",x0,xmin,f_min,flag,sol_exacte,nb_iters)
x0 = -pi/2+0.5
xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f0,grad_f0,hess_f0,x0,options)
my_afficher_resultats("Newton","f0",x0,xmin,f_min,flag,sol_exacte,nb_iters)
x0 = pi/2
xmin,f_min,flag,nb_iters = Algorithme_De_Newton(f0,grad_f0,hess_f0,x0,options)
my_afficher_resultats("Newton","f0",x0,xmin,f_min,flag,sol_exacte,nb_iters)
```
%% Output
-------------------------------------------------------------------------
Résultats de : Newton appliqué à f0 au point initial -1.5707963267948966:
* xsol = -1.5707963267948966
* f(xsol) = -1.0
* nb_iters = 0
* flag = 0
* sol_exacte : -1.5707963267948966
-------------------------------------------------------------------------
Résultats de : Newton appliqué à f0 au point initial -1.0707963267948966:
* xsol = -1.0707963267948966
* f(xsol) = -0.8775825618903726
* nb_iters = 0
* flag = 0
* sol_exacte : -1.5707963267948966
-------------------------------------------------------------------------
Résultats de : Newton appliqué à f0 au point initial 1.5707963267948966:
* xsol = 1.5707963267948966
* f(xsol) = 1.0
* nb_iters = 0
* flag = 0
* sol_exacte : -1.5707963267948966
%% Cell type:markdown id: tags:
## Interprétation
1. Justifier les résultats obtenus pour l'exemple $f_0$ ci-dessus;
2. Soit $$ f_{1} : \mathbf{R}^3 \rightarrow \mathbf{R}$$ $$ (x_1,x_2, x_3) \mapsto 2 (x_1 +x_2 + x_3 -3)^2 + (x_1-x_2)^2 + (x_2 - x_3)^2$$ Justifier que l’algorithme implémenté converge en une itération pour $f_{1}$;
3. Soit $$ f_{2} : \mathbf{R}^2 \rightarrow \mathbf{R}$$ $$ (x_1,x_2) \mapsto 100(x_2-x_1^2)^2 + (1-x_1)^2 $$ que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.
src/notebook_lagrangien_augmente.ipynb deleted 100644 → 0
+ 0
− 386
View file @ b45490c8
%% Cell type:markdown id: tags:
<center>
<h1> TP-Projet d'optimisation numérique </h1>
<h1> Algorithme du Lagrangien Augmenté </h1>
</center>
%% Cell type:markdown id: tags:
## Implémentation
1.Choisir des critères d’arrêt pour la convergence de l'algorithme.
2.Implémenter l'algorithme du lagrangien augmenté, en utilisant les différentes méthodes
qui ont été vues en première partie pour la résolution de la suite de problémes sans
contraintes (fichier `Lagrangien_Augmente.jl`). La spécification de l'algorithme du Lagrangien augmenté est donnée ci-dessous.
%% Cell type:code id: tags:
``` julia
using LinearAlgebra
using Documenter
using Markdown
include("Lagrangien_Augmente.jl")
@doc Lagrangien_Augmente
```
%% Output
# Objet
Résolution des problèmes de minimisation sous contraintes d'égalités par l'algorithme du lagrangien augmenté
# Syntaxe
```julia
Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
hess_contrainte,x0,options)
```
# Entrées
* 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 : (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
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 : (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 : (Integer) nombre d'itérations réalisées
* muk : (Float) valeur de mu_k à la sortie
* lambdak : (Float) valeur de lambda_k à la sortie
# 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]
output = Lagrangien_Augmente(algo,f,contrainte,gradf,hessf,grad_contrainte,hess_contrainte,x0,options)
```
# Tolérances des algorithmes appelés
Pour les tolérances définies dans les algorithmes appelés (Newton et régions de confiance), prendre les tolérances par défaut définies dans ces algorithmes.
\section{Objet}
Résolution des problèmes de minimisation sous contraintes d'égalités par l'algorithme du lagrangien augmenté
\section{Syntaxe}
\begin{verbatim}
Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
hess_contrainte,x0,options)
\end{verbatim}
\section{Entrées}
\begin{itemize}
\item algo : (String) l'algorithme sans contraintes à utiliser:
\begin{itemize}
\item "newton" : pour l'algorithme de Newton
\item "cauchy" : pour le pas de Cauchy
\item "gct" : pour le gradient conjugué tronqué
\end{itemize}
\item fonc : (Function) la fonction à minimiser
\item contrainte : (Function) la contrainte [x est dans le domaine des contraintes ssi $c(x)=0$]
\item gradfonc : (Function) le gradient de la fonction
\item hessfonc : (Function) la hessienne de la fonction
\item grad\_contrainte : (Function) le gradient de la contrainte
\item hess\_contrainte : (Function) la hessienne de la contrainte
\item x0 : (Array\{Float,1\}) la première composante du point de départ du Lagrangien
\item options : (Array\{Float,1\})
\begin{itemize}
\item[1. ] epsilon : utilisé dans les critères d'arrêt
\item[2. ] tol : la tolérance utilisée dans les critères d'arrêt
\item[3. ] itermax : nombre maximal d'itération dans la boucle principale
\item[4. ] lambda0 : la deuxième composante du point de départ du Lagrangien
\item[5. ] mu0,tho : valeurs initiales des variables de l'algorithme
\end{itemize}
\end{itemize}
\section{Sorties}
\begin{itemize}
\item xmin : (Array\{Float,1\}) une approximation de la solution du problème avec contraintes
\item fxmin : (Float) $f(x_{min})$
\item flag : (Integer) indicateur du déroulement de l'algorithme
\begin{itemize}
\item 0 : convergence
\item 1 : nombre maximal d'itération atteint
\item (-1) : une erreur s'est produite
\end{itemize}
\item niters : (Integer) nombre d'itérations réalisées
\item muk : (Float) valeur de mu\_k à la sortie
\item lambdak : (Float) valeur de lambda\_k à la sortie
\end{itemize}
\section{Exemple d'appel}
\begin{verbatim}
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]
output = Lagrangien_Augmente(algo,f,contrainte,gradf,hessf,grad_contrainte,hess_contrainte,x0,options)
\end{verbatim}
\section{Tolérances des algorithmes appelés}
Pour les tolérances définies dans les algorithmes appelés (Newton et régions de confiance), prendre les tolérances par défaut définies dans ces algorithmes.
 Objet
 ≡≡≡≡≡≡≡
Résolution des problèmes de minimisation sous contraintes d'égalités par
l'algorithme du lagrangien augmenté
 Syntaxe
 ≡≡≡≡≡≡≡≡≡
 Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
 hess_contrainte,x0,options)
 Entrées
 ≡≡≡≡≡≡≡≡≡
• 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 : (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
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 : (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 : (Integer) nombre d'itérations réalisées
• muk : (Float) valeur de mu_k à la sortie
• lambdak : (Float) valeur de lambda_k à la sortie
 Exemple d'appel
 ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
 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]
 output = Lagrangien_Augmente(algo,f,contrainte,gradf,hessf,grad_contrainte,hess_contrainte,x0,options)
 Tolérances des algorithmes appelés
 ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
Pour les tolérances définies dans les algorithmes appelés (Newton et régions
de confiance), prendre les tolérances par défaut définies dans ces
algorithmes.
%% Cell type:markdown id: tags:
3. Vérifier que les tests ci-dessous passent.
%% Cell type:code id: tags:
``` julia
using Test
# Tolérance pour les tests d'égalité
tol_erreur = sqrt(eps())
## ajouter les fonctions de test
include("../test/fonctions_de_tests.jl")
include("../test/tester_lagrangien_augmente.jl")
include("../src/Algorithme_De_Newton.jl")
include("../src/Pas_De_Cauchy.jl")
include("../src/Gradient_Conjugue_Tronque.jl")
include("../src/Regions_De_Confiance.jl")
include("../src/Lagrangien_Augmente.jl")
affiche = false
@testset "Test lagrangien augmente" begin
tester_lagrangien_augmente(affiche,Lagrangien_Augmente)
end;
```
%% Cell type:markdown id: tags:
## Interprétation
1.Commenter les résultats obtenus, en étudiant notamment les valeurs de $\lambda_k$ et $\mu_k$.
2.Étudier l'influence du paramètre $\tau$ dans la performance de l'algorithme.
3.**Supplémentaire** :
Que proposez-vous comme méthode pour la résolution des problèmes avec
des contraintes à la fois d'égalité et d'inégalité ? Implémenter (si le temps le permet)
ce nouvel algorithme
src/notebook_regions_confiance.ipynb deleted 100644 → 0
+ 0
− 600
View file @ b45490c8
This diff is collapsed.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment