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

foo

parent b2526514
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 239 additions and 1785 deletions
README.md
+ 6
− 9
View file @ 2d339c79
......@@ -2,15 +2,12 @@
## Récupérer les sources
Pour récupérer les sources, il faut cloner ce dépot git :
```bash
git clone https://gitlab.irit.fr/toc/mathn7/optimisation-numerique/projet-optinum.git
```
Pour récupérer les sources, il faut cloner ce dépot git. Vous pouvez suivre les instructions :
[Cloner un dépôt Gitlab](https://gitlab.irit.fr/toc/etu-n7/documentation/-/wikis/Cloner-un-projet-Gitlab).
## Organisation des sources
Les sujets liés au projet se trouvent dans les notebooks. Voici l'ordre des sujets :
Les sujets liés au projet se trouvent dans les notebooks du répertoire `notebooks`. Voici l'ordre des sujets :
* Newton
* Régions de confiance
......@@ -20,9 +17,9 @@ Pour réaliser le projet vous aurez besoin de cette [documentation](doc-projet.p
## Installation de Julia
Si vous n'avez pas encore installer Julia sur votre compte N7 ou sur votre machine personnelle, suivez les indications :
[Utilisation de Julia à l'N7](https://gitlab.irit.fr/toc/mathn7/wiki/-/wikis/Utilisation-de-Julia-à-l'N7).
Si vous n'avez pas encore installer Julia sur votre compte N7 ou sur votre machine personnelle, suivez les instructions :
[Utilisation de Julia à l'N7](https://gitlab.irit.fr/toc/etu-n7/documentation/-/wikis/Utilisation-de-Julia-à-l'N7).
## Illustration de la méthode de Newton
![newton](newton.gif)
![Newton](newton.gif)
\ No newline at end of file
doc-projet.pdf
+ 0
− 0
View file @ 2d339c79
No preview for this file type
src/Algorithme_De_Newton.jl deleted 100644 → 0
+ 0
− 61
View file @ b2526514
@doc doc"""
#### Objet
Cette fonction implémente l'algorithme de Newton pour résoudre un problème d'optimisation sans contraintes
#### Syntaxe
```julia
xmin,fmin,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
- epsilon : epsilon pour les tests de stagnation
#### 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 s'est arrêté (en respectant cet ordre de priorité si plusieurs critères sont vérifiés)
- 0 : CN1
- 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,fmin,flag,nb_iters = Algorithme_De_Newton(f,gradf,hessf,x0,options)
```
"""
function Algorithme_De_Newton(f::Function,gradf::Function,hessf::Function,x0,options)
"# Si options == [] on prends les paramètres par défaut"
if options == []
max_iter = 100
Tol_abs = sqrt(eps())
Tol_rel = 1e-15
epsilon = 1.e-2
else
max_iter = options[1]
Tol_abs = options[2]
Tol_rel = options[3]
epsilon = options[4]
end
xmin = x0
fmin = f(x0)
flag = 0
nb_iters = 0
return xmin,fmin,flag,nb_iters
end
src/Gradient_Conjugue_Tronque.jl deleted 100644 → 0
+ 0
− 52
View file @ b2526514
@doc doc"""
#### Objet
Cette fonction calcule une solution approchée du problème
```math
\min_{||s||< \Delta} q(s) = s^{t} g + \frac{1}{2} s^{t}Hs
```
par l'algorithme du gradient conjugué tronqué
#### Syntaxe
```julia
s = Gradient_Conjugue_Tronque(g,H,option)
```
#### Entrées :
- g : (Array{Float,1}) un vecteur de ``\mathbb{R}^n``
- H : (Array{Float,2}) une matrice symétrique de ``\mathbb{R}^{n\times n}``
- 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 : (Array{Float,1}) le pas s qui approche la solution du problème : ``min_{||s||< \Delta} q(s)``
#### 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]
xk = [1; 0]
options = []
s = Gradient_Conjugue_Tronque(gradf(xk),hessf(xk),options)
```
"""
function Gradient_Conjugue_Tronque(g,H,options)
"# Si option est vide on initialise les 3 paramètres par défaut"
if options == []
delta = 2
max_iter = 100
tol = 1e-6
else
delta = options[1]
max_iter = options[2]
tol = options[3]
end
n = length(g)
s = zeros(n)
return s
end
src/Lagrangien_Augmente.jl 100755 → 100644
+ 62
− 79
View file @ 2d339c79
@doc doc"""
#### Objet
using LinearAlgebra
include("../src/newton.jl")
include("../src/regions_de_confiance.jl")
"""
Résolution des problèmes de minimisation avec une contrainte d'égalité scalaire par l'algorithme du lagrangien augmenté.
Approximation d'une solution au problème
#### Syntaxe
```julia
xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)
```
min f(x), x ∈ Rⁿ, sous la c c(x) = 0,
#### 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é
- f : (Function) la fonction à minimiser
- gradf : (Function) le gradient de la fonction
- hessf : (Function) la hessienne de la fonction
- c : (Function) la contrainte [x est dans le domaine des contraintes ssi ``c(x)=0``]
- gradc : (Function) le gradient de la contrainte
- hessc : (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
par l'algorithme du lagrangien augmenté.
#### 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
- muks : (Array{Float64,1}) tableau des valeurs prises par mu_k au cours de l'exécution
- lambdaks : (Array{Float64,1}) tableau des valeurs prises par lambda_k au cours de l'exécution
# Syntaxe
#### Exemple d'appel
```julia
using LinearAlgebra
algo = "gct" # ou newton|gct
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]
c(x) = (x[1]^2) + (x[2]^2) -1.5
gradc(x) = [2*x[1] ;2*x[2]]
hessc(x) = [2 0;0 2]
x0 = [1; 0]
options = []
xmin,fxmin,flag,iter,muks,lambdaks = Lagrangien_Augmente(algo,f,gradf,hessf,c,gradc,hessc,x0,options)
```
x_sol, f_sol, flag, nb_iters, μs, λs = lagrangien_augmente(f, gradf, hessf, c, gradc, hessc, x0; kwargs...)
# Entrées
- f : (Function) la ftion à minimiser
- gradf : (Function) le gradient de f
- hessf : (Function) la hessienne de f
- c : (Function) la c à valeur dans R
- gradc : (Function) le gradient de c
- hessc : (Function) la hessienne de c
- x0 : (Vector{<:Real}) itéré initial
- kwargs : les options sous formes d'arguments "keywords"
• max_iter : (Integer) le nombre maximal d'iterations (optionnel, par défaut 1000)
• tol_abs : (Real) la tolérence absolue (optionnel, par défaut 1e-10)
• tol_rel : (Real) la tolérence relative (optionnel, par défaut 1e-8)
• λ0 : (Real) le multiplicateur de lagrange associé à c initial (optionnel, par défaut 2)
• μ0 : (Real) le facteur initial de pénalité de la c (optionnel, par défaut 10)
• τ : (Real) le facteur d'accroissement de μ (optionnel, par défaut 2)
• algo_noc : (String) l'algorithme sans c à utiliser (optionnel, par défaut "rc-gct")
* "newton" : pour l'algorithme de Newton
* "rc-cauchy" : pour les régions de confiance avec pas de Cauchy
* "rc-gct" : pour les régions de confiance avec gradient conjugué tronqué
# Sorties
- x_sol : (Vector{<:Real}) une approximation de la solution du problème
- f_sol : (Real) f(x_sol)
- flag : (Integer) indique le critère sur lequel le programme s'est arrêté
• 0 : convergence
• 1 : nombre maximal d'itération dépassé
- nb_iters : (Integer) le nombre d'itérations faites par le programme
- μs : (Vector{<:Real}) tableau des valeurs prises par μk au cours de l'exécution
- λs : (Vector{<:Real}) tableau des valeurs prises par λk au cours de l'exécution
#### Tolérances des algorithmes appelés
# Exemple d'appel
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.
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]
c(x) = x[1]^2 + x[2]^2 - 1.5
gradc(x) = 2*x
hessc(x) = [2 0; 0 2]
x0 = [1; 0]
x_sol, _ = lagrangien_augmente(f, gradf, hessf, c, gradc, hessc, x0, algo_noc="rc-gct")
"""
function Lagrangien_Augmente(algo,fonc::Function,contrainte::Function,gradfonc::Function,
hessfonc::Function,grad_contrainte::Function,hess_contrainte::Function,x0,options)
function lagrangien_augmente(f::Function, gradf::Function, hessf::Function,
c::Function, gradc::Function, hessc::Function, x0::Vector{<:Real};
max_iter::Integer=1000, tol_abs::Real=1e-10, tol_rel::Real=1e-8,
λ0::Real=2, μ0::Real=10, τ::Real=2, algo_noc::String="rc-gct")
if options == []
epsilon = 1e-2
tol = 1e-5
itermax = 1000
lambda0 = 2
mu0 = 100
tho = 2
else
epsilon = options[1]
tol = options[2]
itermax = options[3]
lambda0 = options[4]
mu0 = options[5]
tho = options[6]
end
#
x_sol = x0
f_sol = f(x_sol)
flag = -1
nb_iters = 0
μs = [μ0] # vous pouvez faire μs = vcat(μs, μk) pour concaténer les valeurs
λs = [λ0]
n = length(x0)
xmin = zeros(n)
fxmin = 0
flag = 0
iter = 0
muk = mu0
muks = [mu0]
lambdak = lambda0
lambdaks = [lambda0]
return x_sol, f_sol, flag, nb_iters, μs, λs
return xmin,fxmin,flag,iter, muks, lambdaks
end
src/Pas_De_Cauchy.jl deleted 100644 → 0
+ 0
− 46
View file @ b2526514
@doc doc"""
#### Objet
Cette fonction calcule une solution approchée du problème
```math
\min_{||s||< \Delta} s^{t}g + \frac{1}{2}s^{t}Hs
```
par le calcul du pas de Cauchy.
#### Syntaxe
```julia
s, e = Pas_De_Cauchy(g,H,delta)
```
#### Entrées
- g : (Array{Float,1}) un vecteur de ``\mathbb{R}^n``
- H : (Array{Float,2}) une matrice symétrique de ``\mathbb{R}^{n\times n}``
- 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
g = [0; 0]
H = [7 0 ; 0 2]
delta = 1
s, e = Pas_De_Cauchy(g,H,delta)
```
"""
function Pas_De_Cauchy(g,H,delta)
e = 0
n = length(g)
s = zeros(n)
return s, e
end
src/Regions_De_Confiance.jl
+ 54
− 77
View file @ 2d339c79
@doc doc"""
using LinearAlgebra
include("../src/cauchy.jl")
include("../src/gct.jl")
"""
Approximation de la solution du problème min f(x), x ∈ Rⁿ.
#### Objet
L'algorithme des régions de confiance résout à chaque itération, un modèle quadratique
de la fonction f dans une boule (appelée la région de confiance) de centre l'itéré
courant. Cette minimisation se fait soit par un pas de Cauchy ou par l'algorithme
du gradient conjugué tronqué.
Minimise une fonction de ``\mathbb{R}^{n}`` à valeurs dans ``\mathbb{R}`` en utilisant l'algorithme des régions de confiance.
# Syntaxe
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é
x_sol, f_sol, flag, nb_iters, xs = regions_de_confiance(f, gradf, hessf, x0; kwargs...)
#### Syntaxe
```julia
xmin, fxmin, flag, nb_iters = Regions_De_Confiance(algo,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
- x0 : (Vector{<:Real}) itéré initial
- kwargs : les options sous formes d'arguments "keywords"
• max_iter : (Integer) le nombre maximal d'iterations (optionnel, par défaut 5000)
• tol_abs : (Real) la tolérence absolue (optionnel, par défaut 1e-10)
• tol_rel : (Real) la tolérence relative (optionnel, par défaut 1e-8)
• epsilon : (Real) le epsilon pour les tests de stagnation (optionnel, par défaut 1)
• Δ0 : (Real) le rayon initial de la région de confiance (optionnel, par défaut 2)
• Δmax : (Real) le rayon maximal de la région de confiance (optionnel, par défaut 10)
• γ1, γ2 : (Real) les facteurs de mise à jour de la région de confiance (optionnel, par défaut 0.5 et 2)
• η1, η2 : (Real) les seuils pour la mise à jour de la région de confiance (optionnel, par défaut 0.25 et 0.75)
• algo_pas : (String) l'algorithme de calcul du pas - "cauchy" ou "gct" (optionnel, par défaut "gct")
• max_iter_gct : (Integer) le nombre maximal d'iterations du GCT (optionnel, par défaut 2*length(x0))
- 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 : (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_abs : la tolérence absolue
- Tol_rel : la tolérence relative
- epsilon : epsilon pour les tests de stagnation
# Sorties
#### Sorties:
- x_sol : (Vector{<:Real}) une approximation de la solution du problème
- f_sol : (Real) f(x_sol)
- flag : (Integer) indique le critère sur lequel le programme s'est arrêté
• 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
- xs : (Vector{Vector{<:Real}}) les itérés
- 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 s'est arrêté (en respectant cet ordre de priorité si plusieurs critères sont vérifiés)
- 0 : CN1
- 1 : stagnation du ``x``
- 2 : stagnation du ``f``
- 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
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, fxmin, flag, nb_iters = Regions_De_Confiance(algo,f,gradf,hessf,x0,options)
```
"""
function Regions_De_Confiance(algo,f::Function,gradf::Function,hessf::Function,x0,options)
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]
x_sol, f_sol, flag, nb_iters, xs = regions_de_confiance(f, gradf, hessf, x0, algo_pas="gct")
if options == []
deltaMax = 10
gamma1 = 0.5
gamma2 = 2.00
eta1 = 0.25
eta2 = 0.75
delta0 = 2
max_iter = 1000
Tol_abs = sqrt(eps())
Tol_rel = 1e-15
epsilon = 1.e-2
else
deltaMax = options[1]
gamma1 = options[2]
gamma2 = options[3]
eta1 = options[4]
eta2 = options[5]
delta0 = options[6]
max_iter = options[7]
Tol_abs = options[8]
Tol_rel = options[9]
epsilon = options[10]
end
"""
function regions_de_confiance(f::Function, gradf::Function, hessf::Function, x0::Vector{<:Real};
max_iter::Integer=5000, tol_abs::Real=1e-10, tol_rel::Real=1e-8, epsilon::Real=1,
Δ0::Real=2, Δmax::Real=10, γ1::Real=0.5, γ2::Real=2, η1::Real=0.25, η2::Real=0.75, algo_pas::String="gct",
max_iter_gct::Integer = 2*length(x0))
n = length(x0)
xmin = zeros(n)
fxmin = f(xmin)
flag = 0
#
x_sol = x0
f_sol = f(x_sol)
flag = -1
nb_iters = 0
xs = [x0] # vous pouvez faire xs = vcat(xs, [xk]) pour concaténer les valeurs
return xmin, fxmin, flag, nb_iters
return x_sol, f_sol, flag, nb_iters, xs
end
src/algo_newton.ipynb deleted 100644 → 0
+ 0
− 152
View file @ b2526514
%% 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
```
%% 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 # Mettre affiche = true pour afficher les résultats
# des appels à l'algorithme de Newton. Cela peut vous
# servir pour les réponses aux questions en fin de notebook.
@testset "Test algo newton" begin
# Tester l'algorithme de Newton
tester_algo_newton(affiche,Algorithme_De_Newton)
end;
```
%% 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)
```
%% Cell type:markdown id: tags:
## Interprétation
1. Justifier les résultats obtenus pour l'exemple $f_0$ ci-dessus;
2. Soit
$$ f_{1} : \mathbb{R}^3 \rightarrow \mathbb{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} : \mathbb{R}^2 \rightarrow \mathbb{R}$$ $$ (x_1,x_2) \mapsto 100(x_2-x_1^2)^2 + (1-x_1)^2 $$
Justifier que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.
**Remarque.** Vous pouvez mettre `affiche=true` dans les tests de l'algorithme de Newton pour
vous aider.
src/lagrangien_augmente.ipynb deleted 100644 → 0
+ 0
− 586
View file @ b2526514
This diff is collapsed.
src/regions_confiance.ipynb deleted 100644 → 0
+ 0
− 262
View file @ b2526514
%% Cell type:markdown id: tags:
<center>
<h1> TP-Projet d'optimisation numérique </h1>
<h1> Algorithme des Régions de Confiance </h1>
</center>
%% 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`). La spécification de cet algorithme est donnée ci-dessous.
%% Cell type:code id: tags:
``` julia
using LinearAlgebra
using Documenter
using Markdown
include("Pas_De_Cauchy.jl")
# @doc Pas_De_Cauchy
```
%% Output
Pas_De_Cauchy
%% Cell type:markdown id: tags:
2. Ecrire des tests exhaustifs (qui testent tous les cas de figure possibles) pour votre algorithme du Pas de Cauchy. Vous créerez pour cela un fichier `tester_pas_de_Cauchy.jl` dans le répertoire `test` sur le modèle des autres fichiers de tests et vous exécuterez dans la cellule de code ci-après ces tests.
%% Cell type:code id: tags:
``` julia
```
%% Cell type:markdown id: tags:
3. Coder l'algorithme des Régions de Confiance (fichier `Regions_De_Confiance.jl`). Sa spécification est donnée ci-dessous.
%% Cell type:code id: tags:
``` julia
include("Regions_De_Confiance.jl")
# @doc Regions_De_Confiance
```
%% Cell type:markdown id: tags:
4. 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_regions_de_confiance.jl")
include("../src/Pas_De_Cauchy.jl")
include("../src/Regions_De_Confiance.jl")
affiche = false
@testset "Test rc avec cauchy" begin
tester_regions_de_confiance(affiche,Regions_De_Confiance)
end;
```
%% Cell type:markdown id: tags:
## Interprétation
<!-- Pour ces questions, des représentations graphiques sont attendues pour corroborer vos réponses. -->
1. 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$$ Quelle relation lie la fonction $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. Pour cela vous ferez des tests numériques et donnerez les résultats sous forme de tableaux et de graphiques.
%% Cell type:markdown id: tags:
# Régions de confiance avec Gradient Conjugué
## Implémentation
1. Implémenter l’algorithme du Gradient Conjugué Tronqué (fichier `Gradient_Conjugue_Tronque.jl`). Sa spécification est donnée ci-dessous.
%% Cell type:code id: tags:
``` julia
include("Gradient_Conjugue_Tronque.jl")
# @doc Gradient_Conjugue_Tronque
```
%% 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_gct.jl")
include("../src/Gradient_Conjugue_Tronque.jl")
affiche = false
@testset "Test gct" begin
tester_gct(affiche,Gradient_Conjugue_Tronque)
end;
```
%% Cell type:markdown id: tags:
3. Intégrer l’algorithme du Gradient Conjugué Tronqué dans le code de régions de confiance (fichier `Regions_De_Confiance.jl`).
4. Décommenter les tests avec le gradient conjugué dans `tester_regions_de_confiance.jl` et vérifier que les tests 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_regions_de_confiance.jl")
include("../src/Pas_De_Cauchy.jl")
include("../src/Gradient_Conjugue_Tronque.jl")
include("../src/Regions_De_Confiance.jl")
affiche = false
@testset "Test rc avec cauchy et gct" begin
tester_regions_de_confiance(affiche,Regions_De_Confiance)
end;
```
%% 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 au bout d’une itération seulement. Vous donnerez ci-après des résultats numériques.
1. 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:code id: tags:
``` julia
```
%% Cell type:code id: tags:
``` julia
```
%% Cell type:code id: tags:
``` julia
```
test/cacher_stacktrace.jl deleted 100755 → 0
+ 0
− 24
View file @ b2526514
using Test
@doc doc"""
Cacher les traces d'appels des tests erronés ou échoués, pour les remettre, décommentez les lignes 11 et 16.
"""
function cacher_stacktrace()
Test.eval(quote
function record(ts::DefaultTestSet, t::Union{Fail, Error})
if myid() == 1
#printstyled(ts.description, ": ", color=:white) # afficher la description du testset
# ne pas afficher pour les tests interrompus
if !(t isa Error) || t.test_type != :test_interrupted
# print(t) # afficher le resultat et la solution attendu
if !isa(t, Error)
# Base.show_backtrace(stdout, scrub_backtrace(backtrace())) # afficher la trace d'appels
end
end
end
push!(ts.results, t)
t, isa(t, Error) || backtrace()
end
end)
end
test/fonctions_de_tests.jl
+ 12
− 11
View file @ 2d339c79
"""
Ce fichier contient toutes fonctions utilisés dans les tests des algorithmes :
- L'algorithme de Newton
- Les régions de confiance
- Le Lagrangien augmenté
- L'algorithme de Newton
- Les régions de confiance
- Le Lagrangien augmenté
"""
# Les points initiaux
......@@ -97,12 +97,13 @@ grad_contrainte2(x) = [2*x[1] ;2*x[2]]
hess_contrainte2(x) = [2 0;0 2]
# Affichage les sorties de l'algorithme des Régions de confiance
function 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)
function afficher_resultats(algo, nom_fct, x0, x_sol, f_sol, flag, nbiters, solution)
println("-------------------------------------------------------------------------")
printstyled("Résultats de : ",algo, " appliqué à ", nom_fct, ":\n", bold=true, color=:blue)
println(" * x0 = ", x0)
println(" * x_sol = ", x_sol)
println(" * f(x_sol) = ", f_sol)
println(" * nb_iters = ", nbiters)
println(" * flag = ", flag)
println(" * solution = ", solution)
end
test/new_runtests.jl deleted 100644 → 0
+ 0
− 49
View file @ b2526514
using Markdown
using Test
using LinearAlgebra
include("../src/Algorithme_De_Newton.jl")
include("../src/Gradient_Conjugue_Tronque.jl")
include("../src/Lagrangien_Augmente.jl")
include("../src/Pas_De_Cauchy.jl")#
include("../src/Regions_De_Confiance.jl")
#include("cacher_stacktrace.jl")
#cacher_stacktrace()
# Tolérance pour les tests d'égalité
tol_erreur = sqrt(eps())
## ajouter les fonctions de test
include("./fonctions_de_tests.jl")
include("./tester_algo_newton.jl")
include("tester_pas_de_cauchy.jl")
#
include("tester_gct.jl")
include("tester_regions_de_confiance.jl")
include("tester_lagrangien_augmente.jl")
affiche = true
println("affiche = ",affiche)
# Tester l'ensemble des algorithmes
@testset "Test SujetOptinum" begin
# Tester l'algorithme de Newton
tester_algo_newton(affiche,Algorithme_De_Newton)
# Tester l'algorithme du pas de Cauchy
tester_pas_de_cauchy(affiche,Pas_De_Cauchy)
# Tester l'algorithme du gradient conjugué tronqué
tester_gct(affiche,Gradient_Conjugue_Tronque)
# Tester l'algorithme des Régions de confiance avec PasdeCauchy | GCT
tester_regions_de_confiance(affiche,Regions_De_Confiance)
# Tester l'algorithme du Lagrangien Augmenté
tester_lagrangien_augmente(affiche,Lagrangien_Augmente)
end
test/tester_algo_newton.jl deleted 100755 → 0
+ 0
− 133
View file @ b2526514
@doc doc"""
Tester l'algorithme de Newton local
# Entrées :
* afficher : (Bool) affichage ou non des résultats de chaque test
# Les cas de test (dans l'ordre)
* fct 1 : x011, x012
* fct 2 : x021, x022, x023
"""
function tester_algo_newton(afficher::Bool, Algorithme_De_Newton::Function)
max_iter = 100
Tol_abs = sqrt(eps())
Tol_rel = 1e-15
epsilon = 1.0
options = [max_iter, Tol_abs, Tol_rel, epsilon]
@testset "L'algo de Newton" begin
@testset "Cas test 1 x0 = solution" begin
# point de départ x011
x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, sol_exacte_fct1, options)
if (afficher)
afficher_resultats("algorithme de Newton ", "fct1", "x011", x_min, fx_min, flag, sol_exacte_fct1, nb_iters)
end
@testset "solution" begin
@test isapprox(x_min, sol_exacte_fct1, atol=tol_erreur)
end
@testset "itération" begin
@test nb_iters == 0
end
@testset "flag" begin
@test flag == 0
end
end
@testset "Cas test 1 x0 = x011" begin
#point de départ x011
x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, pts1.x011, options)
if (afficher)
afficher_resultats("algorithme de Newton ", "fct1", "x011", x_min, fx_min, flag, sol_exacte_fct1, nb_iters)
end
@testset "solution" begin
@test isapprox(x_min, sol_exacte_fct1, atol=tol_erreur)
end
@testset "itération" begin
@test nb_iters == 1
end
@testset "flag" begin
@test flag == 0
end
end
@testset "Cas test 1 x0 = x012" begin
x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, pts1.x012, options)
if (afficher)
afficher_resultats("algorithme de Newton ", "fct1", "x012", x_min, fx_min, flag, sol_exacte_fct1, nb_iters)
end
@testset "solution" begin
@test x_min ≈ sol_exacte_fct1 atol = tol_erreur
end
@testset "itération" begin
@test nb_iters == 1
end
@testset "flag" begin
@test flag == 0
end
end
@testset "Cas test 2 x0 = solution" begin
x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct1, grad_fct1, hess_fct1, sol_exacte_fct1, options)
if (afficher)
afficher_resultats("algorithme de Newton ", "fct1", "x011", x_min, fx_min, flag, sol_exacte_fct1, nb_iters)
end
@testset "solution" begin
@test isapprox(x_min, sol_exacte_fct1, atol=tol_erreur)
end
@testset "itération" begin
@test nb_iters == 0
end
@testset "flag" begin
@test flag == 0
end
end
@testset "Cas test 2 x0 = x021" begin
x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, pts1.x021, options)
if (afficher)
afficher_resultats("algorithme de Newton ", "fct2", "x021", x_min, fx_min, flag, sol_exacte_fct2, nb_iters)
end
@testset "solution" begin
@test x_min ≈ sol_exacte_fct2 atol = tol_erreur
end
@testset "itération" begin
@test nb_iters == 6
end
@testset "flag" begin
@test flag == 0
end
end
@testset "Cas test 2 x0 = x022" begin
x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, pts1.x022, options)
if (afficher)
afficher_resultats("algorithme de Newton ", "fct2", "x022", x_min, fx_min, flag, sol_exacte_fct2, nb_iters)
end
@testset "solution" begin
@test x_min ≈ sol_exacte_fct2 atol = tol_erreur
end
@testset "itération" begin
@test nb_iters == 5
end
@testset "flag" begin
@test flag == 0
end
end
@testset "Cas test 2 x0 = x023" begin
options[1] = 1
sol = [-4.99999958629818e9, 8.673617379884035e-19]
x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, pts1.x023, options)
if (afficher)
afficher_resultats("algorithme de Newton ", "fct2", "x023", x_min, fx_min, flag, sol_exacte_fct2, nb_iters)
end
@testset "solution" begin
@test x_min ≈ sol atol = tol_erreur
end
@testset "flag" begin
@test flag == 3
end
@testset "itération" begin
@test nb_iters == 1
end
@testset "exception" begin
options[1] = 100
@test_throws SingularException x_min, fx_min, flag, nb_iters = Algorithme_De_Newton(fct2, grad_fct2, hess_fct2, pts1.x023, options)
end
end
end
end
test/tester_gct.jl
+ 48
− 63
View file @ 2d339c79
@doc doc"""
Tester l'algorithme du gradient conjugué tronqué
using Test
# Entrées :
* afficher : (Bool) affichage ou non des résultats de chaque test
"""
Tester l'algorithme du gient conjugué tronqué
# Les cas de test (dans l'ordre)
* la quadratique 1
* la quadratique 2
* la quadratique 3
* la quadratique 4
* la quadratique 5
* la quadratique 6
- la quadratique 1
- la quadratique 2
- la quadratique 3
- la quadratique 4
- la quadratique 5
- la quadratique 6
"""
function tester_gct(afficher::Bool,Gradient_Conjugue_Tronque::Function)
function tester_gct(gct::Function)
tol = 1e-7
max_iter = 100
# Tolérance utilisé dans les tests
tol_test = 1e-3
@testset "Gradient-CT" begin
@testset "Gradient conjugué tronqué" begin
# le cas de test 1
grad = [0 ; 0]
Hess = [7 0 ; 0 2]
delta = 1
s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
g = [0 ; 0]
H = [7 0 ; 0 2]
Δ = 1
s = gct(g,H,Δ)
@test s ≈ [0.0 ; 0.0] atol = tol_test
# le cas de test 2 H definie positive
grad = [6 ; 2]
Hess = [7 0 ; 0 2]
delta = 0.5 # sol = pas de Cauchy
s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
@test s ≈ -delta*grad/norm(grad) atol = tol_test
delta = 1.2 # saturation à la 2ieme itération
s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
g = [6 ; 2]
H = [7 0 ; 0 2]
Δ = 0.5 # sol = pas de Cauchy
s = gct(g,H,Δ)
@test s ≈ -Δ*g/norm(g) atol = tol_test
Δ = 1.2 # saturation à la 2ieme itération
s = gct(g,H,Δ)
@test s ≈ [-0.8740776099190263, -0.8221850958502244] atol = tol_test
delta = 3 # sol = min global
s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
@test s ≈ -Hess\grad atol = tol_test
Δ = 3 # sol = min global
s = gct(g,H,Δ)
@test s ≈ -H\g atol = tol_test
# le cas test 2 bis matrice avec 1 vp < 0 et 1 vp > 0
grad = [1,2]
Hess = [1 0 ; 0 -1]
delta = 1. # g^T H g < 0 première direction concave
s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
@test s ≈ -delta*grad/norm(grad) atol = tol_test
grad = [1,0]
delta = 0.5 # g^T H g > 0 sol pas de Cauchy
s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
@test s ≈ -delta*grad/norm(grad) atol = tol_test
grad = [2,1] # g^T H g > 0 sol à l'itération 2, saturation
delta = 6
s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
g = [1,2]
H = [1 0 ; 0 -1]
Δ = 1. # g^T H g < 0 première direction concave
s = gct(g,H,Δ)
@test s ≈ -Δ*g/norm(g) atol = tol_test
g = [1,0]
Δ = 0.5 # g^T H g > 0 sol pas de Cauchy
s = gct(g,H,Δ)
@test s ≈ -Δ*g/norm(g) atol = tol_test
g = [2,1] # g^T H g > 0 sol à l'itération 2, saturation
Δ = 6
s = gct(g,H,Δ)
@test isapprox(s, [0.48997991959774634, 5.979959839195494], atol = tol_test) || isapprox(s, [-4.489979919597747, -3.979959839195493], atol = tol_test)
# le cas de test 3
#grad = [-2 ; 1]
#Hess = [-2 0 ; 0 10]
#delta = 10
#s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
#@test s ≈ [9.102342582478453; -4.140937032991381] atol = tol_test
# le cas de test 4
#grad = [0 ; 0]
#Hess = [-2 0 ; 0 10]
#delta = 1
#s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
#@test s ≈ [0.0 ; 0.0] atol = tol_test
# le cas de test 5
grad = [2 ; 3]
Hess = [4 6 ; 6 5]
delta = 3
s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
g = [2 ; 3]
H = [4 6 ; 6 5]
Δ = 3
s = gct(g,H,Δ)
@test s ≈ [1.9059020876695578 ; -2.3167946029410595] atol = tol_test
# le cas de test 6
# Le pas de Cauchy conduit à un gradient nul en 1 itération
grad = [2 ; 0]
Hess = [4 0 ; 0 -15]
delta = 2
s = Gradient_Conjugue_Tronque(grad,Hess,[delta;max_iter;tol])
# Le pas de Cauchy conduit à un gient nul en 1 itération
g = [2 ; 0]
H = [4 0 ; 0 -15]
Δ = 2
s = gct(g,H,Δ)
@test s ≈ [-0.5 ; 0.0] atol = tol_test
end
end
test/tester_lagrangien_augmente.jl
+ 57
− 41
View file @ 2d339c79
@doc doc"""
Tester l'algorithme du Lagrangien augmenté
using Test
include("../test/fonctions_de_tests.jl")
# Entrées :
* affichage : (Bool) affichage ou non des résultats de chaque test
"""
Tester l'algorithme du lagrangien augmenté
# Entrées
- afficher : (Bool) affichage ou non des résultats de chaque test
# Les cas de test (dans l'ordre)
* Newton
* fct1 : x01, x02
* fct2 : x03, x04
* gct
* fct1 : x01, x02
* fct2 : x03, x04
* Cauchy
* fct1 : x01, x02
* fct2 : x03, x04
- Newton
• fct1 : x01, x02
• fct2 : x03, x04
- gct
• fct1 : x01, x02
• fct2 : x03, x04
- Cauchy
• fct1 : x01, x02
• fct2 : x03, x04
"""
function tester_lagrangien_augmente(afficher::Bool,Lagrangien_Augmente::Function)
function tester_lagrangien_augmente(LA::Function, afficher::Bool)
println("Affichage des résultats des algorithmes : ", afficher, "\n")
# initialisation des paramètres
lambda0 = 2
mu0 = 10
tho = 2
epsilon = 1.
tol = 1e-5
max_iters = 1000
options = [epsilon, tol, max_iters, lambda0, mu0, tho]
# La tolérance utilisée dans les tests
tol_erreur = 1e-4
# initialisation des paramètres
tol = 1e-5 # tol_abs et tol_rel
# Les trois algorithmes d'optimisations sans contraintes utlisés
algos = ["newton", "gct", "cauchy"]
algos = ["newton", "rc-cauchy", "rc-gct"]
#
f1 = fct1; gf1 = grad_fct1; Hf1 = hess_fct1; c1 = contrainte1; gc1 = grad_contrainte1; Hc1 = hess_contrainte1
f2 = fct2; gf2 = grad_fct2; Hf2 = hess_fct2; c2 = contrainte2; gc2 = grad_contrainte2; Hc2 = hess_contrainte2
x01 = pts2.x01
x02 = pts2.x02
x03 = pts2.x03
x04 = pts2.x04
@testset "Lagrangien augmenté " begin
@testset "Avec $algo" for algo in algos
@testset "Lagrangien augmenté " begin
@testset "Avec $algo" for algo in algos
# le cas de test 1
xmin,fxmin,flag,nbiters = Lagrangien_Augmente(algo,fct1,contrainte1,grad_fct1,hess_fct1,grad_contrainte1,
hess_contrainte1,pts2.x01,options)
x0 = x01
x_sol, f_sol, flag, nb_iters, _ = LA(f1, gf1, Hf1, c1, gc1, Hc1, x0, tol_abs=tol, tol_rel=tol, algo_noc=algo)
if (afficher)
afficher_resultats("Lagrangien augmenté avec "*algo,"fonction 1","x01",xmin,fxmin,flag,sol_fct1_augm,nbiters)
afficher_resultats("LA et " * algo, "f1", x0, x_sol, f_sol, flag, nb_iters, sol_fct1_augm)
end
@test isapprox(xmin,sol_fct1_augm ,atol=tol_erreur)
@test x_sol ≈ sol_fct1_augm atol=tol_erreur
# le cas de test 2
xmin ,fxmin,flag,nbiters = Lagrangien_Augmente(algo,fct1,contrainte1,grad_fct1,hess_fct1,grad_contrainte1,
hess_contrainte1,pts2.x02,options)
x0 = x02
x_sol, f_sol, flag, nb_iters, _ = LA(f1, gf1, Hf1, c1, gc1, Hc1, x0, tol_abs=tol, tol_rel=tol, algo_noc=algo)
if (afficher)
afficher_resultats("Lagrangien augmenté avec "*algo,"fonction 1","x02",xmin,fxmin,flag,sol_fct1_augm,nbiters)
afficher_resultats("LA et " * algo, "f1", x0, x_sol, f_sol, flag, nb_iters, sol_fct1_augm)
end
@test xmin ≈ sol_fct1_augm atol=tol_erreur
@test x_sol ≈ sol_fct1_augm atol=tol_erreur
# le cas de test 3
xmin,fxmin,flag,nbiters = Lagrangien_Augmente(algo,fct2,contrainte2,grad_fct2,hess_fct2,grad_contrainte2,
hess_contrainte2,pts2.x03,options)
x0 = x03
x_sol, f_sol, flag, nb_iters, _ = LA(f2, gf2, Hf2, c2, gc2, Hc2, x0, tol_abs=tol, tol_rel=tol, algo_noc=algo)
if (afficher)
afficher_resultats("Lagrangien augmenté avec "*algo,"fonction 2","x03",xmin,fxmin,flag,sol_fct2_augm,nbiters)
afficher_resultats("LA et " * algo, "f2", x0, x_sol, f_sol, flag, nb_iters, sol_fct2_augm)
end
@test xmin ≈ sol_fct2_augm atol=tol_erreur
@test x_sol ≈ sol_fct2_augm atol=tol_erreur
# le cas de test 4
xmin ,fxmin,flag,nbiters = Lagrangien_Augmente(algo,fct2,contrainte2,grad_fct2,hess_fct2,grad_contrainte2,
hess_contrainte2,pts2.x04,options)
x0 = x04
x_sol, f_sol, flag, nb_iters, _ = LA(f2, gf2, Hf2, c2, gc2, Hc2, x0, tol_abs=tol, tol_rel=tol, algo_noc=algo)
if (afficher)
afficher_resultats("Lagrangien augmenté avec "*algo,"fonction 2","x04",xmin,fxmin,flag,sol_fct2_augm,nbiters)
afficher_resultats("LA et " * algo, "f2", x0, x_sol, f_sol, flag, nb_iters, sol_fct2_augm)
end
@test xmin ≈ sol_fct2_augm atol=tol_erreur
@test x_sol ≈ sol_fct2_augm atol=tol_erreur
end
end
end
test/tester_regions_de_confiance.jl deleted 100755 → 0
+ 0
− 140
View file @ b2526514
@doc doc"""
Tester l'algorithme des régions de confiance
# Entrées :
* affichage : (Bool) affichage ou non des résultats de chaque test
# les cas de test (dans l'ordre)
* avec Cauchy :
- fct 1 : x011,x012
- fct 2 : x021,x022,x023
* avec gct :
- fct 1 : x011,x012
- fct 2 : x021,x022,x023
"""
function tester_regions_de_confiance(afficher::Bool,Regions_De_Confiance::Function)
# La tolérance utilisée dans les tests
tol_erreur = 1e-2
# initialisation des variables de l'algorithme
gamma1 = 0.5
gamma2 = 2.00
eta1 = 0.25
eta2 = 0.75
deltaMax = 10
Tol_abs = sqrt(eps())
Tol_rel = 1e-8
epsilon = 1
maxits = 5000
delta0_1 = 2
delta0_2 = 2
options1 =[deltaMax,gamma1,gamma2,eta1,eta2,delta0_1,maxits,Tol_abs,Tol_rel,epsilon]
options2 =[deltaMax,gamma1,gamma2,eta1,eta2,delta0_2,maxits,Tol_abs,Tol_rel,epsilon]
# l'ensemble de tests
@testset "La méthode des RC " begin
###################################################
# les tests avec le pas de Cauchy #
###################################################
# Un premier sous-ensemble de tests
@testset "avec Cauchy " begin
# cas de test 1
x_min11, fmin11, flag11, nb_iters11 = Regions_De_Confiance("cauchy",fct1,grad_fct1,hess_fct1,pts1.x011,options1)
if (afficher)
afficher_resultats("régions de confiance avec "*"cauchy","fonction 1","x011",x_min11,fmin11, flag11,sol_exacte_fct1,nb_iters11)
end
@test isapprox(x_min11,sol_exacte_fct1 ,atol=tol_erreur)
@test flag11 == 2
@test nb_iters11 == 26
# cas de test 2
x_min12, fmin12, flag12, nb_iters12 = Regions_De_Confiance("cauchy",fct1,grad_fct1,hess_fct1,pts1.x012,options1)
if (afficher)
afficher_resultats("régions de confiance avec "*"cauchy","fonction 1","x012",x_min12,fmin12, flag11,sol_exacte_fct1,nb_iters12)
end
@test x_min12 ≈ sol_exacte_fct1 atol=tol_erreur
@test flag12 == 2
@test nb_iters12 == 28
# cas de test 3
x_min21, fmin21, flag21, nb_iters21, = Regions_De_Confiance("cauchy",fct2,grad_fct2,hess_fct2,pts1.x021,options2)
if (afficher)
afficher_resultats("régions de confiance avec "*"cauchy","fonction 2","x021",x_min21,fmin21, flag21,sol_exacte_fct2,nb_iters21)
end
@test x_min21 ≈ sol_exacte_fct2 atol=tol_erreur
@test flag21 == 2
@test nb_iters21 == 3988
# cas de test 4
x_min22, fmin22, flag22, nb_iters22 = Regions_De_Confiance("cauchy",fct2,grad_fct2,hess_fct2,pts1.x022,options2)
println("iters = ", nb_iters22)
if (afficher)
afficher_resultats("régions de confiance avec "*"cauchy","fonction 2","x022",x_min22,fmin22, flag22,sol_exacte_fct2,nb_iters22)
end
@test x_min22 ≈ sol_exacte_fct2 atol=tol_erreur
@test flag22 == 0
@test nb_iters22 == 864
# cas de test 5
x_min23, fmin23, flag23, nb_iters23 = Regions_De_Confiance("cauchy",fct2,grad_fct2,hess_fct2,pts1.x023,options2)
if (afficher)
afficher_resultats("régions de confiance avec "*"cauchy","fonction 2","x023",x_min23,fmin23, flag23,sol_exacte_fct2,nb_iters23)
end
@test x_min23 ≈ sol_exacte_fct2 atol=tol_erreur
@test flag23 == 2
@test nb_iters23 == 3198
end
###################################################
# les tests avec le gradient conjugué tronqué #
###################################################
# Un deuxième sous-ensemble de tests
#= @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)
afficher_resultats("régions de confiance avec "*"gct","fonction 1","x011",x_min11,fmin11, flag11,sol_exacte_fct1,nb_iters11)
end
@test isapprox(x_min11,sol_exacte_fct1 ,atol=tol_erreur)
@test flag11 == 0
@test nb_iters11 == 1
# cas de test 2
x_min12, fmin12, flag12, nb_iters12 = Regions_De_Confiance("gct",fct1,grad_fct1,hess_fct1,pts1.x012,options1)
if (afficher)
afficher_resultats("régions de confiance avec "*"gct","fonction 1","x012",x_min12,fmin12, flag12,sol_exacte_fct1,nb_iters12)
end
@test x_min12 ≈ sol_exacte_fct1 atol=tol_erreur
@test flag12 == 0
@test nb_iters12 == 3
# cas de test 3
x_min21, fmin21, flag21, nb_iters21 = Regions_De_Confiance("gct",fct2,grad_fct2,hess_fct2,pts1.x021,options2)
if (afficher)
afficher_resultats("régions de confiance avec "*"gct","fonction 2","x021",x_min21,fmin21, flag21,sol_exacte_fct2,nb_iters21)
end
@test x_min21 ≈ sol_exacte_fct2 atol=tol_erreur
@test flag21 == 0
@test nb_iters21 == 31
# cas de test 4
x_min22, fmin22, flag22, nb_iters22 = Regions_De_Confiance("gct",fct2,grad_fct2,hess_fct2,pts1.x022,options2)
if (afficher)
afficher_resultats("régions de confiance avec "*"gct","fonction 2","x022",x_min22,fmin22, flag22,sol_exacte_fct2,nb_iters22)
end
@test x_min22 ≈ sol_exacte_fct2 atol=tol_erreur
@test flag22 == 0
@test nb_iters22 == 44
# cas de test 5
x_min23, fmin23, flag23, nb_iters23 = Regions_De_Confiance("gct",fct2,grad_fct2,hess_fct2,pts1.x023,options2)
if (afficher)
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
@test flag23 == 0
@test nb_iters23 == 19
end =#
end
end
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment