Skip to content
Snippets Groups Projects
Commit b45490c8 authored by sophie-mauran's avatar sophie-mauran
Browse files

notebook lagrangien augmente

parent d43e4c2f
Branches
No related tags found
1 merge request!5Refonte ok
Hide whitespace changes
Inline Side-by-side
src/notebook_lagrangien_augmente.ipynb 0 → 100644
+ 386
− 0
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
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment