fin de projet
This commit is contained in:
Laureηt
parent
99ce6be786
commit
484273f683
|
|
@ -5,20 +5,62 @@
|
|||
"metadata": {},
|
||||
"source": [
|
||||
"<center>\n",
|
||||
"<h1> TP-Projet d'optimisation numérique </h1>\n",
|
||||
"<h1> Année 2020-2021 - 2e année département Sciences du Numérique </h1>\n",
|
||||
"<h1> Nom: FAINSIN </h1>\n",
|
||||
"<h1> Prénom: Laurent </h1> \n",
|
||||
"<h1>\n",
|
||||
"TP-Projet d'optimisation numérique <br/>\n",
|
||||
"2ème année département Sciences du Numérique <br/>\n",
|
||||
"2021-2022 <br/>\n",
|
||||
"FAINSIN Laurent\n",
|
||||
"</h1>\n",
|
||||
"</center>"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"execution_count": 30,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"\u001b[32m\u001b[1m Status\u001b[22m\u001b[39m `~/.julia/environments/v1.7/Project.toml`\n",
|
||||
" \u001b[90m [0c46a032] \u001b[39mDifferentialEquations v6.20.0\n",
|
||||
" \u001b[90m [bd48cda9] \u001b[39mGraphRecipes v0.5.8\n",
|
||||
" \u001b[90m [86223c79] \u001b[39mGraphs v1.4.1\n",
|
||||
" \u001b[90m [91a5bcdd] \u001b[39mPlots v1.25.1\n",
|
||||
" \u001b[90m [a6016688] \u001b[39mTestOptinum v0.1.0 `https://github.com/mathn7/TestOptinum.git#master`\n",
|
||||
" \u001b[90m [37e2e46d] \u001b[39mLinearAlgebra\n",
|
||||
" \u001b[90m [d6f4376e] \u001b[39mMarkdown\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "stderr",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n",
|
||||
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Project.toml`\n",
|
||||
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Manifest.toml`\n",
|
||||
"\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
|
||||
"\u001b[32m ✓ \u001b[39mTestOptinum\n",
|
||||
" 1 dependency successfully precompiled in 2 seconds (262 already precompiled, 2 skipped during auto due to previous errors)\n",
|
||||
"\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n",
|
||||
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Project.toml`\n",
|
||||
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Manifest.toml`\n",
|
||||
"\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
|
||||
"\u001b[32m ✓ \u001b[39mTestOptinum\n",
|
||||
" 1 dependency successfully precompiled in 2 seconds (262 already precompiled, 2 skipped during auto due to previous errors)\n",
|
||||
"\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n",
|
||||
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Project.toml`\n",
|
||||
"\u001b[32m\u001b[1m No Changes\u001b[22m\u001b[39m to `~/.julia/environments/v1.7/Manifest.toml`\n",
|
||||
"\u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n",
|
||||
"\u001b[32m ✓ \u001b[39mTestOptinum\n",
|
||||
" 1 dependency successfully precompiled in 2 seconds (262 already precompiled, 2 skipped during auto due to previous errors)\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"include(\"../test/imports_boilerplate.jl\")"
|
||||
"include(\"../test/imports_boilerplate.jl\");\n",
|
||||
"afficher = true;"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -26,20 +68,121 @@
|
|||
"metadata": {},
|
||||
"source": [
|
||||
"# Algorithme de Newton\n",
|
||||
"## Implémentation \n",
|
||||
"\n",
|
||||
"### Implémentation \n",
|
||||
" \n",
|
||||
"1. Coder l’algorithme de Newton local tel que décrit dans la section *Algorithme de Newton* (fichier `Algorithme_De_Newton.jl`)\n",
|
||||
"\n",
|
||||
"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."
|
||||
"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",
|
||||
"execution_count": null,
|
||||
"execution_count": 31,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct0 au point initial sol_exacte :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = -1.5707963267948966\n",
|
||||
" * f(xsol) = -1.0\n",
|
||||
" * nb_iters = 0\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = -1.5707963267948966\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct0 au point initial x001 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = -1.5707963267949088\n",
|
||||
" * f(xsol) = -1.0\n",
|
||||
" * nb_iters = 3\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = -1.5707963267948966\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct0 au point initial x002 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = 1.5707963267948966\n",
|
||||
" * f(xsol) = 1.0\n",
|
||||
" * nb_iters = 0\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = -1.5707963267948966\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct1 au point initial sol_exacte :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1, 1, 1]\n",
|
||||
" * f(xsol) = 0\n",
|
||||
" * nb_iters = 0\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct1 au point initial x011 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1.0000000000000002, 1.0, 0.9999999999999998]\n",
|
||||
" * f(xsol) = 9.860761315262648e-32\n",
|
||||
" * nb_iters = 1\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct1 au point initial x012 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1.0, 0.9999999999999996, 0.9999999999999982]\n",
|
||||
" * f(xsol) = 1.1832913578315177e-29\n",
|
||||
" * nb_iters = 1\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct1 au point initial sol_exacte :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1, 1, 1]\n",
|
||||
" * f(xsol) = 0\n",
|
||||
" * nb_iters = 0\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct2 au point initial x021 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.9999999999999999, 0.9999999999814724]\n",
|
||||
" * f(xsol) = 3.4326461875363225e-20\n",
|
||||
" * nb_iters = 6\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct2 au point initial x022 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1.0, 1.0]\n",
|
||||
" * f(xsol) = 0.0\n",
|
||||
" * nb_iters = 5\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : algorithme de Newton appliqué à fct2 au point initial x022 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [-4.99999958629818e9, 8.673617379884035e-19]\n",
|
||||
" * f(xsol) = 6.249997931491155e40\n",
|
||||
" * nb_iters = 1\n",
|
||||
" * flag = 3\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : stagnation x de Newton appliqué à fct0 au point initial [0.9999, 0.9999, 0.9999] :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.999899999, 0.999899999, 0.999899999]\n",
|
||||
" * f(xsol) = 1.8000360001799175e-7\n",
|
||||
" * nb_iters = 1\n",
|
||||
" * flag = 1\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : stagnation f(x) de Newton appliqué à fct2 au point initial [100.0, 100.0] :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1.0000000000000073, 0.9999999975412127]\n",
|
||||
" * f(xsol) = 6.045706979316412e-16\n",
|
||||
" * nb_iters = 4\n",
|
||||
" * flag = 2\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : itermax de Newton appliqué à fct2 au point initial x021 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.7631148711762008, -3.1750338547475616]\n",
|
||||
" * f(xsol) = 1411.8451793091335\n",
|
||||
" * nb_iters = 2\n",
|
||||
" * flag = 3\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n",
|
||||
"L'algo de Newton | \u001b[32m 24 \u001b[39m\u001b[36m 24\u001b[39m\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"tester_algo_newton(false, Algorithme_De_Newton)"
|
||||
"# les fonctions de l'annexe A + f0 sont dans les tests\n",
|
||||
"tester_algo_newton(afficher, Algorithme_De_Newton);"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -48,140 +191,356 @@
|
|||
"source": [
|
||||
"## Interprétation \n",
|
||||
"\n",
|
||||
"Justifier\n",
|
||||
"### Justifier\n",
|
||||
"\n",
|
||||
"1. les résultats obtenus pour l'exemple $f_0$ ci-dessus;\n",
|
||||
"\n",
|
||||
"2. que l’algorithme implémenté converge en une itération pour $f_{1}$;\n",
|
||||
"3. que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux.\n",
|
||||
"\n",
|
||||
"3. que l’algorithme puisse ne pas converger pour $f_{2}$ avec certains points initiaux."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Vos réponses?\n",
|
||||
"### Vos réponses?\n",
|
||||
"La méthode de Newton repose sur la recherche des solutions de $\\nabla f(x) = 0$, cet algorithme recherche donc les extremums de $f$ et non uniquement ses minimas.\n",
|
||||
"\n",
|
||||
"1. \n",
|
||||
" 1. Dans le cas où $x_0 = x_{sol}$, les tests de convergence arretent l'algorithme (et rien ne se passe)\n",
|
||||
"\n",
|
||||
"1.\n",
|
||||
" 1. Dans le cas où $x_0 = x_{sol}$, les tests de convergence arretent l'algorithme (et rien ne se passe, on a déjà la solution)\n",
|
||||
" \n",
|
||||
" 2. Dans le cas où $x_0 = \\frac{1-\\pi}{2}$, l'algorithme trouve une racine de $cos(x)$ en seulement 2 itérations.\n",
|
||||
" \n",
|
||||
" 3. Dans le cas où $x_0 = \\frac\\pi2$, l'algorithme tombe immédiatement sur une racine de $cos(x)$, il s'arrête mais la solution est un maximum et non un minimum.\n",
|
||||
"\n",
|
||||
"2. \n",
|
||||
" 1. $x_0 = x_{sol}$, donc la convergence en une itération est cohérent.\n",
|
||||
" \n",
|
||||
" 2. $x_0 = [1, 0, 0]$, $\\nabla^2f(x_0) \\setminus \\nabla f (x_0) ~= [0, -1, -1]$. Ainsi après une itération, on retombe sur $[1, 1, 1]$, qui est un minimum de f1.\n",
|
||||
" \n",
|
||||
" 3. $x_0 = [10, 3, -2.2]$, on a le même scénario que précédemment : $\\nabla^2f(x_0) \\setminus \\nabla f (x_0) ~= [9, 2, -3.2]$.\n",
|
||||
"\n",
|
||||
"3. $f_2$ ne peut pas converger dans le cas où $x_0= [0, \\frac1{200} + 10^{-12}]$ puisque à partir d'une certaine itération, la hessienne possède des coefficients trop grand et devient numériquement non inversible."
|
||||
"3. $f_2$ ne peut pas converger dans le cas où $x_0= [0, \\frac1{200} + 10^{-12}]$ puisqu'à partir d'une certaine itération, la hessienne possède des coefficients trop grand et devient numériquement non inversible."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Régions de confiance avec pas de cauchy \n",
|
||||
"# Régions de confiance\n",
|
||||
"\n",
|
||||
"## Implémentation \n",
|
||||
"## Pas de Cauchy\n",
|
||||
"\n",
|
||||
"1. Coder l'algorithme du pas de Cauchy d’un sous-problème de\n",
|
||||
"régions de confiance (fichier `Pas_De_Cauchy.jl`). Tester sur les quadratiques proposées en Annexe B.\n",
|
||||
"### Implémentation\n",
|
||||
"\n",
|
||||
"2. Coder l'algorithme de régions de confiance (fichier `Regions_De_Confiance.jl`). Tester sur les problèmes de l’Annexe A."
|
||||
"Coder l'algorithme du pas de Cauchy d’un sous-problème de régions de confiance (fichier `Pas_De_Cauchy.jl`).\n",
|
||||
"Tester sur les quadratiques proposées en Annexe B."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"execution_count": 32,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : Cauchy 1 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [0, 0]\n",
|
||||
" * sol_exacte = [0, 0]\n",
|
||||
" * flag = 0\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : Cauchy 2 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-0.9230769230769234, -0.30769230769230776]\n",
|
||||
" * sol_exacte = [-0.9230769230769234, -0.30769230769230776]\n",
|
||||
" * flag = 1\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : Cauchy 3 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-0.8538149682454623, -0.2846049894151541]\n",
|
||||
" * sol_exacte = [-0.8538149682454623, -0.2846049894151541]\n",
|
||||
" * flag = -1\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : Cauchy 4 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [5.000000000000001, -2.5000000000000004]\n",
|
||||
" * sol_exacte = [5.000000000000001, -2.5000000000000004]\n",
|
||||
" * flag = 1\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : Cauchy 5 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [4.47213595499958, -2.23606797749979]\n",
|
||||
" * sol_exacte = [4.47213595499958, -2.23606797749979]\n",
|
||||
" * flag = -1\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : Cauchy 6 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-4.743416490252569, -1.5811388300841895]\n",
|
||||
" * sol_exacte = [-4.743416490252569, -1.5811388300841895]\n",
|
||||
" * flag = -1\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : Cauchy 7 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-2.23606797749979, -4.47213595499958]\n",
|
||||
" * sol_exacte = [-2.23606797749979, -4.47213595499958]\n",
|
||||
" * flag = -1\n",
|
||||
"\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n",
|
||||
"Pas de Cauchy | \u001b[32m 7 \u001b[39m\u001b[36m 7\u001b[39m\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"tester_pas_de_cauchy(false, Pas_De_Cauchy)"
|
||||
"# les quadratiques de l'annexe B sont dans les tests\n",
|
||||
"tester_pas_de_cauchy(afficher, Pas_De_Cauchy);"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Interprétation \n",
|
||||
"### Interprétation \n",
|
||||
"\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"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",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Vos réponses?\n",
|
||||
"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.\n",
|
||||
"\n",
|
||||
"### Vos réponses ?\n",
|
||||
"\n",
|
||||
"| Point | Newton | RC-Cauchy |\n",
|
||||
"| :-------- | :----: | :-------: |\n",
|
||||
"| $x_{sol}$ | 0 | 0 |\n",
|
||||
"| $x_{011}$ | 1 | 26 |\n",
|
||||
"| $x_{012}$ | 1 | 28 |\n",
|
||||
"\n",
|
||||
"1. Si on note $q_1$ le modèle de Taylor à l'ordre 2 de $f_1$, alors $m^1_k(x_k+s) = q_1(s) = f_1(x_k) + g_1^T s + \\frac12 s^T H_k s$.\n",
|
||||
"On observe que RC-Cauchy est plus lent que la méthode de Newton sur la fonction $f1$.\n",
|
||||
"\n",
|
||||
"2. Pour essayer d'améliorer les performances de l'algorithme des régions de confiance avec Cauchy, on peut aussi essayer d'agrandir $\\Delta_{max}$ pour que l'algorithme converge plus rapidement, dans le cas où on observe un grand nombre d'itérations lors de la résolution."
|
||||
"2. Pour essayer d'améliorer les performances de l'algorithme des régions de confiance avec Cauchy, on peut aussi essayer d'agrandir $\\Delta_{max}$ pour que l'algorithme converge plus rapidement dans les cas où on observe un grand nombre d'itérations lors de la résolution."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Régions de confiance avec gradient conjugué tronqué\n",
|
||||
"## Gradient conjugué tronqué\n",
|
||||
"\n",
|
||||
"## Implémentation \n",
|
||||
"### Implémentation \n",
|
||||
"\n",
|
||||
"1. Implémenter l’algorithme du Gradient Conjugué Tronqué, en se basant sur le cours (fichier `Gradient_Conjugue_Tronque.jl`).\n",
|
||||
"On validera les résultats sur les fonctions de l’Annexe C.\n",
|
||||
"\n",
|
||||
"2. Intégrer finalement l’algorithme du Gradient Conjugué Tronqué dans le code de\n",
|
||||
"régions de confiance, et appliquer ce code pour résoudre les exemples proposés en\n",
|
||||
"Annexe A."
|
||||
"Implémenter l’algorithme du Gradient Conjugué Tronqué, en se basant sur le cours (fichier `Gradient_Conjugue_Tronque.jl`).\n",
|
||||
"On validera les résultats sur les fonctions de l’Annexe C."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"execution_count": 33,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 1 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [0.0, 0.0]\n",
|
||||
" * sol_exacte = [0.0, 0.0]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 2 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-0.4743416490252569, -0.15811388300841897]\n",
|
||||
" * sol_exacte = [-0.4743416490252569, -0.15811388300841897]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 3 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-0.8740776099190263, -0.8221850958502243]\n",
|
||||
" * sol_exacte = [-0.8740776099190263, -0.8221850958502244]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 4 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-0.8571428571428571, -0.9999999999999998]\n",
|
||||
" * sol_exacte = [-0.8571428571428571, -1.0]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 5 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-0.447213595499958, -0.894427190999916]\n",
|
||||
" * sol_exacte = [-0.4472135954999579, -0.8944271909999159]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 6 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-0.5, 0.0]\n",
|
||||
" * sol_exacte = [-0.5, -0.0]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 7 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [9.102342582478453, -4.140937032991381]\n",
|
||||
" * sol_exacte = [9.102342582478453, -4.140937032991381]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 8 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [0.0, 0.0]\n",
|
||||
" * sol_exacte = [0.0, 0.0]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 9 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [1.9059020876695598, -2.3167946029410578]\n",
|
||||
" * sol_exacte = [1.9059020876695578, -2.3167946029410595]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : GCT 10 :\u001b[22m\u001b[39m\n",
|
||||
" * sol = [-0.5, 0.0]\n",
|
||||
" * sol_exacte = [-0.5, 0.0]\n",
|
||||
"\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n",
|
||||
"Gradient-CT | \u001b[32m 11 \u001b[39m\u001b[36m 11\u001b[39m\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"tester_gct(false, Gradient_Conjugue_Tronque)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"tester_regions_de_confiance(true, Regions_De_Confiance)"
|
||||
"# les quadratiques de l'annexe C sont dans les tests\n",
|
||||
"tester_gct(afficher, Gradient_Conjugue_Tronque);"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## Interprétation \n",
|
||||
"### Interprétation \n",
|
||||
"\n",
|
||||
"1. Comparer la décroissance obtenue avec celle du pas de Cauchy, en retournant, dans\n",
|
||||
"un premier temps le dernier itéré admissible à courbure positive (c’est à dire, que si\n",
|
||||
"l’une ou l’autre des deux conditions (b) ou (d) sont rencontrées dans l’algorithme 3,\n",
|
||||
"alors on ne calcule pas ``σ_{j}`` et on retourne le dernier itéré ``s_{j}`` directement).\n",
|
||||
"1. Comparer la décroissance obtenue avec celle du pas de Cauchy, en retournant, dans un premier temps le dernier itéré admissible à courbure positive (c’est à dire, que si l’une ou l’autre des deux conditions (b) ou (d) sont rencontrées dans l’algorithme 3, alors on ne calcule pas ``σ_{j}`` et on retourne le dernier itéré ``s_{j}`` directement).\n",
|
||||
"\n",
|
||||
"2. Comparer la décroissance obtenue avec celle du pas de Cauchy, en imposant la sortie\n",
|
||||
"dans l’algorithme 3 au bout d’une itération seulement. Que remarquez vous ?\n",
|
||||
"2. 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 ?\n",
|
||||
"\n",
|
||||
"3. Comparer la décroissance obtenue avec celle du pas de Cauchy dans le cas général.\n",
|
||||
"\n",
|
||||
"4. Quels sont les avantages et inconvénients des deux approches ?"
|
||||
"4. Quels sont les avantages et inconvénients des deux approches ?\n",
|
||||
"\n",
|
||||
"### Vos réponses ?\n",
|
||||
"\n",
|
||||
"1. \n",
|
||||
"\n",
|
||||
"| Solution | RC-Cauchy | RC-GCT |\n",
|
||||
"| :-------: | :-----------------: | :-----------------: |\n",
|
||||
"| [1, 1, 1] | [1, 1, 1] | [1, 1, 1] |\n",
|
||||
"| [1, 1, 1] | [1.51, 0.85, 0.68] | [1.0, 1.0, 1.0] |\n",
|
||||
"| [1, 1, 1] | [8.41, 2.02, -2.93] | [4.66, 0.62, -3.12] |\n",
|
||||
"| [1, 1] | [-1.05, 1.05] | [-1.17, 1.38] |\n",
|
||||
"| [1, 1] | [8.00, 0.09] | [5.46, 3.19] |\n",
|
||||
"| [1, 1] | [0.04, -0.01] | [0.0, 0.005] |\n",
|
||||
"\n",
|
||||
"2. Si on limite à une itération, on observe que l'algorithme des régions de confiance avec GCT converge plus rapidement.\n",
|
||||
"\n",
|
||||
"Test | RC-Cauchy | RC-GCT |\n",
|
||||
"| :----- | :-------: | :----: |\n",
|
||||
"| test 1 | 0 | 0 |\n",
|
||||
"| test 2 | 26 | 1 |\n",
|
||||
"| test 3 | 28 | 3 |\n",
|
||||
"| test 4 | 3988 | 31 |\n",
|
||||
"| test 5 | 864 | 44 |\n",
|
||||
"| test 6 | 3198 | 19 |\n",
|
||||
"3. Dans le cas général on remarque que RC-GCT est nettement plus efficace que RC-Cauchy. \n",
|
||||
"\n",
|
||||
"4. Cauchy est plus simple mais moins efficace, et GCT est plus efficace mais nécéssite plus de calculs par itération."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"1. dqzd\n",
|
||||
"2. dzqd\n",
|
||||
"3. 3dqzdzd\n",
|
||||
"4. dqzd"
|
||||
"## Implémentation\n",
|
||||
"\n",
|
||||
"1. Coder l'algorithme de régions de confiance (fichier `Regions_De_Confiance.jl`). Tester sur les problèmes de l’Annexe A.\n",
|
||||
"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",
|
||||
"execution_count": 34,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 1 au point initial sol_exacte :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1, 1, 1]\n",
|
||||
" * f(xsol) = 0\n",
|
||||
" * nb_iters = 0\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 1 au point initial x011 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1.0000558873349883, 0.999992420017735, 0.9999289527004819]\n",
|
||||
" * f(xsol) = 9.090411079109608e-9\n",
|
||||
" * nb_iters = 26\n",
|
||||
" * flag = 2\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 1 au point initial x012 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1.000049795462743, 0.9999961002424803, 0.9999424049876057]\n",
|
||||
" * f(xsol) = 6.0401046516733e-9\n",
|
||||
" * nb_iters = 28\n",
|
||||
" * flag = 2\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 2 au point initial x021 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.9975992881487654, 0.9951970760634036]\n",
|
||||
" * f(xsol) = 5.768693455998473e-6\n",
|
||||
" * nb_iters = 3988\n",
|
||||
" * flag = 2\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 2 au point initial x022 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.9961677295964368, 0.9923393628804894]\n",
|
||||
" * f(xsol) = 1.4697922911344958e-5\n",
|
||||
" * nb_iters = 864\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance (itermax) avec cauchy appliqué à fonction 2 au point initial x022 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.9906938429133161, 0.981448447768753]\n",
|
||||
" * f(xsol) = 8.667134381048603e-5\n",
|
||||
" * nb_iters = 10\n",
|
||||
" * flag = 3\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec cauchy appliqué à fonction 2 au point initial x023 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.998024983312937, 0.9960352320641266]\n",
|
||||
" * f(xsol) = 3.935418178353333e-6\n",
|
||||
" * nb_iters = 3198\n",
|
||||
" * flag = 2\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à sol_exacte au point initial x011 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1, 1, 1]\n",
|
||||
" * f(xsol) = 0\n",
|
||||
" * nb_iters = 0\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 1 au point initial x011 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1.0000000000000007, 1.0, 1.0]\n",
|
||||
" * f(xsol) = 2.0214560696288428e-30\n",
|
||||
" * nb_iters = 1\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 1 au point initial x012 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.9999999999999996, 1.0000000000000002, 1.0000000000000004]\n",
|
||||
" * f(xsol) = 4.930380657631324e-31\n",
|
||||
" * nb_iters = 3\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 2 au point initial x021 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.9999996743780089, 0.9999993478371609]\n",
|
||||
" * f(xsol) = 1.0611413038132374e-13\n",
|
||||
" * nb_iters = 31\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 2 au point initial x022 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [1.0000035183009863, 1.0000066949336202]\n",
|
||||
" * f(xsol) = 2.4053014026923312e-11\n",
|
||||
" * nb_iters = 44\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"--------------------------------------------------------------------------------\n",
|
||||
"\u001b[34m\u001b[1mRésultats de : régions de confiance avec gct appliqué à fonction 2 au point initial x023 :\u001b[22m\u001b[39m\n",
|
||||
" * xsol = [0.9999999999998994, 0.9999999999996207]\n",
|
||||
" * f(xsol) = 3.1813581453548166e-24\n",
|
||||
" * nb_iters = 19\n",
|
||||
" * flag = 0\n",
|
||||
" * sol_exacte = [1, 1]\n",
|
||||
"\u001b[0m\u001b[1mTest Summary: | \u001b[22m\u001b[32m\u001b[1mPass \u001b[22m\u001b[39m\u001b[36m\u001b[1mTotal\u001b[22m\u001b[39m\n",
|
||||
"La méthode des RC | \u001b[32m 13 \u001b[39m\u001b[36m 13\u001b[39m\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# les fonctions de l'annexe A sont dans les tests\n",
|
||||
"tester_regions_de_confiance(afficher, Regions_De_Confiance);"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -190,91 +549,21 @@
|
|||
"source": [
|
||||
"# Lagrangien augmenté\n",
|
||||
"\n",
|
||||
"## Implémentation\n",
|
||||
"1.Choisir des critères d’arrêt pour la convergence de l'algorithme.\n",
|
||||
"### Implémentation\n",
|
||||
"\n",
|
||||
"2.Implémenter l'algorithme du lagrangien augmenté, en utilisant les différentes méthodes\n",
|
||||
"qui ont été vues en première partie pour la résolution de la suite de problémes sans\n",
|
||||
"contraintes (fichier `Lagrangien_Augmente.jl`)\n",
|
||||
" \n",
|
||||
"3.Tester les différentes variantes sur les problèmes en Annexe D.\n",
|
||||
" "
|
||||
"1. Choisir des critères d’arrêt pour la convergence de l'algorithme.\n",
|
||||
"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`)\n",
|
||||
"3. Tester les différentes variantes sur les problèmes en Annexe D."
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"execution_count": 36,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"function afficher_resultats(algo,nom_fct,point_init,xmin,fxmin,flag,sol_exacte,nbiters)\n",
|
||||
"\tprintln(\"-------------------------------------------------------------------------\")\n",
|
||||
"\tprintstyled(\"Résultats de : \"*algo*\" appliqué à \"*nom_fct*\" au point initial \"*point_init*\" :\\n\",bold=true,color=:blue)\n",
|
||||
"\tprintln(\" * xsol = \",xmin)\n",
|
||||
"\tprintln(\" * f(xsol) = \",fxmin)\n",
|
||||
"\tprintln(\" * nb_iters = \",nbiters)\n",
|
||||
"\tprintln(\" * flag = \",flag)\n",
|
||||
"\tprintln(\" * sol_exacte : \", sol_exacte)\n",
|
||||
"end\n",
|
||||
"\n",
|
||||
"fct1(x) = 2 * (x[1] + x[2] + x[3] - 3)^2 + (x[1] - x[2])^2 + (x[2] - x[3])^2\n",
|
||||
"# la gradient de la fonction fct1\n",
|
||||
"function grad_fct1(x)\n",
|
||||
" y1 = 4 * (x[1] + x[2] + x[3] - 3) + 2 * (x[1] - x[2])\n",
|
||||
" y2 = 4 * (x[1] + x[2] + x[3] - 3) - 2 * (x[1] - x[2]) + 2 * (x[2] - x[3])\n",
|
||||
" y3 = 4 * (x[1] + x[2] + x[3] - 3) - 2 * (x[2] - x[3])\n",
|
||||
" return [y1; y2; y3]\n",
|
||||
"end\n",
|
||||
"# la hessienne de la fonction fct1\n",
|
||||
"hess_fct1(x) = [6 2 4; 2 8 2; 4 2 6]\n",
|
||||
"\n",
|
||||
"contrainte1(x) = x[1] + x[3] - 1\n",
|
||||
"grad_contrainte1(x) = [1; 0; 1]\n",
|
||||
"hess_contrainte1(x) = [0 0 0; 0 0 0; 0 0 0]\n",
|
||||
"\n",
|
||||
"x01 = [0; 1; 1]\n",
|
||||
"x02 = [0.5; 1.25; 1]\n",
|
||||
"x03 = [1; 0]\n",
|
||||
"x04 = [sqrt(3) / 2; sqrt(3) / 2]\n",
|
||||
"pts2 = Pts_avec_contraintes(x01, x02, x03, x04)\n",
|
||||
"\n",
|
||||
"# sol_fct1_augm = [0.5 ; 1.25 ; 0.5]\n",
|
||||
"\n",
|
||||
"algo = \"newton\"\n",
|
||||
"xmin, fxmin, flag, nbiters = Lagrangien_Augmente(algo, fct1, contrainte1, grad_fct1, hess_fct1, grad_contrainte1, hess_contrainte1, pts2.x01, options)\n",
|
||||
"afficher_resultats(\"Lagrangien augmenté avec \" * algo, \"fonction 1\", \"x01\", xmin, fxmin, flag, sol_fct1_augm, nbiters)\n",
|
||||
"\n",
|
||||
"algo = \"cauchy\"\n",
|
||||
"xmin, fxmin, flag, nbiters = Lagrangien_Augmente(algo, fct1, contrainte1, grad_fct1, hess_fct1, grad_contrainte1, hess_contrainte1, pts2.x01, options)\n",
|
||||
"afficher_resultats(\"Lagrangien augmenté avec \" * algo, \"fonction 1\", \"x01\", xmin, fxmin, flag, sol_fct1_augm, nbiters)\n",
|
||||
"\n",
|
||||
"algo = \"gct\"\n",
|
||||
"xmin, fxmin, flag, nbiters = Lagrangien_Augmente(algo, fct1, contrainte1, grad_fct1, hess_fct1, grad_contrainte1, hess_contrainte1, pts2.x01, options)\n",
|
||||
"afficher_resultats(\"Lagrangien augmenté avec \" * algo, \"fonction 1\", \"x01\", xmin, fxmin, flag, sol_fct1_augm, nbiters)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"tester_lagrangien_augmente(true, Lagrangien_Augmente)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"for algo in [\"newton\" \"cauchy\" \"gct\"]\n",
|
||||
" for tau in [0.01; 0.1; 1; 10; 100; 1000]\n",
|
||||
" options = [1e-8 1e-5 1 10 10 tau]\n",
|
||||
" xmin, fxmin, flag, nbiters = Lagrangien_Augmente(algo, fct1, contrainte1, grad_fct1, hess_fct1, grad_contrainte1, hess_contrainte1, zeros(3), options)\n",
|
||||
" println(\"algo=\" * algo * \", tau=\" * string(tau) * \" \\t--> iter=\" * string(nbiters) * \" fxmin=\" * string(fxmin) * \" flag=\" * string(flag))\n",
|
||||
" end\n",
|
||||
"end"
|
||||
"# les fonctions de l'annexe D sont dans les tests\n",
|
||||
"tester_lagrangien_augmente(afficher, Lagrangien_Augmente);"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -290,8 +579,7 @@
|
|||
"source": [
|
||||
"1. Commenter les résultats obtenus, en étudiant notamment les valeurs de $\\lambda_k$ et $\\mu_k$.\n",
|
||||
"2. Étudier l'influence du paramètre $\\tau$ dans la performance de l'algorithme.\n",
|
||||
"3. **Supplémentaire** : \n",
|
||||
"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"
|
||||
"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"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -319,8 +607,8 @@
|
|||
"1. On observe que lorsque:\n",
|
||||
" - l'algorithme converge (flag = 0), alors $\\lambda_k$ tend vers $2 \\times f(x_{min})$.\n",
|
||||
" - l'algorithme ne converge pas (flag = 1), alors $\\mu_k$ tend vers 0. \n",
|
||||
"\n",
|
||||
"2. Il semblerait que plus $\\tau$ est élevé, plus l'algorithme converge rapidement"
|
||||
"2. Il semblerait que plus $\\tau$ est élevé, plus l'algorithme converge rapidement.\n",
|
||||
"3. "
|
||||
]
|
||||
}
|
||||
],
|
||||
|
|
|
|||
|
|
@ -123,11 +123,23 @@ 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("---------------------------------------------------------------------------------")
|
||||
println("-"^80)
|
||||
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)
|
||||
println(" * xsol = ", xmin)
|
||||
println(" * f(xsol) = ", fxmin)
|
||||
println(" * nb_iters = ", nbiters)
|
||||
println(" * flag = ", flag)
|
||||
println(" * sol_exacte = ", sol_exacte)
|
||||
end
|
||||
|
||||
function afficher_resultats_gct(algo, sol, sol_exacte)
|
||||
println("-"^80)
|
||||
printstyled("Résultats de : " * algo, " :\n", bold = true, color = :blue)
|
||||
println(" * sol = ", sol)
|
||||
println(" * sol_exacte = ", sol_exacte)
|
||||
end
|
||||
|
||||
function afficher_resultats_cauchy(algo, flag, sol, sol_exacte)
|
||||
afficher_resultats_gct(algo, sol, sol_exacte)
|
||||
println(" * flag = ", flag)
|
||||
end
|
||||
|
|
@ -25,55 +25,92 @@ function tester_gct(afficher::Bool, Gradient_Conjugue_Tronque::Function)
|
|||
Hess = [7 0; 0 2]
|
||||
delta = 1
|
||||
s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol])
|
||||
@test isapprox(s, [0.0; 0.0], atol = tol_test)
|
||||
sol = [0.0; 0.0]
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 1", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, 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 isapprox(s, -delta * grad / norm(grad), atol = tol_test)
|
||||
sol = -delta * grad / norm(grad)
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 2", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, atol = tol_test)
|
||||
delta = 1.2 # saturation à la 2ieme itération
|
||||
s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol])
|
||||
@test isapprox(s, [-0.8740776099190263, -0.8221850958502244], atol = tol_test)
|
||||
sol = [-0.8740776099190263, -0.8221850958502244]
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 3", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, atol = tol_test)
|
||||
delta = 3 # sol = min global
|
||||
s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol])
|
||||
@test isapprox(s, -Hess \ grad, atol = tol_test)
|
||||
sol = -Hess \ grad
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 4", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, 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.0 # g^T H g < 0 première direction concave
|
||||
s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol])
|
||||
@test isapprox(s, -delta * grad / norm(grad), atol = tol_test)
|
||||
sol = -delta * grad / norm(grad)
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 5", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, 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 isapprox(s, -delta * grad / norm(grad), atol = tol_test)
|
||||
sol = -delta * grad / norm(grad)
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 6", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, 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])
|
||||
@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 isapprox(s, [9.102342582478453; -4.140937032991381], atol = tol_test)
|
||||
sol = [9.102342582478453; -4.140937032991381]
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 7", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, 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 isapprox(s, [0.0; 0.0], atol = tol_test)
|
||||
sol = [0.0; 0.0]
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 8", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, 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])
|
||||
@test isapprox(s, [1.9059020876695578; -2.3167946029410595], atol = tol_test)
|
||||
sol = [1.9059020876695578; -2.3167946029410595]
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 9", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, atol = tol_test)
|
||||
|
||||
# le cas de test 6
|
||||
# Le pas de Cauchy conduit à un gradient nul en 1 itération
|
||||
|
|
@ -81,6 +118,10 @@ function tester_gct(afficher::Bool, Gradient_Conjugue_Tronque::Function)
|
|||
Hess = [4 0; 0 -15]
|
||||
delta = 2
|
||||
s = Gradient_Conjugue_Tronque(grad, Hess, [delta; max_iter; tol])
|
||||
@test isapprox(s, [-0.5; 0.0], atol = tol_test)
|
||||
sol = [-0.5; 0.0]
|
||||
if afficher
|
||||
afficher_resultats_gct("GCT 10", s, sol)
|
||||
end
|
||||
@test isapprox(s, sol, atol = tol_test)
|
||||
end
|
||||
end
|
||||
|
|
|
|||
|
|
@ -23,9 +23,9 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function)
|
|||
s, e = Pas_De_Cauchy(g, H, delta)
|
||||
sol = [0; 0]
|
||||
if afficher
|
||||
println("Cauchy 1= ", sol)
|
||||
afficher_resultats_cauchy("Cauchy 1", e, s, sol)
|
||||
end
|
||||
@test (e == 0) && (isapprox(s, [0; 0], atol = tol_erreur))
|
||||
@test (e == 0) && (isapprox(s, sol, atol = tol_erreur))
|
||||
end
|
||||
|
||||
@testset "quad 2, non saturé" begin
|
||||
|
|
@ -35,7 +35,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function)
|
|||
s, e = Pas_De_Cauchy(g, H, delta)
|
||||
sol = -(norm(g)^2 / (g' * H * g)) * g
|
||||
if afficher
|
||||
println("Cauchy 2= ", sol)
|
||||
afficher_resultats_cauchy("Cauchy 2", e, s, sol)
|
||||
end
|
||||
@test (e == 1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776]
|
||||
end
|
||||
|
|
@ -46,7 +46,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function)
|
|||
s, e = Pas_De_Cauchy(g, H, delta)
|
||||
sol = -(delta / norm(g)) * g
|
||||
if afficher
|
||||
println("Cauchy 3= ", sol)
|
||||
afficher_resultats_cauchy("Cauchy 3", e, s, sol)
|
||||
end
|
||||
@test (e == -1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776]
|
||||
end
|
||||
|
|
@ -57,7 +57,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function)
|
|||
s, e = Pas_De_Cauchy(g, H, delta)
|
||||
sol = -(norm(g)^2 / (g' * H * g)) * g
|
||||
if afficher
|
||||
println("Cauchy 4= ", sol)
|
||||
afficher_resultats_cauchy("Cauchy 4", e, s, sol)
|
||||
end
|
||||
@test (e == 1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776]
|
||||
end
|
||||
|
|
@ -68,7 +68,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function)
|
|||
s, e = Pas_De_Cauchy(g, H, delta)
|
||||
sol = -(delta / norm(g)) * g
|
||||
if afficher
|
||||
println("Cauchy 5= ", sol)
|
||||
afficher_resultats_cauchy("Cauchy 5", e, s, sol)
|
||||
end
|
||||
@test (e == -1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776]
|
||||
end
|
||||
|
|
@ -79,7 +79,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function)
|
|||
s, e = Pas_De_Cauchy(g, H, delta)
|
||||
sol = -(delta / norm(g)) * g
|
||||
if afficher
|
||||
println("Cauchy 6= ", sol)
|
||||
afficher_resultats_cauchy("Cauchy 6", e, s, sol)
|
||||
end
|
||||
@test (e == -1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776]
|
||||
end
|
||||
|
|
@ -90,7 +90,7 @@ function tester_pas_de_cauchy(afficher::Bool, Pas_De_Cauchy::Function)
|
|||
s, e = Pas_De_Cauchy(g, H, delta)
|
||||
sol = -(delta / norm(g)) * g
|
||||
if afficher
|
||||
println("Cauchy 7= ", sol)
|
||||
afficher_resultats_cauchy("Cauchy 7", e, s, sol)
|
||||
end
|
||||
@test (e == -1) && (isapprox(s, sol, atol = tol_erreur)) # sol = [-0.9230769230769234; -0.30769230769230776]
|
||||
end
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ function tester_regions_de_confiance(afficher::Bool, Regions_De_Confiance::Funct
|
|||
# cas de test max_iter
|
||||
x_min22, fmin22, flag22, nb_iters22 = Regions_De_Confiance("cauchy", fct2, grad_fct2, hess_fct2, pts1.x022, options_max_iter)
|
||||
if (afficher)
|
||||
afficher_resultats("régions de confiance avec " * "cauchy", "fonction 2", "x022", x_min22, fmin22, flag22, sol_exacte_fct2, nb_iters22)
|
||||
afficher_resultats("régions de confiance (itermax) avec " * "cauchy", "fonction 2", "x022", x_min22, fmin22, flag22, sol_exacte_fct2, nb_iters22)
|
||||
end
|
||||
@test flag22 == 3
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue