maj documentation

Manifest.toml

@@ -327,7 +327,7 @@ uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 deps = ["Markdown", "Test"]
 git-tree-sha1 = "0f55172039cb2a8d64c8e001a040a7b53209ac67"
 repo-rev = "master"
-repo-url = "https://github.com/mathn7/TestOptinum.git"
+repo-url = "https://github.com/mathn7/TestOptinum"
 uuid = "a6016688-b6f6-4950-8384-ab0954b6af15"
 version = "0.1.0"
 

docs/make.jl

@@ -17,7 +17,6 @@ makedocs(
             ],
 	    "Index des fonctions" =>"fct_index.md",
             "Travail à réaliser" => [
-            "Pour l'algorithme de Newton" => "Questions_Newton.md",
 	    "Pour les régions de confiance avec le pas de Cauchy" => "Questions_Pas_De_Cauchy.md",
 	    "Pour les régions de confiance avec le gradient conjugué tronqué" => "Questions_GCT.md",
 	    "Pour Lagrangien augmenté" => "Questions_Lagrangien_Augmente.md"

docs/src/Algorithme_de_newton.md

@@ -46,3 +46,20 @@ une approximation de la solution du problème ``\min _{x \in \mathbb{R}^{n}} f(x
   b. Mise à jour : ``x_{k+1} = x_{k}+ d_{k} , k = k + 1``
 #### 2.Retourner :  ``x_{k}``.
 
+## Travail à réaliser Pour l'algorithme de Newton 
+
+#### Implémentation 
+ 
+1. Coder l’algorithme de Newton local tel que décrit dans la séction *Algorithme de Newton*
+
+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](Annexes.md).
+
+#### Interprétation 
+
+justifier que
+
+1. l’algorithme implémenté converge en une itération pour ``f_{1}``;
+
+2. l’algorithme puisse ne pas converger pour ``f_{2}`` avec certains points initiaux.
+
+

docs/src/Questions_Newton.md

@@ -2,7 +2,7 @@
 
 ###### Implémentation 
  
-1. Coder l’algorithme de Newton local tel que décrit dans la séction *Algorithme de Newton*
+1. Coder l’algorithme de Newton local tel que décrit dans la section *Algorithme de Newton*
 
 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.
 
@@ -10,7 +10,7 @@
 
 justifier que
 
-1. l’algorithme implémenté converge en une itération pour ``f_{1}`` ,
+1. l’algorithme implémenté converge en une itération pour ``f_{1}``;
 
 2. l’algorithme puisse ne pas converger pour ``f_{2}`` avec certains points initiaux.
 

docs/src/Regions_de_confiance.md

@@ -1,21 +1,21 @@
-# Régions de confiance
+# Régions de confiance partie 1
 
-  L’introduction d’une région de confiance dans la méthode de Newton permet de garantir
+  L’introduction d’une *région de confiance* dans la méthode de Newton permet de garantir
 la convergence globale de celle-ci, i.e. la convergence vers un optimum local quel que soit
 le point de départ. Cela suppose certaines conditions sur la résolution locale des sous-
 problèmes issus de la méthode, qui sont aisément imposables.
 
 ## Principe
-  L’idée de la méthode des régions de confiance est d’approcher f par une fonction
+  L’idée de la méthode des régions de confiance est d’approcher ``f`` par une fonction
 modèle plus simple ``m_{k}`` dans une région ``R_{k}=\left\{x_{k}+s ;\|s\| \leq \Delta_{k}\right\}`` pour un ``\Delta_{k}`` fixé.
 Cette région dite “de confiance” doit être suffisament petite pour que
 
-``\hspace*{2.5cm}`` ``m_{k}\left(x_{k}+s\right) \sim f\left(x_{k}+s\right)``
+``\hspace*{2.5cm}`` ``m_{k}\left(x_{k}+s\right) \sim f\left(x_{k}+s\right).``
 
-   Le principe est que, au lieu de résoudre l’équation : ``f\left(x_{k+1}\right)=\min _{\|x\| \leq \Delta_{k}} f\left(x_{k}+s\right)``
+   Le principe est que, au lieu de résoudre : ``f\left(x_{k+1}\right)=\min _{\|x\| \leq \Delta_{k}} f\left(x_{k}+s\right)``
 on résout :
 
-``\hspace*{2.5cm}`` ``m_{k}\left(x_{k+1}\right)=\min _{\|x\| \leq \Delta_{k}} m_{k}\left(x_{k}+s\right)`` ``\hspace*{2.5cm}``(2.1)
+``\hspace*{2.5cm}`` ``m_{k}\left(x_{k+1}\right)=\min _{\|x\| \leq \Delta_{k}} m_{k}\left(x_{k}+s\right)`` ``\hspace*{2.5cm}.``(2.1)
 
 Si la différence entre ``f(x_{k+1})`` et ``m_{k} (x_{k+1} )`` est trop grande, on diminue le ``∆_{k}`` (et
 donc la région de confiance) et on résout le modèle (2.1) à nouveau. Un avantage de cette
@@ -25,29 +25,29 @@ sur une région proche de ``x_{k}`` .
 
  Exemple de modèle : l’approximation de Taylor à l’ordre 2 (modèle quadratique) :
 
-``\hspace*{1.5cm}``	``m_{k}\left(x_{k}+s\right)=q_{k}(s)=f\left(x_{k}\right)+g_{k}^{\top} s+\frac{1}{2} s^{\top} H_{k} s`` ``\hspace*{1.5cm}``(2.2)
+``\hspace*{1.5cm}``	``m_{k}\left(x_{k}+s\right)=q_{k}(s)=f\left(x_{k}\right)+g_{k}^{\top} s+\frac{1}{2} s^{\top} H_{k} s`` ``\hspace*{1.5cm},``(2.2)
 
-avec ``g_{k}=\nabla f\left(x_{k}\right) \text { et } H_{k}=\nabla^{2} f\left(x_{k}\right)``
+avec ``g_{k}=\nabla f\left(x_{k}\right) \text { et } H_{k}=\nabla^{2} f\left(x_{k}\right).``
 
 ## Algorithme
 
-###### Algorithme 2  
+#### Algorithme 2  
 
 *Méthode des régions de confiance (algo général)*     
 
-###### Données:
+##### Données:
 
-``\Delta_{\max } > 0, \Delta_{0}  \in(0, \Delta_{\max}), 0 < \gamma_{1} < 1 < \gamma_{2} , 0 < \eta_{1} < \eta_{2} < 1``
+``\Delta_{\max } > 0, \Delta_{0}  \in(0, \Delta_{\max}), 0 < \gamma_{1} < 1 < \gamma_{2} , 0 < \eta_{1} < \eta_{2} < 1.``
 
-###### Sorties: 
-une approximation de la solution du problème : ``\min _{x \in \mathbb{R}^{n}} f(x)``
+##### Sorties: 
+une approximation de la solution du problème : ``\min _{x \in \mathbb{R}^{n}} f(x).``
 
 
-###### 1.Tant que le test de convergence est non satisfait:
+##### 1.Tant que le test de convergence est non satisfait :
 
-``\hspace*{1.5cm}`` a.Calculer approximativement ``s_{k}`` solution du sous-problème (2.1);
+``\hspace*{1.5cm}`` a.Calculer approximativement ``s_{k}`` solution du sous-problème (2.1).
 
-``\hspace*{1.5cm}`` b.Evaluer ``f\left(x_{k}+s_{k}\right)`` et ``\rho_{k}=\frac{f\left(x_{k}\right)-f\left(x_{k}+s_{k}\right)}{m_{k}\left(x_{k}\right)-m_{k}\left(x_{k}+s_{k}\right)}``
+``\hspace*{1.5cm}`` b.Evaluer ``f\left(x_{k}+s_{k}\right)`` et ``\rho_{k}=\frac{f\left(x_{k}\right)-f\left(x_{k}+s_{k}\right)}{m_{k}\left(x_{k}\right)-m_{k}\left(x_{k}+s_{k}\right)}.``
 
 ``\hspace*{1.5cm}`` c. Mettre à jour l’itéré courant :
 
@@ -59,7 +59,7 @@ une approximation de la solution du problème : ``\min _{x \in \mathbb{R}^{n}} f
 
 
 
-###### 2.Retourner ``x_{k}``.
+##### 2.Retourner ``x_{k}``.
 
 Cet algorithme  est un cadre générique. On va s’intéresser à deux raffinages possibles de l’étape a.
 

test/runtests.jl

@@ -12,22 +12,22 @@ include("../src/Regions_De_Confiance.jl")
 
 TestOptinum.cacher_stacktrace()
 
+affiche = false
+println("affiche = ",affiche)
 # Tester l'ensemble des algorithmes
-
-@testset "Test SujetOptinum" begin		
+@testset "Test SujetOptinum" begin
 	# Tester l'algorithme de Newton
-	tester_algo_newton(false,Algorithme_De_Newton)
+	tester_algo_newton(affiche,Algorithme_De_Newton)
 
 	# Tester l'algorithme du pas de Cauchy
-	tester_pas_de_cauchy(false,Pas_De_Cauchy)
+	tester_pas_de_cauchy(affiche,Pas_De_Cauchy)
 
 	# Tester l'algorithme du gradient conjugué tronqué
-	tester_gct(false,Gradient_Conjugue_Tronque)
+	tester_gct(affiche,Gradient_Conjugue_Tronque)
 
 	# Tester l'algorithme des Régions de confiance avec PasdeCauchy | GCT
-	tester_regions_de_confiance(false,Regions_De_Confiance)
+	tester_regions_de_confiance(affiche,Regions_De_Confiance)
 
 	# Tester l'algorithme du Lagrangien Augmenté
-	tester_lagrangien_augmente(false,Lagrangien_Augmente)
+	tester_lagrangien_augmente(affiche,Lagrangien_Augmente)
 end
-