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

foo

parent 2d339c79
No related branches found
No related tags found
No related merge requests found
%% 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. 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 `src/lagrangien_augmente.jl`). La spécification est donnée dans le fichier.
2. Vérifier que les tests ci-dessous passent.
%% Cell type:code id: tags:
``` julia
include("../src/lagrangien_augmente.jl")
include("../test/tester_lagrangien_augmente.jl")
#
afficher = false # si true, alors affiche les résultats des algorithmes
#
tester_lagrangien_augmente(lagrangien_augmente, afficher);
```
%% Cell type:markdown id: tags:
## Interprétation
1. Commenter les résultats obtenus, en étudiant notamment les valeurs en sortie de $\lambda_k$ et $\mu_k$.
2. Étudier l'influence du paramètre $\tau$ dans la performance de l'algorithme. Pour cela Vous réaliserez des tests numériques.
%% Cell type:code id: tags:
``` julia
# Expérimentations numériques à faire ici.
# Vous pouvez utiliser le package Plots pour les affichages de courbes: using Plots
```
%% 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 dans le fichier `src/newton.jl` en respectant la spécification donnée dans ce même fichier ;
2. Exécuter les tests ci-dessous et vérifier qu'ils passent.
Pour les tests, nous avons défini les fonctions suivantes $f_1 \colon \mathbb{R}^3 \to \mathbb{R}$
et $f_2 \colon \mathbb{R}^2 \to \mathbb{R}$.
$$
f_{1}(x_1, x_2, x_3) = 2 (x_1 +x_2 + x_3 -3)^2 + (x_1-x_2)^2 + (x_2 - x_3)^2
$$
et
$$
f_{2}(x_1,x_2) = 100(x_2-x_1^2)^2 + (1-x_1)^2.
$$
**Remarque.** On peut retrouver ces fonctions dans le fichier `test/fonctions_de_tests.jl`.
%% Cell type:code id: tags:
``` julia
include("../src/newton.jl") # votre algorithme de Newton
include("../test/tester_newton.jl") # la fonction pour tester votre algorithme de Newton
#
afficher = false # si true, alors affiche les résultats des algorithmes
#
tester_newton(newton, afficher); # tester l'algorithme de Newton
```
%% Output
Affichage des résultats des algorithmes : false
Test Summary: | Pass Total Time
algorithme de Newton |  19  19 0.6s
%% Cell type:code id: tags:
``` julia
include("../src/newton.jl") # votre algorithme de Newton
include("../test/fonctions_de_tests.jl") # pour avoir la fonction d'affichage des résultats
# Fonction f0
# -----------
f0(x) = sin(x)
grad_f0(x) = cos(x) # la gradient de la fonction f0
hess_f0(x) = -sin(x) # la hessienne de la fonction f0
solution = -pi/2
x0 = solution
x_sol, f_sol, flag, nb_iters = newton(f0, grad_f0, hess_f0, x0)
afficher_resultats("Newton", "f0", x0, x_sol, f_sol, flag, nb_iters, solution)
x0 = -pi/2+0.5
x_sol, f_sol, flag, nb_iters = newton(f0, grad_f0, hess_f0, x0)
afficher_resultats("Newton", "f0", x0, x_sol, f_sol, flag, nb_iters, solution)
x0 = pi/2
x_sol, f_sol, flag, nb_iters = newton(f0, grad_f0, hess_f0, x0)
afficher_resultats("Newton", "f0", x0, x_sol, f_sol, flag, nb_iters, solution)
```
%% Output
-------------------------------------------------------------------------
Résultats de : Newton appliqué à f0:
* x0 = -1.5707963267948966
* x_sol = -1.5707963267948966
* f(x_sol) = -1.0
* nb_iters = 0
* flag = 0
* solution = -1.5707963267948966
-------------------------------------------------------------------------
Résultats de : Newton appliqué à f0:
* x0 = -1.0707963267948966
* x_sol = -1.5707963267949088
* f(x_sol) = -1.0
* nb_iters = 3
* flag = 0
* solution = -1.5707963267948966
-------------------------------------------------------------------------
Résultats de : Newton appliqué à f0:
* x0 = 1.5707963267948966
* x_sol = 1.5707963267948966
* f(x_sol) = 1.0
* nb_iters = 0
* flag = 0
* solution = -1.5707963267948966
%% Cell type:markdown id: tags:
## Interprétation
1. Justifier les résultats obtenus pour l'exemple $f_0$ ci-dessus;
2. Justifier que l’algorithme implémenté converge en une itération pour $f_{1}$;
3. 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.
%% Cell type:code id: tags:
``` julia
```
%% 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 dans le fichier `src/cauchy.jl`). La spécification de cet algorithme est donnée dans le fichier.
2. Ecrire des tests exhaustifs (qui testent tous les cas de figure possibles) pour votre algorithme du pas de Cauchy. Vous remplirez pour cela le fichier `test/tester_cauchy.jl` 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
include("../src/cauchy.jl") # votre algorithme
include("../test/tester_cauchy.jl") # la fonction pour tester votre algorithme
#
tester_cauchy(cauchy); # tester l'algorithme
```
%% Cell type:markdown id: tags:
3. Coder l'algorithme des régions de confiance (fichier `src/regions_de_confiance.jl`). Sa spécification est donnée dans le fichier.
4. Vérifier que les tests ci-dessous passent.
%% Cell type:code id: tags:
``` julia
include("../src/regions_de_confiance.jl")
include("../test/tester_rc_cauchy.jl")
#
afficher = false # si true, alors affiche les résultats des algorithmes
#
tester_rc_cauchy(regions_de_confiance, afficher);
```
%% Cell type:markdown id: tags:
## Interprétation
<!-- Pour ces questions, des représentations graphiques sont attendues pour corroborer vos réponses. -->
1. Soit la fonction $f_1 \colon \mathbb{R}^3 \to \mathbb{R}$ définie par
$$
f_1(x_1,x_2, x_3) = 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 l'algorithme de Newton et celui des régions de confiance avec le 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:code id: tags:
``` julia
# Expérimentations numériques à faire ici
# Vous pouvez utiliser le package Plots pour les affichages de courbes: using Plots
```
%% Cell type:markdown id: tags:
# Régions de confiance avec gradient conjugué tronqué
## Implémentation
1. Implémenter l’algorithme du gradient conjugué tronqué (fichier `src/gct.jl`). Sa spécification est dans le fichier.
2. Vérifier que les tests ci-dessous passent.
%% Cell type:code id: tags:
``` julia
include("../src/gct.jl")
include("../test/tester_gct.jl")
#
tester_gct(gct);
```
%% Cell type:markdown id: tags:
3. Intégrer l’algorithme du gradient conjugué tronqué dans le code des régions de confiance.
4. Vérifier que les tests ci-dessous passent.
%% Cell type:code id: tags:
``` julia
include("../src/regions_de_confiance.jl")
include("../test/tester_rc_gct.jl")
#
afficher = false # si true, alors affiche les résultats des algorithmes
#
tester_rc_gct(regions_de_confiance, afficher);
```
%% Cell type:markdown id: tags:
## Interprétation
Nous proposons de comparer l'utilisation du pas de Cauchy avec celle du gradient conjugué tronqué dans l'algorithme des régions de confiance.
**Remarques.**
* Nous vous demandons de réaliser des expérimentations numériques pour les comparaisons demandées ci-après.
* Vous devez utiliser l'argument optionnel `max_iter_gct` et la sortie `xs` de l'algorithme des régions de confiance.
* Vous pouvez comparer l'écart en norme entre les itérés de l'algorithme et la solution du problème.
* Vous trouverez des choses utiles dans le fichier `test/fonctions_de_tests.jl`.
1. Comparer dans le cas où l'on force le gradient conjugué tronqué à ne faire qu'une seule itération. Que remarquez vous ?
2. Comparer dans le cas général. Que remarquez vous ?
3. Quels sont les avantages et inconvénients des deux approches ?
%% Cell type:code id: tags:
``` julia
# Expérimentations numériques à faire ici.
# Vous pouvez utiliser le package Plots pour les affichages de courbes: using Plots
```
using LinearAlgebra
"""
Approximation de la solution du problème
min qₖ(s) = s'gₖ + 1/2 s' Hₖ s
sous les contraintes s = -t gₖ, t > 0, ‖s‖ ≤ Δₖ
# Syntaxe
s = cauchy(g, H, Δ; kwargs...)
# Entrées
- g : (Vector{<:Real}) le vecteur gₖ
- H : (Matrix{<:Real}) la matrice Hₖ
- Δ : (Real) le scalaire Δₖ
- kwargs : les options sous formes d'arguments "keywords", c'est-à-dire des arguments nommés
• tol_abs : la tolérence absolue (optionnel, par défaut 1e-10)
# Sorties
- s : (Vector{<:Real}) la solution du problème
# Exemple d'appel
g = [0; 0]
H = [7 0 ; 0 2]
Δ = 1
s = cauchy(g, H, Δ)
"""
function cauchy(g::Vector{<:Real}, H::Matrix{<:Real}, Δ::Real; tol_abs::Real = 1e-10)
s = zeros(length(g))
return s
end
using LinearAlgebra
"""
Approximation de la solution du problème
min qₖ(s) = s'gₖ + 1/2 s' Hₖ s, sous la contrainte ‖s‖ ≤ Δₖ
# Syntaxe
s = gct(g, H, Δ; kwargs...)
# Entrées
- g : (Vector{<:Real}) le vecteur gₖ
- H : (Matrix{<:Real}) la matrice Hₖ
- Δ : (Real) le scalaire Δₖ
- kwargs : les options sous formes d'arguments "keywords", c'est-à-dire des arguments nommés
• max_iter : le nombre maximal d'iterations (optionnel, par défaut 100)
• tol_abs : la tolérence absolue (optionnel, par défaut 1e-10)
• tol_rel : la tolérence relative (optionnel, par défaut 1e-8)
# Sorties
- s : (Vector{<:Real}) une approximation de la solution du problème
# Exemple d'appel
g = [0; 0]
H = [7 0 ; 0 2]
Δ = 1
s = gct(g, H, Δ)
"""
function gct(g::Vector{<:Real}, H::Matrix{<:Real}, Δ::Real;
max_iter::Integer = 100,
tol_abs::Real = 1e-10,
tol_rel::Real = 1e-8)
s = zeros(length(g))
return s
end
using LinearAlgebra
"""
Approximation d'une solution du problème min f(x), x ∈ Rⁿ, en utilisant l'algorithme de Newton.
# Syntaxe
x_sol, f_sol, flag, nb_iters, xs = newton(f, gradf, hessf, x0; kwargs...)
# Entrées
- f : (Function) la fonction à minimiser
- gradf : (Function) le gradient de la fonction f
- hessf : (Function) la Hessienne de la fonction f
- x0 : (Union{Real,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)
• epsilon : (Real) le epsilon pour les tests de stagnation (optionnel, par défaut 1)
# Sorties
- x_sol : (Union{Real,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
# 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]
x_sol, f_sol, flag, nb_iters, xs = newton(f, gradf, hessf, x0)
"""
function newton(f::Function, gradf::Function, hessf::Function, x0::Union{Real,Vector{<:Real}};
max_iter::Integer = 1000,
tol_abs::Real = 1e-10,
tol_rel::Real = 1e-8,
epsilon::Real = 1)
#
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 x_sol, f_sol, flag, nb_iters, xs
end
\ No newline at end of file
# Ecrire les tests de l'algorithme du pas de Cauchy
using Test
function tester_cauchy(cauchy::Function)
@testset "Pas de Cauchy" begin
@test 1==1
end
end
\ No newline at end of file
using Test
include("../test/fonctions_de_tests.jl")
"""
Tester l'algorithme de Newton
# 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_newton(newton::Function, afficher::Bool)
println("Affichage des résultats des algorithmes : ", afficher, "\n")
# tolérance pour les tests
tol_erreur = sqrt(eps())
# options pour Newton
max_iter = 100
tol_abs = sqrt(eps())
tol_rel = 1e-15
epsilon = 1.0
#
@testset "algorithme de Newton" begin
@testset "test f1 : x0 = solution" begin
x_sol, f_sol, flag, nb_iters, _ = newton(fct1, grad_fct1, hess_fct1, sol_exacte_fct1,
max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
if (afficher)
afficher_resultats("newton", "f1", sol_exacte_fct1, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
end
@testset "solution" begin
@test x_sol 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 "test f1 : x0 = x011" begin
x_sol, f_sol, flag, nb_iters, _ = newton(fct1, grad_fct1, hess_fct1, pts1.x011,
max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
if (afficher)
afficher_resultats("newton", "f1", pts1.x011, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
end
@testset "solution" begin
@test x_sol 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 "test f1 : x0 = x012" begin
x_sol, f_sol, flag, nb_iters, _ = newton(fct1, grad_fct1, hess_fct1, pts1.x012,
max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
if (afficher)
afficher_resultats("newton", "f1", pts1.x012, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
end
@testset "solution" begin
@test x_sol 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 "test f2 : x0 = x021" begin
x_sol, f_sol, flag, nb_iters, _ = newton(fct2, grad_fct2, hess_fct2, pts1.x021,
max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
if (afficher)
afficher_resultats("newton", "f2", pts1.x021, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
end
@testset "solution" begin
@test x_sol 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 "test f2 : x0 = x022" begin
x_sol, f_sol, flag, nb_iters, _ = newton(fct2, grad_fct2, hess_fct2, pts1.x022,
max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
if (afficher)
afficher_resultats("newton", "f2", pts1.x022, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
end
@testset "solution" begin
@test x_sol 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 "test f2 : x0 = x023" begin
x_sol, f_sol, flag, nb_iters, _ = newton(fct2, grad_fct2, hess_fct2, pts1.x023,
max_iter=1, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
if (afficher)
afficher_resultats("newton", "f2", pts1.x023, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
end
@testset "solution" begin
@test x_sol [-4.99999958629818e9, 8.673617379884035e-19] atol = tol_erreur
end
@testset "flag" begin
@test flag == 3
end
@testset "itération" begin
@test nb_iters == 1
end
@testset "exception" begin
@test_throws SingularException _, _, _, _ = newton(fct2, grad_fct2, hess_fct2, pts1.x023,
max_iter=max_iter, tol_abs=tol_abs, tol_rel=tol_rel, epsilon=epsilon)
end
end
end
end
using Test
include("../test/fonctions_de_tests.jl")
"""
Tester l'algorithme des régions de confiance avec le pas de Cauchy
# 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_rc_cauchy(rc::Function, afficher::Bool)
println("Affichage des résultats des algorithmes : ", afficher, "\n")
# La tolérance utilisée dans les tests
tol_erreur = 1e-2
#
algo_pas = "cauchy"
# l'ensemble de tests
@testset "RC et pas de Cauchy " begin
# cas de test 1
x_sol, f_sol, flag, nb_iters, _ = rc(fct1, grad_fct1, hess_fct1, pts1.x011, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f1", pts1.x011, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
end
@test x_sol sol_exacte_fct1 atol=tol_erreur
@test flag == 2
@test nb_iters == 33
# cas de test 2
x_sol, f_sol, flag, nb_iters = rc(fct1, grad_fct1, hess_fct1, pts1.x012, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f1", pts1.x012, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
end
@test x_sol sol_exacte_fct1 atol=tol_erreur
@test flag == 2
@test nb_iters == 34
# cas de test 3
x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x021, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f2", pts1.x021, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
end
@test x_sol sol_exacte_fct2 atol=tol_erreur
@test flag == 3
@test nb_iters == 5000
# cas de test 4
x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x022, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f2", pts1.x022, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
end
@test x_sol sol_exacte_fct2 atol=tol_erreur
@test flag == 0
@test nb_iters == 864
# cas de test 5
x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x023, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f2", pts1.x023, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
end
@test x_sol sol_exacte_fct2 atol=tol_erreur
@test flag == 2
@test nb_iters == 4512
end
end
using Test
include("../test/fonctions_de_tests.jl")
"""
Tester l'algorithme des régions de confiance avec le gradient conjugué tronqué
# 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_rc_gct(rc::Function, afficher::Bool)
println("Affichage des résultats des algorithmes : ", afficher, "\n")
# La tolérance utilisée dans les tests
tol_erreur = 1e-2
#
algo_pas = "gct"
# l'ensemble de tests
@testset "RC et gct" begin
# cas de test 1
x_sol, f_sol, flag, nb_iters, _ = rc(fct1, grad_fct1, hess_fct1, pts1.x011, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f1", pts1.x011, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
end
@test x_sol sol_exacte_fct1 atol=tol_erreur
@test flag == 0
@test nb_iters == 1
# cas de test 2
x_sol, f_sol, flag, nb_iters = rc(fct1, grad_fct1, hess_fct1, pts1.x012, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f1", pts1.x012, x_sol, f_sol, flag, nb_iters, sol_exacte_fct1)
end
@test x_sol sol_exacte_fct1 atol=tol_erreur
@test flag == 0
@test nb_iters == 3
# cas de test 3
x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x021, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f2", pts1.x021, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
end
@test x_sol sol_exacte_fct2 atol=tol_erreur
@test flag == 0
@test nb_iters == 31
# cas de test 4
x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x022, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f2", pts1.x022, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
end
@test x_sol sol_exacte_fct2 atol=tol_erreur
@test flag == 0
@test nb_iters == 44
# cas de test 5
x_sol, f_sol, flag, nb_iters, _ = rc(fct2, grad_fct2, hess_fct2, pts1.x023, algo_pas=algo_pas)
if (afficher)
afficher_resultats("RC et " * algo_pas, "f2", pts1.x023, x_sol, f_sol, flag, nb_iters, sol_exacte_fct2)
end
@test x_sol sol_exacte_fct2 atol=tol_erreur
@test flag == 0
@test nb_iters == 19
end
end
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment