à finir

src/Lagrangien_Augmente.jl

@@ -1,33 +1,33 @@
 @doc doc"""
-Résolution des problèmes de minimisation sous contraintes d'égalités
+Résolution des problèmes de minimisation sous cs d'égalités
 
 # Syntaxe
 ```julia
-Lagrangien_Augmente(algo,fonc,contrainte,gradfonc,hessfonc,grad_contrainte,
-			hess_contrainte,x0,options)
+Lagrangien_Augmente(algo,f,c,gradf,hessf,grad_c,
+			hess_c,x0,options)
 ```
 
 # Entrées
-  * **algo** 		   : (String) l'algorithme sans contraintes à utiliser:
+  * **algo** 		   : (String) l'algorithme sans cs à utiliser:
     - **"newton"**  : pour l'algorithme de Newton
     - **"cauchy"**  : pour le pas de Cauchy
     - **"gct"**     : pour le gradient conjugué tronqué
-  * **fonc** 		   : (Function) la fonction à minimiser
-  * **contrainte**	   : (Function) la contrainte [x est dans le domaine des contraintes ssi ``c(x)=0``]
-  * **gradfonc**       : (Function) le gradient de la fonction
-  * **hessfonc** 	   : (Function) la hessienne de la fonction
-  * **grad_contrainte** : (Function) le gradient de la contrainte
-  * **hess_contrainte** : (Function) la hessienne de la contrainte
+  * **f** 		   : (Function) la ftion à minimiser
+  * **c**	   : (Function) la c [x est dans le domaine des cs ssi ``c(x)=0``]
+  * **gradf**       : (Function) le gradient de la ftion
+  * **hessf** 	   : (Function) la hessienne de la ftion
+  * **grad_c** : (Function) le gradient de la c
+  * **hess_c** : (Function) la hessienne de la c
   * **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
+    4. **lambda_0**	   : la deuxième composante du point de départ du Lagrangien
+    5. **mu_0,tau** 	   : valeurs initiales des variables de l'algorithme
 
 # Sorties
-* **xmin**		   : (Array{Float,1}) une approximation de la solution du problème avec contraintes
+* **xmin**		   : (Array{Float,1}) une approximation de la solution du problème avec cs
 * **fxmin** 	   : (Float) ``f(x_{min})``
 * **flag**		   : (Integer) indicateur du déroulement de l'algorithme
    - **0**    : convergence
@@ -44,36 +44,88 @@ hessf(x)=[-400*(x[2]-3*x[1]^2)+2  -400*x[1];-400*x[1]  200]
 algo = "gct" # ou newton|gct
 x0 = [1; 0]
 options = []
-contrainte(x) =  (x[1]^2) + (x[2]^2) -1.5
-grad_contrainte(x) = [2*x[1] ;2*x[2]]
-hess_contrainte(x) = [2 0;0 2]
-output = Lagrangien_Augmente(algo,f,contrainte,gradf,hessf,grad_contrainte,hess_contrainte,x0,options)
+c(x) =  (x[1]^2) + (x[2]^2) -1.5
+grad_c(x) = [2*x[1] ;2*x[2]]
+hess_c(x) = [2 0;0 2]
+output = Lagrangien_Augmente(algo,f,c,gradf,hessf,grad_c,hess_c,x0,options)
 ```
 """
-function Lagrangien_Augmente(algo, fonc::Function, contrainte::Function, gradfonc::Function,
-  hessfonc::Function, grad_contrainte::Function, hess_contrainte::Function, x0, options)
+function Lagrangien_Augmente(algo, f::Function, c::Function, gradf::Function, hessf::Function, grad_c::Function, hess_c::Function, x0, options)
 
   if options == []
     epsilon = 1e-8
     tol = 1e-5
     itermax = 1000
-    lambda0 = 2
-    mu0 = 100
-    tho = 2
+    lambda_0 = 2
+    mu_0 = 100
+    tau = 2
   else
     epsilon = options[1]
     tol = options[2]
     itermax = options[3]
-    lambda0 = options[4]
-    mu0 = options[5]
-    tho = options[6]
+    lambda_0 = options[4]
+    mu_0 = options[5]
+    tau = options[6]
   end
 
   n = length(x0)
-  xmin = zeros(n)
-  fxmin = 0
-  flag = 0
-  iter = 0
+  flag = -1
 
-  return xmin, fxmin, flag, iter
+  L(x, lambda, mu) = f(x) + lambda' * c(x) + mu / 2 * norm(c(x))^2
+  gradL(x, lambda, mu) = gradf(x) + lambda' * grad_c(x) + mu / 2 * c(x) # à vérifier
+
+  eta_chap_0 = 0.1258925
+  alpha = 0.1
+  beta = 0.9
+  epsilon_0 = 1 / mu_0
+  eta_0 = eta_chap_0 / (mu_0^alpha)
+
+  k = 0
+  x_k = x_0
+  lambda_k = lambda_0
+  mu_k = mu_0
+
+  while true
+
+    # a
+    if algo == "newton"
+      x_k1, _, _, _ = Algorithme_De_Newton(L, gradL, hessL, x_k, options)
+      # A FINIR
+    elseif algo == "cauchy"
+      s_k = Gradient_Conjugue_Tronque(gradf(x_k), hessf(x_k), [delta_k max_iter Tol_rel])
+    elseif algo == "gct"
+      s_k, e_k = Pas_De_Cauchy(gradf(x_k), hessf(x_k), delta_k)
+    end
+
+    if norm(c_k1) <= eta_k # b
+      lambda_k1 = lambda_k + mu_k * c(x_k1)
+      mu_k1 = mu_k
+      epsilon_k1 = epsilon_k / mu_k
+      eta_k1 = eta_k / (mu_k^beta)
+    else # c
+      lambda_k1 = lambda_k
+      mu_k1 = tau * mu_k
+      epsilon_k1 = epsilon_0 / mu_k1
+      eta_k1 = eta_chap_0 / (mu_k1^alpha)
+    end
+
+
+    if norm(gradL(x_k, lambda_k, 0)) <= max(tol * norm(gradL(x_0, lambda_0, 0)), epsilon) && norm(c(x_k)) <= max(tol * norm(c(x_0), epsilon))
+      flag = 0
+      break
+    elseif k >= max_iter
+      flag = 3
+      break
+    end
+
+    k += 1
+    x_k = x_k1
+    lambda_k = lambda_k1
+    mu_k = mu_k1
+
+  end
+
+  xmin = xkp1
+  f_min = f(xmin)
+  return xmin, f_min, flag, k
 end

src/TP-Projet-Optinum.ipynb

@@ -816,6 +816,15 @@
     "      ce nouvel algorithme\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# TODO\n",
+    "COMPLETER LES TESTS pour avoir tous les flags, tous les if \\\n",
+    "répondre aux question"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},