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

ajout fonctions annexe

parent 4d3e0cf4
Branches
No related tags found
1 merge request!5Refonte ok
%% 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 tel que décrit ci-dessous (fichier `Algorithme_De_Newton.jl`)
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
Justifier
1. Justifier les résultats obtenus pour l'exemple $f_0$ ci-dessus;
1. 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}$;
2. 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.
3. que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.
......
%% Cell type:markdown id: tags:
<center>
<h1> TP-Projet d'optimisation numérique </h1>
<h1> Année 2020-2021 - 2e année département Sciences du Numérique </h1>
<h1> Noms: </h1>
<h1> Prénoms: </h1>
</center>
%% Cell type:markdown id: tags:
# Algorithme de Newton
## Implémentation
1. Coder l’algorithme de Newton local tel que décrit dans la section *Algorithme de Newton* (fichier `Algorithme_De_Newton.jl`)
2. Tester l’algorithme sur les fonctions $f_{1}$ , $f_{2}$ avec les points initiaux $x_{011}$ , $x_{012}$ (pour $f_{1}$ ) et $x_{021}$ , $x_{022}$ , $x_{023}$ (pour $f_{2}$ ) donnés en Annexe A.
%% Cell type:code id: tags:
``` julia
using Pkg
Pkg.status()
```
%% Output
Status `~/.julia/environments/v1.4/Project.toml`
 [c52e3926] Atom v0.12.15
 [336ed68f] CSV v0.6.2
 [159f3aea] Cairo v1.0.3
 [13f3f980] CairoMakie v0.1.2
 [5ae59095] Colors v0.12.2
 [a81c6b42] Compose v0.8.2
 [717857b8] DSP v0.6.7
 [a93c6f00] DataFrames v0.21.2
 [41bf760c] DiffEqSensitivity v6.21.0
 [6d1b261a] DiffEqTutorials v0.7.0 #master (https://github.com/JuliaDiffEq/DiffEqTutorials.jl)
 [0c46a032] DifferentialEquations v6.14.0
 [e30172f5] Documenter v0.24.11
 [90d7349d] Erdos v0.7.0
 [587475ba] Flux v0.10.4
 [f6369f11] ForwardDiff v0.10.10
 [c91e804a] Gadfly v1.3.0
 [4d00f742] GeometryTypes v0.8.3
 [a2cc645c] GraphPlot v0.3.1
 [bd48cda9] GraphRecipes v0.5.4
 [86223c79] Graphs v0.10.3
 [7073ff75] IJulia v1.21.2
 [4138dd39] JLD v0.10.0
 [033835bb] JLD2 v0.1.13
 [e5e0dc1b] Juno v0.8.2
 [b964fa9f] LaTeXStrings v1.1.0
 [093fc24a] LightGraphs v1.3.3
 [5c8ed15e] LinearOperators v1.1.0
 [4854310b] MINPACK v1.1.1
 [99179fae] MTH2210 v0.2.0 #master (https://github.com/amontoison/MTH2210.jl.git)
 [7ebac608] Multigraphs v0.1.0
 [2774e3e8] NLsolve v4.4.0
 [54ca160b] ODEInterface v0.4.6
 [09606e27] ODEInterfaceDiffEq v3.7.0
 [289cfbba] Optinum v0.1.0 #master (https://github.com/mathn7/Optinum)
 [217bec77] OptinumProf v0.1.0 #master (https://github.com/mathn7/OptinumProf.git)
 [1dea7af3] OrdinaryDiffEq v5.41.0
 [d254efa0] PkgSkeleton v0.3.1 #master (https://github.com/triscale-innov/PkgSkeleton.jl)
 [91a5bcdd] Plots v1.4.1
 [d330b81b] PyPlot v2.9.0
 [295af30f] Revise v2.7.2
 [47aef6b3] SimpleWeightedGraphs v1.1.1
 [2913bbd2] StatsBase v0.32.2
 [a6016688] TestOptinum v0.1.0 #master (https://github.com/mathn7/TestOptinum.git)
 [1504d1ba] Toto v0.1.0 [`../../../ENS/Julia/Creation-Pkg/Toto`]
 [44d3d7a6] Weave v0.9.4
 [e88e6eb3] Zygote v0.4.20
 [37e2e46d] LinearAlgebra 
 [d6f4376e] Markdown 
 [de0858da] Printf 
 [8dfed614] Test 
 Status `~/Project.toml` (empty project)
%% Cell type:code id: tags:
``` julia
#using Pkg; Pkg.add("LinearAlgebra"); Pkg.add("Markdown")
#using Pkg; Pkg.add("LinearAlgebra"); Pkg.add("Markdown"); Pkg.add("Documenter")
# using Documenter
using LinearAlgebra
using Documenter
using Markdown
include("Pas_De_Cauchy.jl")
@doc Pas_De_Cauchy
```
%% Output
# Objet
Cette fonction calcule une solution approchée du problème
$$
\min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs
$$
par le calcul du pas de Cauchy
# Syntaxe
```julia
s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
```
# 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
* 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 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)
```
\section{Objet}
Cette fonction calcule une solution approchée du problème
$$\min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs$$
par le calcul du pas de Cauchy
\section{Syntaxe}
\begin{verbatim}
s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
\end{verbatim}
\section{Entrées}
\begin{itemize}
\item gradfk : (Array\{Float,1\}) le gradient de la fonction f appliqué au point $x_k$
\item hessfk : (Array\{Float,2\}) la Hessienne de la fonction f appliqué au point $x_k$
\item delta : (Float) le rayon de la région de confiance
\end{itemize}
\section{Sorties}
\begin{itemize}
\item s : (Array\{Float,1\}) une approximation de la solution du sous-problème
\item e : (Integer) indice indiquant l'état de sortie: si g != 0 si on ne sature pas la boule e <- 1 sinon e <- -1 sinon e <- 0
\end{itemize}
\section{Exemple d'appel}
\begin{verbatim}
g1 = [0; 0]
H1 = [7 0 ; 0 2]
delta1 = 1
s1, e1 = Pas_De_Cauchy(g1,H1,delta1)
\end{verbatim}
 Objet
 ≡≡≡≡≡≡≡
Cette fonction calcule une solution approchée du problème
\min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs
 \min_{||s||< \delta_{k}} q_k(s) = s^{t}g + (1/2)s^{t}Hs
par le calcul du pas de Cauchy
 Syntaxe
 ≡≡≡≡≡≡≡≡≡
 s1, e1 = Pas_De_Cauchy(gradient,Hessienne,delta)
 Entrées
 ≡≡≡≡≡≡≡≡≡
gradfk : (Array{Float,1}) 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 : (Array{Float,2}) 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 : (Float) le rayon de la région de confiance
• delta : (Float) le rayon de la région de confiance
 Sorties
 ≡≡≡≡≡≡≡≡≡
s : (Array{Float,1}) une approximation de la solution du
sous-problème
• 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 sinon e <- -1 sinon e <- 0
• e : (Integer) 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
 ≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡
 g1 = [0; 0]
 H1 = [7 0 ; 0 2]
 delta1 = 1
 s1, e1 = Pas_De_Cauchy(g1,H1,delta1)
%% 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
MethodError: no method matching Base.Docs.Binding(::typeof(Algorithme_De_Newton), ::Symbol)
Closest candidates are:
Base.Docs.Binding(!Matched::Module, ::Symbol) at docs/bindings.jl:12
Stacktrace:
[1] top-level scope at In[6]:39
%% Cell type:markdown id: tags:
## Interprétation
Justifier
1. les résultats obtenus pour l'exemple $f_0$ ci-dessus;
2. que l’algorithme implémenté converge en une itération pour $f_{1}$;
3. que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.
%% Cell type:markdown id: tags:
## Vos réponses?
%% Cell type:markdown id: tags:
# Régions de confiance avec pas de cauchy
## Implémentation
1. Coder l'algorithme du pas de Cauchy d’un sous-problème de
régions de confiance (fichier `Pas_De_Cauchy.jl`). Tester sur les quadratiques proposées en Annexe B.
2. Coder l'algorithme de régions de confiance (fichier `Regions_De_Confiance.jl`). Tester sur les problèmes de l’Annexe A.
%% Cell type:code id: tags:
``` julia
# Vos tests
```
%% Cell type:markdown id: tags:
## Interprétation
1. Quelle relation lie la fonction test $f_1$ et son modèle de Taylor à l’ordre 2 ? Comparer alors les performances de Newton et RC-Pas de Cauchy sur cette fonction.
2. Le rayon initial de la région de confiance est un paramètre important dans l’analyse
de la performance de l’algorithme. Sur quel(s) autre(s) paramètre(s) peut-on jouer
pour essayer d’améliorer cette performance ? Étudier l’influence d’au moins deux de
ces paramètres.
%% Cell type:markdown id: tags:
## Vos réponses?
%% Cell type:markdown id: tags:
# Régions de confiance avec gradient conjugué tronqué
## Implémentation
1. Implémenter l’algorithme du Gradient Conjugué Tronqué, en se basant sur le cours (fichier `Gradient_Conjugue_Tronque.jl`).
On validera les résultats sur les fonctions de l’Annexe C.
2. Intégrer finalement l’algorithme du Gradient Conjugué Tronqué dans le code de
régions de confiance, et appliquer ce code pour résoudre les exemples proposés en
Annexe A.
%% Cell type:code id: tags:
``` julia
# Vos tests
```
%% Cell type:markdown id: tags:
## Interprétation
1. Comparer la décroissance obtenue avec celle du pas de Cauchy, en imposant la sortie
dans l’algorithme 3 au bout d’une itération seulement. Que remarquez vous ?
2. Comparer la décroissance obtenue avec celle du pas de Cauchy dans le cas général.
3. Quels sont les avantages et inconvénients des deux approches ?
%% Cell type:markdown id: tags:
## Vos réponses?
%% Cell type:markdown id: tags:
# Lagrangien augmenté
## 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`)
3.Tester les différentes variantes sur les problèmes en Annexe D.
%% Cell type:code id: tags:
``` julia
# Vos tests
```
%% 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
%% Cell type:markdown id: tags:
## Vos réponses?
......
......@@ -78,7 +78,7 @@ function tester_regions_de_confiance(afficher::Bool,Regions_De_Confiance::Functi
# les tests avec le gradient conjugué tronqué #
###################################################
# Un deuxième sous-ensemble de tests
@testset "avec GCT " begin
#= @testset "avec GCT " begin
# cas de test 1
x_min11, fmin11, flag11, nb_iters11= Regions_De_Confiance("gct",fct1,grad_fct1,hess_fct1,pts1.x011,options1)
if (afficher)
......@@ -113,6 +113,6 @@ function tester_regions_de_confiance(afficher::Bool,Regions_De_Confiance::Functi
afficher_resultats("régions de confiance avec "*"gct","fonction 2","x023",x_min11,fmin23, flag23,sol_exacte_fct2,nb_iters23)
end
@test x_min23 ≈ sol_exacte_fct2 atol=tol_erreur
end
end =#
end
end
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment