Ajout des fichiers dans src

docs/gabarit_rapport.jl

@@ -0,0 +1,21 @@
+#' # OPTINUM-RAPPORT
+#'
+#' Nom et Prénom                       Groupe:
+#'
+#' Date:
+using LinearAlgebra
+using Optinum
+
+#' ## Exercice 1 - <le sujet de l'exercice>
+
+function question1()
+
+  print("TODO !")
+
+  return
+  
+end
+
+question1()
+
+# Un commentaire sur l'exercice 1

docs/src/Algorithme_de_newton.md

@@ -0,0 +1,48 @@
+# Algorithme de Newton local
+
+## Principe
+
+La fonction ``f`` étant ``C^{2}`` , on peut remplacer ``f`` au voisinage de l’itéré courant ``x_{k}`` par son développement de Taylor au second ordre, soit :
+
+``f(y) \sim q(y)=f\left(x_{k}\right)+\nabla f\left(x_{k}\right)^{T}\left(y-x_{k}\right)+\frac{1}{2}\left(y-x_{k}\right)^{T} \nabla^{2} f\left(x_{k}\right)\left(y-x_{k}\right)``
+
+On choisit alors comme point ``x_{k+1}`` le minimum de la quadratique q lorsqu’il existe et
+est unique, ce qui n’est le cas que si ``\nabla^{2} f (x)`` est définie positive. Or le minimum de q est
+réalisé par ``x_{k+1}`` solution de : ``\nabla^{2} f (x_{k+1}) = 0`` , soit :
+``\nabla f\left(x_{k}\right)+\nabla^{2} f\left(x_{k}\right)\left(x_{k+1}-x_{k}\right)=0``
+
+ou encore, en supposant que ``\nabla^{2} f (x_{k})`` est définie positive :
+
+``x_{k+1}=x_{k}-\nabla^{2} f\left(x_{k}\right)^{-1} \nabla f\left(x_{k}\right)``
+
+La méthode ne doit cependant jamais être appliquée en utilisant une inversion de la
+matrice Hessienne (qui peut être de très grande taille et mal conditionnée), mais plutôt en utilisant :
+
+   ``x_{k+1}=x_{k}+d_{k}``
+où ``d_{k}`` est l’unique solution du système linéaire :
+
+   ``\nabla^{2} f\left(x_{k}\right) d_{k}=-\nabla f\left(x_{k}\right)`` ,
+``d_{k}``
+étant appelée direction de Newton.
+
+Cette méthode est bien définie si à chaque itération, la matrice hessienne ``\nabla^{2} f (x_{k})`` est
+définie positive : ceci est vrai en particulier au voisinage de la solution ``x^{*}_{k}`` cherchée si on
+suppose que ``\nabla^{2} f (x^{*})`` 
+est définie positive (par continuité de ``\nabla^{2} f``).
+
+## Algorithme
+
+#### Données:
+
+f , ``x_{0}`` première approximation de la solution cherchée, ``\epsilon > 0`` précision demandée.
+
+#### Sorties
+
+une approximation de la solution du problème ``\min _{x \in \mathbb{R}^{m}} f(x)`` .
+
+#### 1.Tant que le test de convergence est non satisfait 
+  a. Calculer d k solution du système : ``\nabla^{2} f (x_{k}) d_{k} = - \nabla f (x_{k})``
+  
+  b. Mise à jour : ``x_{k+1} = x_{k}+ d_{k} , k = k + 1``
+#### 2.Retourner :  ``x_{k}``.
+

docs/src/Annexes.md

@@ -0,0 +1,95 @@
+## A. Problèmes sans contraintes
+
+Les problèmes de minimisation sans contraintes à résoudre sont les suivants :
+
+###### Problème 1
+
+``\hspace*{1.5cm}`` ``\begin{aligned} f_{1}: \mathbb{R}^{3} & \rightarrow \mathbb{R} \\ \left(x_{1}, x_{2}, x_{3}\right) & \mapsto 2\left(x_{1}+x_{2}+x_{3}-3\right)^{2}+\left(x_{1}-x_{2}\right)^{2}+\left(x_{2}-x_{3}\right)^{2} \end{aligned}``
+
+On cherchera à minimiser ``f_{1}`` sur ``R^{3}`` , en partant des points suivants: ``\\``
+
+``\hspace*{2cm}`` ``x_{011}=\left[\begin{array}{c} 1 \\ 0 \\ 0 \end{array}\right], \quad x_{012}=\left[\begin{array}{c} 10 \\ 3 \\ -2.2 \end{array}\right]``
+
+###### Problème 2
+
+``\hspace*{1.5cm}`` ``\begin{aligned} f_{2}: \mathbb{R}^{2} & \rightarrow \mathbb{R} \\ \left(x_{1}, x_{2}\right) & \mapsto 100\left(x_{2}-x_{1}^{2}\right)^{2}+\left(1-x_{1}\right)^{2} \end{aligned}``
+
+On cherchera à minimiser ``f_{2}`` sur ``R^{2}`` , en partant des points suivants:``\\`` 
+
+
+``x_{0 2 1}=\left[\begin{array}{c} -1.2 \\ 1 \end{array}\right]\\``
+
+``x_{0 2 2}=\left[\begin{array}{c} 10 \\ 0 \end{array}\right]\\``
+
+``x_{023}=\left[\begin{array}{c} 0 \\ \frac{1}{200}+\frac{1}{10^{12}} \end{array}\right]\\``
+
+
+
+## B. Cas tests pour le calcul du pas de Cauchy
+
+On considère des fonctions quadratiques de la forme ``q(s)=s^{\top} g+\frac{1}{2} s^{\top} H s``
+
+###### Quadratique 1
+
+``g=\left[\begin{array}{l} 0 \\ 0 \end{array}\right]``,``H=\left[\begin{array}{ll} 7 & 0 \\ 0 & 2 \end{array}\right]\\``
+
+###### Quadratique 2
+``g=\left[\begin{array}{l} 6 \\ 2 \end{array}\right]``,``H=\left[\begin{array}{ll} 7 & 0 \\ 0 & 2 \end{array}\right]\\``
+
+
+###### Quadratique 3
+
+``g=\left[\begin{array}{l} -2 \\ 1 \end{array}\right]``,``H=\left[\begin{array}{ll} -2 & 0 \\ 0 & 10 \end{array}\right]\\``
+
+## C. Cas tests pour la résolution du sous-problème par l’algorithme du Gradient Conjugué Tronqué
+
+On reprendra les 3 quadratiques testées avec le pas de Cauchy, auxquelles on ajoutera :
+
+###### Quadratique 4
+
+``g=\left[\begin{array}{l} 0 \\ 0 \end{array}\right]``, ``H=\left[\begin{array}{ll} -2 & 0 \\ 0 & 10 \end{array}\right]\\``
+
+###### Quadratique 5
+
+``g=\left[\begin{array}{l} 2 \\ 3 \end{array}\right]``,``H=\left[\begin{array}{ll} 4 & 6 \\ 6 & 5 \end{array}\right]\\``
+
+###### Quadratique 6
+
+``g=\left[\begin{array}{l} 2 \\ 0 \end{array}\right]``, ``H=\left[\begin{array}{ll} 4 & 0 \\ 0 & -15 \end{array}\right]\\``
+
+
+
+
+## D. Problèmes avec contraintes
+
+#### Retour sur f1 
+On s'intéresse à la valeur minimale de f1 sur un ensemble défini par une contrainte linéaire. La formulation du problème sera alors 
+
+``\min _{x \in \mathbb{R}^{3}} f_{1}(x) \text { s.t. } x_{1}+x_{3}=1``
+
+On choisira comme point initial
+
+``x_{c 11}=\left[\begin{array}{l} 0 \\ 1 \\ 1 \end{array}\right]`` (réalisable) 
+
+ou 
+
+``x_{c 12}=\left[\begin{array}{l} 0.5 \\ 1.25 \\ 1 \end{array}\right]`` (non réalisable) .
+   
+#### Retour sur f2
+  On cherche à minimiser la fonction f2 décrite dans la partie précédente, en se restreignant maintenant à une sphère. Le problème s'écrit :
+
+``\min _{x \in \mathbb{R}^{2}} f_{2}(x) \quad \text { s.t. } \quad x_{1}^{2}+x_{2}^{2}=1.5``
+
+On choisira comme point initial
+
+``x_{c 21}=\left[\begin{array}{c} 1 \\ 0 \end{array}\right]``  (non réalisable)  
+
+ou  
+
+``x_{c 22}=\left[\begin{array}{c} \sqrt{3} / 2 \\ \sqrt{3} / 2 \end{array}\right]`` (réalisable).
+
+#### Un problème avec contraintes d'inégalité (supplément)
+
+``\left\{\begin{array}{lll} \min _{(x, y) \in \mathbb{R}^{2}} f_{3}(x, y) & = & (x-1)^{2}+(y-2.5)^{2} \\ x-2 y+2 & \geq & 0 \\ -x-2 y+6 & \geq & 0 \\ -x+2 y+2 & \geq & 0 \\ x & \geq & 0 \\ y & \geq & 0 \end{array}\right.``
+
+L'origine porra être prise comme point initial.

docs/src/Exemples.md

@@ -0,0 +1,97 @@
+## Exemples d'appels
+
+Dans les exemples suivants appliqués sur les fonctions :
+1. [`Algorithme_De_Newton`](@ref)
+1. [`Pas_De_Cauchy`](@ref)
+1. [`Gradient_Conjugue_Tronque`](@ref)
+1. [`Regions_De_Confiance`](@ref)
+1. [`Lagrangien_Augmente`](@ref)
+
+nous allons utiliser la fonction suivante : ``\\``
+``\begin{aligned}\hspace*{1.5cm} f: \mathbb{R}^{2} \quad &\rightarrow \mathbb{R} \\ \hspace*{1.5cm} \left(x_{1}, x_{2}\right) &\rightarrow 100\left(x_{2}-x_{1}^{2}\right)^{2}+\left(1-x_{1}\right)^{2} \end{aligned} \\``
+dont le gradient est : ``\hspace*{0.5cm}`` 
+`` \nabla f(x) = \left[\begin{array}{l} -400 x_{1}(x_{2}-x_{1}^{2})-2(1-x_{1}) & 200 (x_{2}-x_{1}^{2}) \end{array}\right]^{T} \\``
+et la hessienne est : ``\hspace*{0.5cm}``
+`` \nabla^2 f(x) = \left[ \begin{array}{cc} -400 (x_{2}-3 x_{1}^{2})+2 & -400 x_{1} \\ -400 x_{1} & 200 \end{array}\right]``
+
+```@example 1
+using OptinumProf
+using LinearAlgebra
+using Plots
+```
+Voici la fonction ``f``
+```@example 1
+f(x)=100*(x[2]-x[1]^2)^2+(1-x[1])^2
+x, y = -1.5:0.1:1, -2:0.1:3.5
+z = Plots.Surface((x,y)->f([x,y]), x, y)
+Plots.surface(x,y,z,camera=(85,43))
+```
+Ici on trace la norme de ``\nabla f``
+```@example 1
+gradf(x)=[-400*x[1]*(x[2]-x[1]^2)-2*(1-x[1]) ; 200*(x[2]-x[1]^2)]
+z = Plots.Surface((x,y)->norm(gradf([x,y])), x, y)
+Plots.surface(x,y,z,camera=(85,43))
+```
+Et ``\nabla^2 f``
+```@example 1
+hessf(x)=[-400*(x[2]-3*x[1]^2)+2  -400*x[1];-400*x[1]  200]
+options = []
+nothing # masquer la sortie
+```
+### L'Algorithme de Newton
+
+```@example 1
+x0 = [1; 0]
+output = Algorithme_De_Newton(f,gradf,hessf,x0,options)
+println(output) # (xmin,f_min,flag,nb_iters)
+```
+
+### Le pas de Cauchy
+
+```@example 1
+xk = [0; 0.5]
+delta1 = 1
+output = Pas_De_Cauchy(gradf(xk),hessf(xk),delta1)
+println(output) # (sk, e)
+```
+
+### Algorithme du Gradient Conjugué Tronqué
+
+```@example 1
+# deltak = options[1]
+# max_iter = options[2]
+# tol = options[3]
+options = [1,5,1e-3]
+xk = [0; 0.5]
+sk = Gradient_Conjugue_Tronque(gradf(xk),hessf(xk),options)
+println(sk)
+```
+
+### L'Algorithme des régions de confiance
+
+```@example 1
+algo="gct" # ou cauchy
+x0 = [1; 0]
+options = []
+output = Regions_De_Confiance(algo,f,gradf,hessf,x0,options)
+println(output)  # (xmin, fxmin, flag,nb_iters)
+```
+
+### Algorithme du Lagrangien augmenté pour contraintes d’égalité
+
+Dans cet exemple nous allons prendre la contrainte suivante : ``\\``
+`` c(x) = x_{1}^2 + x_{2}^2 -1.5 = 0 \\``
+dont le gradient est : ``\hspace*{0.5cm}`` 
+`` \left[\begin{array}{l} 2x_{1} & 2 x_{2} \end{array}\right]^{T} \\``
+et la hessienne est :``\hspace*{0.5cm}``
+ `` \left[ \begin{array}{cc} 2 & 0 \\ 0 & 2 \end{array}\right]``
+
+```@example 1
+algo = "gct" # ou newton|gct
+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)
+println(output) # (xmin1,fxmin1,flag,nbiters)
+```

docs/src/FAQ.md

@@ -0,0 +1 @@
+# Foire Aux Questions

docs/src/Integration_continue.md

@@ -0,0 +1,103 @@
+# Intégration continue avec Travis CI
+
+### L'Intégration continue
+[L'intégration continue](https://en.wikipedia.org/wiki/Continuous_integration) est un ensemble de pratiques utilisées en génie logiciel consistant à vérifier à chaque modification de code source que le résultat des modifications ne produit pas de régression dans l'application développée, Le principal but de cette pratique est de détecter les problèmes d'intégration au plus tôt lors du développement. De plus, elle permet d'automatiser l'exécution des suites de tests et de voir l'évolution du développement du logiciel.
+
+* Les principaux avantages d'une telle technique de développement sont :
+
+   * le test immédiat des modifications 
+   * la notification rapide en cas de code incompatible ou manquant 
+   * les problèmes d'intégration sont détectés et réparés de façon continue, évitant les problèmes de dernière minute 
+   * une version est toujours disponible pour un test, une démonstration ou une distribution.
+  
+### Travis CI
+
+[**Travis CI**](http://travis-ci.com) est un logiciel libre d'intégration continue. Il fournit un service en ligne utilisé pour compiler, tester et déployer le code source des logiciels développés, notamment en lien avec le service d'hébergement du code source GitHub. Le logiciel est publié sous [licence MIT](https://fr.wikipedia.org/wiki/Licence_MIT). Sa configuration s'effectue en [YAML](https://fr.wikipedia.org/wiki/YAML).
+
+ ### Lancement des jobs sur Travis CI
+
+ Pour lancer des jobs sur Travis : 
+
+1. Allez sur [Travis CI](travis-ci.com) ensuite *Sign up with GitHub*.
+2. Acceptez l'autorisation de Travis CI. Vous serez redirigé vers GitHub.
+3. Cliquez sur votre photo de profil en haut à droite de votre tableau de bord Travis, cliquez sur Paramètres puis sur le bouton vert *Activate button* et sélectionnez les dépôts que vous souhaitez utiliser avec Travis CI.
+4. Maintenant , il ne reste que d'ajouter un fichier `.travis.yml` dans la racine de votre dépôt.
+   ce fichier doit contenir les informations suivantes : le langage utilisé et les versions sur lequels vous voulez lancer les tests.
+   par exemple : 
+
+```yml
+language: julia
+os:
+  - osx
+  - linux
+  - windows 
+julia:
+  - 1.0.5
+  - 1.4
+  - 1.5 
+```
+le job des tests est configuré par défaut, mais il faudra avoir un fichier `runtests.jl` dans le dossier `test` sinon vous devrez personnaliser votre test, par exemple :
+
+```yml
+language: julia
+os:
+  - osx
+  - linux
+  - windows 
+julia:
+  - 1.0.5
+  - 1.4
+  - 1.5 
+script:
+  - julia -e 'using Pkg; Pkg.instantiate(); Pkg.develop(PackageSpec(path=pwd()))'
+  - julia test/test1.jl
+  - julia test/test2.jl
+``` 
+
+Travis CI peut être utilisé pour deployer votre documentation dans les [Github pages](https://docs.travis-ci.com/user/deployment/pages/).
+pour se faire, créez un job spécifique pour la documentation : 
+
+```yml
+jobs:
+  include:
+    - stage: Documentation
+      julia: 1.4
+      os: linux
+      script:        
+        - julia --project=docs -e 'using Pkg; Pkg.instantiate(); Pkg.develop(PackageSpec(path=pwd()))'        
+        - julia --project=docs docs/make.jl
+      after_success: skip
+```
+
+- Dans ce script on utilise un `stage` ("Documentation" n'est qu'un nom), pour en savoir plus [consultez cette page](https://docs.travis-ci.com/user/build-stages/).
+- Pour personnaliser les notifications de Travis, [consultez cette page](https://docs.travis-ci.com/user/notifications/).
+- Pour lancer des applications sur Heroku, [consultez cette page](https://docs.travis-ci.com/user/deployment/heroku/).
+- Pour personnaliser votre build, [consultez cette page](https://docs.travis-ci.com/user/customizing-the-build)
+
+### Déploiement de la documentation 
+
+Si vous voulez déployer votre doc sur *Github pages*, vous devez avoir dans votre fichier `docs/make.jl`, dans le cas de Julia, un appel à la fonction [`deploydocs()`](https://juliadocs.github.io/Documenter.jl/stable/lib/public/#Documenter.deploydocs) du package [`Documenter`](https://juliadocs.github.io/Documenter.jl/stable/lib/public/#Documenter) en donnant comme paramètre le dépôt surlequel vous voulez déployer, exemple :
+```julia
+deploydocs(repo   = "github.com/username/myrepo.git")
+```
+la branche de déploiement est par défaut `branch = "gh-pages"`, et celle du développement est `devbranch="master"`,consultez la documentation de la fonction [`deploydocs()`](https://juliadocs.github.io/Documenter.jl/stable/lib/public/#Documenter.deploydocs) pour en savoir plus.
+
+À chaque `push` ou `pull request` Travis-CI va exécuter ce fichier, et pour lui donner les droits à faire des modifications dans votre branche du dépoiement (`gh-pages` par défaut) suivez les étapes suivantes : 
+
+- Dans le dossier contenant votre module Julia, dans la console julia utilisez la fonction [`genkeys(MonModule)`](https://juliadocs.github.io/Documenter.jl/stable/lib/public/#DocumenterTools.genkeys) du package `DocumenterTools` pour récuperer la clé ssh et la clé de sécurité: 
+
+```julia
+julia> using MonModule # s'il ne trouve pas le module, faites activate ./ dans la racine de votre module
+julia> using DocumenterTools
+julia> DocumenterTools.genkeys(MonModule)
+```
+Ensuite,
+
+- Allez sur `https://github.com/username/myrepo/settings/keys` et àjoutez la clé ssh ("ssh-rsa ...") à votre dépôt,mettez comme nom `documenter` et **cochez** *read/write access*.
+
+- Allez sur `https://travis-ci.com/github/username/myrepo/settings` ajoutez une *secure environment variable* avec le nom `DOCUMENTER_KEY` en donnant comme valeur la deuxième clé ().
+
+!!! warning "Note"
+
+    - Vous devez avoir suffisamment de droits pour pouvoir effectuer ces modifications. 
+    - Evitez de copier un espace de plus en récupérant les deux clés.

docs/src/Lagrangien_augmente.md

@@ -0,0 +1,41 @@
+# Principe
+
+La méthode du lagrangien augmenté appartient à une classe d'algorithme qui
+permettent la résolution des problèmes avec contraintes.Elle s'apparente aux méthodes de
+pénalisation, dans lesquelles on résout le problème avec contraintes à travers une suite de
+problèmes sans contraintes.
+
+#  Algorithme du Lagrangien augmenté pour contraintes d'égalité
+
+  On s'intéresse ici au cas où l'ensemble C est défini par un ensemble des contraintes d'égalités.
+  Le problème se met ainsi sous la forme :
+  
+  ``\min _{x \in \mathbb{R}^{n}} f(x)`` ;   ``c(x)=0``
+  
+où ``c : \mathbb{R}^{n} \rightarrow  \mathbb{R}^{m}``. 
+L'algorithme suivant est obtenu de  Bierlaire, *Introduction à l'optimisation différentiable*.
+  
+ 
+### Données : 
+``\mu_{0} > 0, \tau > 0, \hat{\eta}_{0}=0.1258925 ,  \alpha=0.1, \beta=0.9, \epsilon_{0}=1 ,  \mu_{0}, \eta_{0}=\hat{\eta}_{0} / \mu_{0}^{\alpha}`` , et un point de départ du Lagrangien ``(x_{0},\lambda_{0})``. On pose ``k = 0``
+
+### Sorties :
+une approximation de la solution du problème avec contraintes.
+
+### 1. Tant qu'il n'y a pas convergence, répéter
+   a. Calculer approximation un minimiseur ``x_{k+1}`` du problème sans contraintes suivant :
+   
+   ``\min _{x \in \mathbb{R}^{n}} L_{A}\left(x, \lambda_{k}, \mu_{k}\right)=f(x)+\lambda_{k}^{T} c(x)+\frac{\mu_{k}}{2}\|c(x)\|^{2}``
+   
+avec ``x_{k}`` comme point de départ ,en terminant lorsque ``\| \nabla_{x} L_{A}\left(x, \lambda_{k}, \mu_{k}\right) \| \leq \epsilon_{k}``.
+Si convergence de l'algorithme global, s'arrêter , sinon aller en b
+
+  b. Si ``\|c(x_{k+1})\| \leq \eta_{k}``, mettre à jour (entre autres) les multiplicateurs :
+  
+``\left\{\begin{array}{l}\lambda_{k+1}=\lambda_{k}+\mu_{k} c\left(x_{k+1}\right) \\ \mu_{k+1}=\mu_{k} \\\epsilon_{k+1}=\epsilon_{k} / \mu_{k} \\\eta_{k+1}=\eta_{k} / \mu_{k}^{\beta} \\k=k+1\end{array}\right.``
+  
+  c. Autrement, mettre à jour (entre autres) le paramétre de pénalité :
+  
+``\left\{\begin{array}{l}\lambda_{k+1} =\lambda_{k} \\\mu_{k+1} =\tau \mu_{k} \\\epsilon_{k+1} =\epsilon_{0} / \mu_{k+1} \\\eta_{k+1} =\hat{\eta}_{0} / \mu_{k+1}^{\alpha} \\k=k+1\end{array}\right.``
+  
+### 2. Retourner ``x_{k},\lambda_{k},\mu_{k}`` . 

docs/src/Precompilation.md

@@ -0,0 +1,76 @@
+## Intérêt
+L'utilisation des fonctions des modules, sans avoir accès aux modules ni faire des `using`,
+à partir d'un fichier binaire qui contient des versions précompilées de ces modules.
+
+## Génération du fichier binaire
+##### Ajout du PackageCompiler en local
+```linux
+~$ julia
+```
+```julia
+julia > ]
+(v1.4) pkg> add PackageCompiler
+```
+
+##### Création d'un nouvel environnement et ajout des modules à compiler
+Dans un dossier `NouveauEnv` je crée un nouvel environnement julia
+```linux
+~$ mkdir NouveauEnv
+~$ cd NouveauEnv
+~$ julia
+```
+```julia
+julia> ]
+pkg> activate .
+(NouveauEnv) pkg> add https://github.com/mathn7/TestOptinum.git
+(NouveauEnv) pkg> add https://github.com/mathn7/optinum.git
+(NouveauEnv) pkg> add LinearAlgebra #je rajoute autant que je veux des modules
+```
+
+##### Génération du fichier binaire
+Avant de procéder à la génération du fichier binaire il faut créer un fichier julia (dans le dossier NouveauEnv)
+qui utilise les modules pour pouvoir exporter les fonctions.
+Le contenu de (NouveauEnv/Exemple.jl) sera : 
+
+
+```linux
+~/NouveauEnv
+❯ cat Exemple.jl
+using LinearAlgebra ;using TestOptinum;using Optinum;
+```
+ 
+```linux
+~$julia
+```
+```julia
+julia> ]
+pkg> activate .
+(NouveauEnv) pkg>
+julia> using PackageCompiler
+julia> PackageCompiler.create_sysimage([:LinearAlgebra , :TestOptinum ,:Optinum]; sysimage_path="ExamplePrecompile.so",
+                                         precompile_execution_file="Exemple.jl")
+```
+les paramètres de la fonction `create_sysimage`, utilisés sont :
+
+premier paramètre : liste des modules à compiler (dans notre exemple : LinearAlgebra,TestOptinum,Optinum)
+
+deuxième paramètre (sysimage_path) : nom du fichier binaire à générer (on peut spécifier le chemin également)
+
+troisième paramètre (precompile\_execution\_file) : nom du fichier à compiler
+
+## Utilisation du fichier binaire
+Après la génération du fichier binaire `ExamplePrecompile.so` on peut utiliser
+les fonctions précompilées (qui se trouvaient dans Exemple.jl) sans faire des `using`
+```linux
+~$julia -q -JExamplePrecompile.so
+```
+```julia
+julia> LinearAlgebra.norm([4 5],2)
+6.4031242374328485
+
+julia>TestOptinum.tester_algo_newton(true,Optinum.Algorithme_De_Newton)
+Test Summary:    | Pass  Total
+L'algo de Newton |    4      4
+
+```
+

docs/src/Questions_GCT.md

@@ -0,0 +1,24 @@
+# Travail à réaliser pour l'algorithme des régions de confiance avec gradient conjugué tronqué
+
+###### Implémentation 
+
+1. Implémenter l’algorithme du Gradient Conjugué Tronqué, en se basant sur le cours.
+On validera les résultats sur les fonctions de l’Annexe C.
+
+2. Intégrer finalement l’algorithme du Gradient Conjugué Tronqué dans un code de
+régions de confiance, et appliquer ce code pour résoudre les exemples proposés en
+Annexe A.
+
+###### Interprétation  
+
+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).
+
+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 ?
+
+3. Comparer la décroissance obtenue avec celle du pas de Cauchy dans le cas général.
+
+4. Quels sont les avantages et inconvénients des deux approches ?

docs/src/Questions_Lagrangien_Augmente.md

@@ -0,0 +1,21 @@
+
+# Travail à réaliser :
+
+### Implémentation
+1.Choisir des critères d’arrêt pour la convergence de l'algorithme.
+
+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.
+ 
+3.Tester les différentes variantes sur les problèmes en Annexe D.
+ 
+ ### Interprétation
+ 1.Commenter les résultats obtenus, en étudiant notamment les valeurs de ``λ_{k}`` et ``μ_{k}``.
+ 
+ 2.Étudier l'influence du paramètre ``τ`` dans la performance de l'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

docs/src/Questions_Newton.md

@@ -0,0 +1,16 @@
+## 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.
+
+###### 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_Pas_De_Cauchy.md

@@ -0,0 +1,19 @@
+## Travail à réaliser pour l'algorithme des régions de confiance avec pas de cauchy 
+
+###### Implémentation 
+
+1. Implémenter une fonction calculant **à part** le pas de Cauchy d’un sous-problème de
+régions de confiance. La tester sur les quadratiques proposées en Annexe B.
+
+2. Inclure en suivant ce calcul dans un algorithme de régions de confiance ; le tester sur les problèmes de l’Annexe A.
+
+###### Interprétation 
+
+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.
+
+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.
+
+

docs/src/Regions_de_confiance.md

@@ -0,0 +1,129 @@
+# Régions de confiance
+
+  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
+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)``
+
+   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)``
+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)
+
+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
+méthode est que toutes les directions sont prises en compte. Par contre, il faut faire attention
+à ne pas trop s’éloigner de ``x_{k}`` ; en général, la fonction ``m_{k}`` n’approche proprement ``f`` que
+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)
+
+avec ``g_{k}=\nabla f\left(x_{k}\right) \text { et } H_{k}=\nabla^{2} f\left(x_{k}\right)``
+
+## Algorithme
+
+###### Algorithme 2  
+
+*Méthode des régions de confiance (algo général)*     
+
+###### Données:
+
+``\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)``
+
+
+###### 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}`` 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 :
+
+``\hspace*{2.5cm}``   ``x_{k+1}=\left\{\begin{array}{ll} x_{k}+s_{k} & \text { si } \rho_{k} \geq \eta_{1} \\ x_{k} & \text { sinon. } \end{array}\right.``
+
+``\hspace*{1.5cm}`` d. Mettre à jour la région de confiance : 
+
+``\hspace*{2.5cm}``    ``\Delta_{k+1}=\left\{\begin{array}{cc}\min \{\gamma_{2} \Delta_{k}, \Delta_{\max }\} & \operatorname{si} \rho_{k} \geq \eta_{2} \\ \Delta_{k} & \text{ si } \rho_{k} \in [\eta_{1}, \eta_{2}]. \\\gamma_{1} \Delta_{k} & \text { sinon. } \end{array}\right.``
+
+
+
+###### 2.Retourner ``x_{k}``.
+
+Cet algorithme  est un cadre générique. On va s’intéresser à deux raffinages possibles de l’étape a.
+
+## Le pas de cauchy 
+
+``\hspace*{0.5cm}``On considère ici le modèle quadratique ``q_{k}(s)``. Le sous-problème de régions de confiance correspondant peut se révéler difficile à résoudre (parfois autant que le problème de départ).
+
+Il est donc intéressant de se restreindre à une résolution approchée de ce problème.
+
+``\hspace*{0.5cm}``Le pas de Cauchy appartient à la catégorie des solutions approchées. Il s’agit de se
+restreindre au sous-espace engendré par le vecteur ``g_{k}`` ; le sous-problème s’écrit alors
+
+``\hspace*{2.5cm}`` ``\left\{\begin{array}{cl} \min & q_{k}(s) \\ s . t . & s=-t g_{k} \\ & t>0 \\ & \|s\| \leq \Delta_{k} \end{array}\right.`` 
+``\hspace*{1.5cm}``   (2.3)
+
+## Algorithme du Gradient Conjugué Tronqué
+
+On s’intéresse maintenant à la résolution approchée du problème (2.1) à l’itération k de l’algorithme 2 des Régions de Confiance. On considère pour cela l’algorithme du Gradient Conjugué Tronqué (vu en cours), rappelé ci-après :
+
+
+###### Algorithme 3
+
+*Algorithme du gradient conjugué tronqué*
+
+###### Données:
+
+``\Delta_{k} > 0, x_{k}, g=\nabla f\left(x_{k}\right), H=\nabla^{2} f\left(x_{k}\right)``
+
+###### Sorties:
+
+le pas s qui approche la solution du problème : ``\min_{\|s \| \leq \Delta_{k}} q(s)``
+
+où ``q(s)=g^{\top} s+\frac{1}{2} s^{\top} H_{k} s``
+
+###### Initialisations :
+
+``s_{0}=0, g_{0}=g, p_{0}=-g``
+
+
+**1. Pour** j = 0, 1, 2, . . . , **faire** :
+
+``\hspace*{1.5cm}`` a. ``\hspace*{0.4cm}`` ``\kappa_{j}=p_{j}^{T} H p_{j}``
+
+``\hspace*{1.5cm}`` b.``\hspace*{0.4cm}`` Si ``\kappa_{j} \leq 0`` alors ``\\``
+``\hspace*{2.5cm}`` déterminer ``\sigma_{j}`` la racine de l’équation ``\left\|s_{j}+\sigma p_{j}\right\|_{2}=\Delta_{k}\\``
+ ``\hspace*{2.7cm}`` pour laquelle la valeur de ``q\left(s_{j}+\sigma p_{j}\right)`` est la plus petite.
+
+``\hspace*{2.5cm}`` Poser ``s=s_{j}+\sigma_{j} p_{j}`` et sortir de la boucle.``\\``
+``\hspace*{1.5cm}`` Fin Si
+
+``\hspace*{1.5cm}`` c. ``\hspace*{0.4cm}`` ``\alpha_{j}=g_{j}^{T} g_{j} / \kappa_{j}\\``
+
+``\hspace*{1.5cm}`` d.``\hspace*{0.4cm}`` Si ``\left\|s_{j}+\alpha_{j} p_{j}\right\|_{2} \geq \Delta_{k}`` alors
+
+``\hspace*{2.5cm}`` déterminer ``\sigma_{j}`` la racine positive de l’équation ``\left\|s_{j}+\sigma p_{j}\right\|_{2}=\Delta_{k}\\``
+
+``\hspace*{2.5cm}`` Poser ``s=s_{j}+\sigma_{j} p_{j}`` et sortir de la boucle.``\\``
+``\hspace*{1.5cm}`` Fin Si
+
+
+``\hspace*{1.5cm}`` e. ``\hspace*{0.4cm}`` ``s_{j+1}=s_{j}+\alpha_{j} p_{j}\\``
+``\hspace*{1.5cm}`` f. ``\hspace*{0.4cm}`` ``g_{j+1}=g_{j}+\alpha_{j} H p_{j}\\`` 
+``\hspace*{1.5cm}`` g. ``\hspace*{0.4cm}`` ``\beta_{j}=g_{j+1}^{T} g_{j+1} / g_{j}^{T} g_{j}\\``
+``\hspace*{1.5cm}`` h. ``\hspace*{0.4cm}`` ``p_{j+1}=-g_{j+1}+\beta_{j} p_{j}\\``
+``\hspace*{1.5cm}`` i. ``\hspace*{0.4cm}`` Si la convergence est suffisante, poser ``s=s_{j+1}`` et sortir de la boucle.
+
+###### Retourner ``s``.

docs/src/Sujet.md

@@ -0,0 +1,36 @@
+# Sujet TP-Projet Optimisation numérique 2A-ENSEEIHT
+
+La première partie de ce TP-projet concerne les problèmes d’optimisation sans
+contraintes. On étudie la méthode de Newton et sa globalisation par l’algorithme des
+régions de confiance. La résolution du sous-problème des régions de confiance sera
+réalisée de deux façons, soit à l’aide du point de Cauchy, soit par l’algorithme du Gra-
+dient Conjugué Tronqué.
+La seconde partie du projet exploite la partie précédente pour résoudre des problèmes
+d’optimisation avec contraintes par l’algorithme du Lagrangien augmenté.
+
+## Optimisation sans contraintes
+
+Dans cette partie, on s’intéresse à la résolution du problème
+
+``\min _{x \in \mathbb{R}^{n}} f(x)``
+
+où la fonction ``f`` est de classe ``C^{2}`` sur ``R^{n}`` . On cherche donc à exploiter l’information fournie
+par ses dérivées première et seconde, que l’on représente en tout point x par le vecteur
+gradient ``\nabla f (x) \in R^{n}`` et la matrice Hessienne ``\nabla^{2} f (x) \in R^{nxn}``.
+
+[1) Algorithme de Newton local](Algorithme_de_newton.md)
+
+[2) La méthode des régions de confiance](Regions_de_confiance.md)
+
+
+
+## Optimisation avec contraintes
+
+Dans cette partie, nous nous intéressons à la résolution des problèmes sous contraintes.Le problème se présente donc sous la forme suivante :
+
+
+``\min _{x \in \mathbb{R}^{n}} f(x)`` sous la contrainte ``x \in C``
+
+où C est un sous-ensemble non vide de ``\mathbb{R}^{n}``.
+
+[3) Lagrangien Augmenté](Lagrangien_augmente.md)

docs/src/create_package.md

@@ -0,0 +1,98 @@
+## Créer un Module en Julia
+
+Pour générer un nouveau module :
+```julia
+julia>]
+pkg> generate Module
+julia>;
+shell>cd Module/
+```
+deux fichiers seront crées : `Project.toml` qui contient le nom du package, son UUID unique, sa version, l'auteur et les éventuelles dépendances 
+et le fichier `src/Module.jl` qui contient :
+
+ ```julia
+module Module
+
+greet() = print("Hello World!")
+
+end # module
+```
+ensuite vous pouvez activer le module pour pouvoir l'utiliser en faisant :
+
+```julia
+pkg> activate .
+julia> import Module
+
+julia> Module.greet()
+Hello World!
+```
+### Ajout des dépendances au Module
+
+Pour ajouter des dépendances au Module (les packages utilisés dans le Module):
+
+```julia
+pkg> add Module1 Module2
+ Resolving package versions...
+ Updating "/Module/Project.toml"
+ + ...
+ + ...
+```
+les dépendances résultantes sont ajoutées au fichier `Manifest.toml`
+
+voici un exemple de fichier `Project.toml`:
+
+```julia
+name = "Module"
+uuid = "d9fbbd2f-b07c-4129-9383-1eb96f1f244d"
+authors = [<nom & adresse mail>]
+version = "0.1.0"
+
+[deps]
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+```
+
+maintenant on peut faire une mise à jour du fichier `src/Module.jl`:
+
+```julia
+module Module
+
+import Module1
+import Module2
+
+greet() = print("Hello World!")
+
+end # module
+```
+
+### Ajouter des tests
+
+les tests à réaliser doivent être inclus dans le fichier `test/runtests.jl`
+une fois fait, on peut lancer les tests : 
+
+```julia
+(Module) pkg> test
+   Testing Module
+ Resolving package versions...
+...
+   Testing Module tests passed
+```
+##### Ajouter des dépendances spécifiques aux tests
+pour ajouter des dépendances spécifiques aux tests (ou à la génération de la documentation)
+il faut activer l'environnement `test/` et ajouter les modules utilisés:
+
+```julia
+(Module) pkg> activate ./test
+[ Info: activating environment at `/Module/test/Project.toml`.
+(test) pkg> add Module3
+ Resolving package versions...
+  Updating `/Module/test/Project.toml`
+  [8dfed614] + Module3
+  Updating `/Module/test/Manifest.toml`
+  [...]
+```
+comme pour l'environnement principal les dépendances sont ajoutées dans un fichier `test/Manifest.toml`.
+
+Consultez [cette page](https://julialang.github.io/Pkg.jl/v1/creating-packages/) savoir plus sur la création des packages en Julia.

docs/src/fct_index.md

@@ -0,0 +1,12 @@
+# Documentation des fonctions
+
+Documentation de toute les fonctions du package Optinum
+
+```@index
+Pages = ["fct_index.md"]
+```
+
+```@autodocs
+Modules = [Optinum]
+Order   = [:function, :type]
+```

docs/src/generate_pdf.md

@@ -0,0 +1,23 @@
+# Génération d'un fichier pdf
+
+Le package [Weave](http://weavejl.mpastell.com/stable/) permet de générer un
+rapport sous format pdf d'un script Julia.
+
+Le fichier [gabarit_rapport.jl](../gabarit_rapport.jl) est un gabarit de
+rapport. Après avoir édité votre script, vous pouvez publier votre script en
+format HTML avec la commande:
+
+```julia
+julia> ]
+pkg> add Weave
+julia> using Weave
+julia> weave("gabarit_rapport.jl", doctype = "md2html")
+```
+Il est important d'imprimer ensuite le fichier [HTML en format pdf](https://www.sejda.com/fr/html-to-pdf) pour la remise
+sur Moodle.
+
+!!! warning "Avertissement"
+
+    Les lignes de code précédentes ne doivent pas se retrouver dans votre
+    script. Vous devez les éxécuter dans la console de Julia en vous assurant
+    d'être dans le dossier contenant le fichier `gabarit_rapport.jl`.

docs/src/generation_doc.md

@@ -0,0 +1,59 @@
+# Génération de la documentation d'un dépot git
+
+### 1/ Créer un répertoire `docs/` au niveau de la racine du projet
+
+### 2/ En se plaçant au niveau du répertoire `docs/`
+
+### 2-1/ Création du fichier `make.jl`
+
+Ce programme utilise `Documenter.makedocs()` pour générer les pages html et `Documenter.deploydocs()` pour la dépoloyer dans les Github-pages:
+
+```julia
+using Documenter
+using *le module*
+
+makedocs(    
+    modules = [*le module*],
+    sitename = "le nom du site",
+    authors = "author 1, author 2, ...",
+    format = Documenter.HTML(prettyurls = get(ENV, "CI", nothing) == "true"),
+    pages = [ 
+             *Ici vous listez vos pages de la façon suivante*
+             "Le nom de la page 1 " => "page1.md",
+             "Le nom de la page 2 " => "page2.md",
+                                    .
+                                    .
+                                    .
+            ]
+    )
+
+deploydocs(repo = "*Le lien du dépôt git*")
+```
+### 2-2/- Ajouter les dépendances spécifiques à la génération de la doc
+
+Au niveau du répertoire *docs* vous tapez sur un terminal
+
+```linux
+/docs$ julia
+```
+```Julia
+julia> ]
+pkg> activate .
+(docs) pkg> add Documenter
+(docs) pkg> add *Le lien git du module*
+```
+
+### 2-3/ ajout des fichiers
+
+Créez un docs `src/` ensuite `src/assets/` le premier contiendra `les fichiers.md` et le deuxième contiendra les éventuels images, logo et autres. (pour ajouter un logo mettez l'image sous le nom `logo.<extension>` dans `assets/`.
+
+### 2-4/ index des fonctions
+
+```julia
+
+```
+
+### 3/- Génération de la docs
+
+
+Pour en savoir plus, consultez [cette page](https://juliadocs.github.io/Documenter.jl/stable/lib/public/#Documenter). 

docs/src/git_doc.md

@@ -0,0 +1,91 @@
+## Créer un module en Julia et définir ses fonctions
+Pour générer un nouveau module, utilisez `pkg> generate Toto`,
+deux fichiers seront crées : `Project.toml` qui contient le nom du package, son UUID unique, sa version, l'auteur et les éventuelles dépendances 
+et le fichier `src/Toto.jl` :
+
+```julia
+module Toto
+
+greet() = print("Hello World!")
+include("Fonctions.jl")
+
+end # module
+```
+Dans ce fichier `Toto.jl`, on définit les fonctions du module.
+Dans l'exemple ci-dessus la fonction "greet()" et toutes les fonctions définies dans le fichier "Fonctions.jl" seront accessibles pour les utilisateurs du module.
+
+
+## Définir les tests du module :
+
+Pour ajouter des tests à ce module :
+
+* Créez un nouveau dossier `/test` (pas `/tests` !)
+* dedans créez un nouveau fichier `runtests.jl` (pas `runtest.jl` !)
+
+!! tous les tests devraient être inclus (avec des `include`) dans ce fichier. 
+
+
+## Créer un dépôt Git
+
+Pour créer un dépôt sur Github:
+
+* Rendez-vous sur [github.com](github.com)
+* Créez un compte si vous en avez pas
+* [Créez un dépôt](https://github.com/new), il est recommandé de prendre le même nom que le Module (`Toto` dans notre cas).
+!!! warning "Avertissement"
+    
+    * Ne cochez PAS *Initialize this repository with a README* !, mais si vous l'avez déja fait n'utilisez PAS la méthode suivante, mais plutôt la méthode **Git clone** ci-dessous.
+    * Pour les authentifications, utilisez votre identifiant Github.
+
+* Ensuite,recupérez le lien de votre dépôt:
+
+| [![](https://sansnom.org/activities/discussions/documentation/free-software/pull-request/clone_https.png)]() |
+
+* Lancez un terminal dans le dossier (`Toto` dans notre cas) contenant votre Module:
+```
+git init 
+git add .  
+git commit -m "first commit" 
+git remote add origin https://le_lien_du_dépôt.git 
+git push -u origin master
+```
+Dans la suite vous n'aurez plus besoin d'utiliser toute la commande `git push -u origin master`,mais juste `git push` pour pousser vos modifs.
+#### Git clone
+* Pour ajouter vos fichier si vous avez initialisé votre dépôt lancez un terminal dans un dossier à coté du dossier contenant votre Module:
+```
+git clone https://le_lien_du_dépôt.git 
+```
+* Un dossier au nom du dépôt sera crée, ajouter vos fichiers dedans,(`Project.toml`,`Manifest.toml`,`src/`,...)
+!!! warning "Avertissement"
+    
+    Ajoutez les fichiers et pas le dossier contenant le module !
+    
+* Maintenant,allez dans le dossier du dépôt et dans un terminal :
+
+```
+git add .  
+git commit -m "first commit" 
+git push
+```
+
+Consultez [cette page](https://guides.github.com/activities/hello-world/) pour savoir plus sur Git/Github.
+
+
+## Utilisation du module
+
+* Vous pouvez maintenant importé votre module:
+
+```julia
+julia> ]
+pkg> add https://le_lien_du_dépôt.git
+```
+* pour le tester: 
+
+```julia
+pkg> test Toto
+```
+* pour l'utiliser:
+
+```julia
+julia> using Toto
+```

docs/src/julia_vs_matlab.md

@@ -0,0 +1,510 @@
+# Julia vs MatLab
+
+Cette page se veut une description sommaire des différences entre les languages de programmation MatLab et Julia. Cette page ne se veut pas être une revue exhaustive ni complète des différences entre ces deux langages, mais un sommaire permettant à un utilisateur habitué à MatLab de pouvoir être minimalement fonctionnel sur Julia. Un complément d'informations peut être trouvé sur cette page web de la documentation de Julia [Noteworthy Differences from other Languages](https://docs.julialang.org/en/v1/manual/noteworthy-differences/).
+
+## Quelques fonctions usuelles
+
+Le tableau suivant se veut un recensement non-exhaustif de certaines commandes
+usuelles sur MatLab et Julia.
+
+| Opération                     | MatLab    | Julia     | Librairie requise     |
+| :---:                         | :---:     | :--:      | :--:                  |
+| Vecteur linéairement espacé   | linspace  | LinRange  |                       |
+| Valeur maximale d'un array    | max       | maximum   |                       |
+| Valeur minimale d'un array    | min       | minimum   |                       |
+| Résolution système linéaire   | \         | \         | LinearAlgebra         |
+| Norme d'un vecteur            | norm      | norm      | LinearAlgebra         |
+| Norm d'une matrice            | norm      | opnorm    | LinearAlgebra         |
+| Affichage sur la console      | fprintf   | @printf   | Printf                |
+| Moyenne d'un array            | mean      | mean      | Statistics            |
+| Affichage d'un graphique      | plot      | plot      | Plots                 |
+
+
+Une des différences majeures entre Julia et MatLab est que MatLab représente par
+défaut ces données dans dans des matrices contenant des `Float64`, tandis que
+Julia type *fortement* ces variables. Notamment, Julia distingue les `integer` et
+les `float` à l'aide d'un point `.` suivant immédiatemment le nombre. Par exemple,
+la commande suivante crée un `integer` (`Int64` sur la majorité des machines):
+
+```@repl 1
+a = 3
+typeof(a)
+```
+Alors que la syntaxe suivante crée un `float` (`Float64` sur la majorité des machines):
+
+```@repl 1
+b = 3.
+typeof(b)
+```
+
+Aussi, Julia fait la différence
+entre une variable de type `Float64` et un vecteur contenant des `Float64`.
+
+```@repl 1
+c = -1.
+d = [-1.]
+```
+
+Ceci engendre donc des différences dans l'utilisation de certaines fonctions.
+Par exemple, si l'on veut calculer les valeurs absolues d'un `Float64` et les
+valeurs absolues des éléments d'un vecteur (ou d'une matrice), on obtient les
+résultats suivants:
+
+```@repl 1
+abs(c)
+abs(d)
+```
+
+Il sera indiqué à la section [`Opérations sur des vecteurs et des matrices`](@ref creation_vec_mat)
+comment effectuer cette opération simple à effectuer sur MatLab.
+
+## Création de vecteurs et de matrices
+
+La première différence notable avec MatLab est le fait que Julia distingue les
+vecteurs des matrices. Les vecteurs sont des `array` de dimension 1, alors que
+les matrices sont des `array` dimension 2. En Julia, la convention adoptée est
+de type *column-major order*, les vecteurs sont de type colonne. Afin de créer
+un vecteur sur Julia, on emploie les crochets `[]` et on sépare les éléments par
+des virgules ou des point-virgules `;`.
+
+```@repl 2
+x = [1,2,3]
+y = [1;2;3]
+```
+
+Les matrices sont quant à elles créées encore à l'aide de crochets `[]`, mais
+les éléments sur une même ligne doivent être séparés pas des espaces et un saut
+de ligne s'indique par le point-virgule `;`.
+
+```@repl 2
+A = [1 2 3; 4 5 6]
+```
+
+!!! note
+    La commande suivante créera un `array` de dimension 2 possédant une ligne
+    et 3 colonnes au lieu d'un vecteur
+
+    ```@repl 2
+    z = [1 2 3]
+    ```
+
+## [Opérations sur des vecteurs et des matrices](@id creation_vec_mat)
+
+Julia récupère quelques éléments syntaxiques de MatLab concernant les opérations
+sur *arrays*, mais diffère sur quelques points. Comme dans
+MatLab, les opérations *élément par élément* s'effectuent à l'aide du point `.`.
+Ainsi, les opérations suivantes sont les mêmes que sur MatLab.
+
+```@repl 3
+v=[1,2]
+B=[1 2 ; 3 4]
+C=[5 -6 ; -7 8]
+
+B*C
+B.*C
+
+B^2
+B.^2
+
+B*v
+B.*v
+```
+
+La multiplication d'un vecteur ou une matrice par un nombre est définie comme sur
+MatLab.
+
+```@repl 3
+2.5*v
+2.5*B
+C/3
+```
+
+Les opérations différentes concernent notamment les opérations d'addition/soustraction
+et les comparaison logique. L'addition/soustraction d'un nombre et d'un vecteur/matrice
+n'est pas définie en Julia, il faut donc utiliser le `.`.
+
+```@repl 3
+2 + B
+2 .+ B
+B - C
+B .- C
+```
+
+Pour les opérateurs logiques, il faut aussi employer le `.` afin de comparer
+*éléments par éléments*.
+
+```@repl 3
+2 == B
+2 .== B
+2 .<= B
+
+B<C
+B.<C
+```
+
+!!! warning "Important"
+    Étant donné que le point `.` permet à la fois de définir un `float` et d'effectuer
+    les opérations *éléments par éléments*, il faut mettre des espaces entre les
+    points afin de pouvoir distinguer la signification de chaque point `.`. La
+    commande suivante:
+
+    ```repl
+    5.+[1,2]
+    ```
+    produira le message d'erreur suivant:
+
+    ```repl
+    ERROR: syntax: invalid syntax "5.*"; add space(s) to clarify
+    ```
+
+    Il faut alors utiliser la syntaxe suivante:
+
+    ```
+    5. .+ [1,2]
+    ```
+
+Les fonctions mathématiques standards définies sur ``\mathbb{R}`` n'acceptent
+pas des vecteurs sous Julia. Il faut donc employer le point `.` immédiatemment
+après le nom de la fonction afin d'appliquer la fonction *élément par élément*.
+
+```@repl 3
+cos(v)
+cos.(v)
+mod(B,3)
+mod.(B,3)
+```
+
+Cette syntaxe s'applique à toute les fonctions écrit sur Julia, que cela soit
+les fonctions des librairies standards de Julia ou des fonctions créées par
+l'utilisateur.
+
+
+!!! warning "Avertissement"
+
+    Certaines fonctions mathématiques sont définies sur des matrices carrés, tels
+    les fonctions trigonométriques, l'exponentiation et la puissance. Il faut
+    donc faire attention à savoir si l'on veut effectuer ces opérations sur la
+    matrice ou sur les éléments de la matrice. L'exemple suivant illustre ces
+    différences:
+
+    ```repl
+    M=[0 1 ; 2 -1]
+    exp(M)
+    ```
+    produit le résultat suivant:
+
+    ```repl
+    2×2 Array{Float64,2}:
+    1.8573   0.860982
+    1.72196  0.996317
+    ```
+
+    Alors que la commande suivante:
+
+    ```repl
+    exp.(M)
+    ```
+
+    effectue l'exponentiation *élément par élément*:
+
+    ```repl
+    2×2 Array{Float64,2}:
+    1.0      2.71828
+    7.38906  0.367879
+    ```
+
+
+
+## Indexation, *slices* et concaténation de vecteurs et de matrices
+
+On accède aux éléments d'un vecteur ou d'une matrice à l'aide des crochets `[]`
+comparativement à MatLab ou l'on accède aux éléments avec les parenthèse `()`.
+Le reste de la syntaxe est identique à celle de MatLab, la numérotation commence
+à 1 et le dernier élément peut être extrait avec `end`. Les dimensions sont aussi
+séparées par des virgules `,`.
+
+```@repl 4
+w=[-1,2,3]
+E=[1 2 3 ; 4 5 6 ; 7 8 9]
+
+w[2:end]
+E[[1,3],1:2]
+E[[1,3],[1:2]]
+```
+
+La dernière commande engendre une erreur, ce qui permet d'illustrer une subtile
+différence entre Julia et MatLab. MatLab interprète la commande `[1:2]` en créant
+un vecteur contenant `[1,2]`, alors que Julia crée un *array* d'*array*, ce qui
+génère l'erreur.
+
+La concaténation s'effectue selon la même logique que la création d'une matrice,
+on emploie l'espace pour concaténer horizontalement et le point-virgule `;` pour concaténer
+verticalement  
+
+```@repl 4
+[E E]
+[E;E]
+[w E]
+[E ; w']
+```
+
+La syntaxe pour modifier un ou des éléments d'un vecteur ou d'une matrice est
+la même que sur MatLab. Toutefois, puisque Julia est *fortement typé*, les
+commandes suivantes produisent des erreurs étant donné que les types ne concordent pas.
+
+```@repl 4
+E[1,1] = [-1]
+E[2:3,[1,3]] = -4
+```
+
+En comparaison, les commandes suivantes ne produisent pas d'erreurs:
+
+```@repl 4
+E[1,1] = -1
+E[1:1,1] = [-1]
+E[2:3,[1,3]] .= -4
+```
+
+## Passer par valeur ou par référence?
+
+Une différence majeure entre MatLab et Julia est le fait que MatLab effectue des
+copies de ses variables, alors que Julia effectue parfois le référencement.
+
+```@repl 7
+A = [1 2 ; 3 4]
+B = A;
+B[1,1] = -9;
+A
+```
+
+La deuxième commande ne crée pas une copie de `A`, mais indique plutôt que `B`
+pointe vers le même espace mémoire que `A`. Ainsi, toute modification à `A` ou
+à `B` sera effectuée sur les deux variables.
+
+Toutefois, dès qu'une opération de *slices* consistant à extraire un sous-vecteur
+d'un *array* est effectuée, une copie est créée.
+
+```@repl 7
+A = [1 2 ; 3 4]
+C = A[1,:]
+A[1,1] = -5;
+C
+```
+
+Si l'on veut que la variable `C` pointe vers l'espace mémoire de `A`, il faut
+plutôt employer la fonction `view`.
+
+```@repl 7
+A = [1 2 ; 3 4]
+D = view(A,1,1:2)
+A[1,1] = -3;
+D
+```
+
+Lorsqu'un *array* est passé en argument dans une fonction, l'argument est passé
+par référence. Ainsi, toute modification de cet *array* dans la fonction se
+réflètera à l'extérieur de cette fonction. Ceci constitue une très grosse différence
+par rapport à MatLab, où toutes les variables modifiées au sein d'une fonction
+sont passées par valeur et non par référence.
+
+```@repl 7
+A = [1 2 ; 3 4]
+function demo!(M)
+    M[1,1] = -11
+    T = 1 .+ M
+    return T
+end
+
+S = demo!(A)
+A
+```
+
+!!! note
+    Par convention, les fonctions modifiant les variables passées en arguments
+    sont notées avec un point d'exclamation `!`.
+
+## Création d'une fonction
+
+Sur MatLab, la création de fonctions ne peut s'effectuer qu'à la fin d'un script
+ou en écrivant un fichier `.m` contenant la définition d'une fonction. Julia est
+plus versatile, car des fonctions peuvent être définies n'importe où dans un script
+et même à l'intérieur d'autres fonctions. L'exemple suivant
+permet de définir la fonction ``y(x) = x \cos(x) -e^x``.
+
+```@repl 8
+function exemple1(x)
+    y = x * cos(x) - exp(x)
+    return y
+end
+x = LinRange(0,1,250)
+z1 = exemple1.(x)
+```
+
+!!! warning "Important"
+    la fonction est appellée avec un point étant donné que le veut évaluer la
+    fonction sur chaque élément du vecteur `x`.
+
+Cette dernière fonction peut être définie de manière plus compacte ainsi:
+
+```@repl 8
+exemple2(x) = x * cos(x) - exp(x)
+z2 = exemple2.(x)
+```
+
+Voici un exemple d'une fonction permettant de retourner les éléments d'un vecteur
+plus petit ou égal à une valeur `p` et les valeurs strictement plus grande que `p`.
+
+```@repl 8
+function exemple3(x,p)
+    vector_petit = x[x .<= p]
+    vector_grand = x[x .> p]
+    return vector_petit , vector_grand
+end
+
+test = [1,5,-9,3,-5,2,8,12,7]
+(vec1,vec2) = exemple3(test,2);
+vec1
+vec2
+```
+
+## Scope/portée des variables
+
+Une autre différence majeure entre MatLab et Julia réside dans la portée/scope
+des variables. Sur MatLab, les variables globales doivent être déclarées à la
+fois dans le script et dans les fonctions employant ces variables. Ces variables
+peuvent être modifiées et ces modifications seront accessibles partout. Sur Julia,
+les variables globales sont celles définies dans un script, le REPL ou dans un module.
+Les variables globales dans Julia peuvent seulement être modifiées dans le *scope*
+global (changer des éléments d'un *array* ne consiste pas à changer la variable).
+Les fonctions et les boucles `for/while` introduisent un *scope* local qui hérite
+de toutes les variables du *scope parent* (qu'elles soient globales ou locales).
+Si une variable introduite dans le *scope* local possède le même nom qu'une
+variable globale, une nouvelle variable possédant le même nom sera créée, mais
+sa portée sera restreint qu'au *scope* local (c'est pourquoi, dans l'exemple suivant,
+ la variable `c` n'est pas définie en dehors de la boucle `for`).
+
+```@repl 11
+b = 1
+for t=1:5
+    b = -2
+    c = t + b
+    println(c)
+end
+b
+c
+
+function test1()
+    b = 3
+    println(b)
+end
+test1()
+b
+```
+
+Le script suivant produit une erreur étant donné que la variable `b` dans le
+*scope* de la boucle `for` ne correspond pas au `b` du scope global. Une nouvelle
+variable `b` est alors créée dans le scope de la boucle `for`, ce qui engendre
+une erreur puisque cette variable n'est pas initialisée.
+
+```@repl 11
+b = 1
+
+for t=1:10
+    b = b + 1
+end
+```
+
+Les variables locales sont aussi passées aux *scopes enfants*. Ces variables
+peuvent toutefois être modifiées à l'intérieur de ces *scopes enfants*,
+contrairement aux variables globales.
+
+```@repl 11
+b = 1
+function test2()
+    x = 2
+    function test_in()
+        x = 3
+        return x + b
+    end
+    return test_in() + x
+end
+test2()
+```
+
+
+## Affichage de textes et de tableaux sur la console
+
+Afin d'afficher une ligne de texte sur MatLab, on emploie la commande `fprintf`,
+alors que sur Julia, il faut utiliser la macro `@printf`. Cette macro se retrouve
+dans le package `Printf` qui doit être importé. Le reste de la syntaxe reste
+néanmoins similaire à celle de MatLab.
+
+```@repl 9
+using Printf
+
+n = 1:6; v1 = 2 .^ n; v2 = 2 .^ (1 ./ n);
+
+@printf("n   2^n   2^(1/n)\n")
+for t=1:length(n)
+    @printf("%2d   %2d   %16.15e\n",n[t],v1[t],v2[t])
+end
+```
+
+## Affichage de graphiques
+
+Afin d'afficher des graphiques avec Julia, il faut utiliser le *package* [Plots](http://docs.juliaplots.org/latest/),
+en employant la commande `using Plots`. Les attributs spécifiant les propriétés
+des courbes et des graphiques doivent être décrites lors de la création de
+ces mêmes courbes, comparativement à Matlab. L'exemple suivant permet de créer
+une courbe rouge représentant la fonction sin et une courbe bleue représentant
+la fonction cos.
+
+```@repl 10
+using Plots
+
+x = LinRange(-2*pi,2*pi,250); y1 = sin.(x); y2 = cos.(x);
+
+plot(x,y1,label="sin(x)",color="red")
+plot!(x,y2,label="cos(x)",color="blue",xlabel="x",ylabel="y",title="Un premier graphique")
+
+plot!([],[],label="",size=(400,300)); savefig("tutorial-plot1.png"); nothing # hide
+```
+
+![Graphique #1](tutorial-plot1.png)
+
+Le titre de chaque courbe est spécifié avec l'attribut `label` et la couleur
+avec l'attribut `color`. Pour afficher plusieurs courbes sur le même graphique,
+il faut utiliser la commande terminée par un `!` (ici la commande est `plot!`).
+Finalement, le titre des axes et du graphiques sont spécifiés.
+
+Afin d'afficher des points sur un graphique, on change l'attribut `linetype`
+pour `scatter`.
+
+```@repl 10
+y3 = 2 .* rand(length(x)) .- 1;
+
+plot!(x,y3,label="random",color="green",linetype="scatter")
+
+plot!([],[],label="",size=(400,300)); savefig("tutorial-plot2.png"); nothing # hide
+```
+
+![Graphique #1](tutorial-plot2.png)
+
+Afin de créer un graphique avec des axes en base logarithmique, il faut employer
+l'attribut `xscale=:log10` pour l'axe x ou `yscale=:log10` pour l'axe y. Le
+package `Plots` génèrera toutefois des erreurs si des éléments sont nuls ou
+négatifs lorsque l'on emploie des axes logarithmiques. Il faut donc seulement
+selectionner les éléments strictement plus grand que 0.
+
+```@repl 10
+data_x = 1:5;
+data_y = [1e-3,1e-7,-1e-4,1e-5,0];
+
+plot(data_x[data_y.>0],data_y[data_y.>0],yscale=:log10,title="Graphique avec axe y de type log")
+
+plot!([],[],label="",size=(400,300)); savefig("tutorial-plot3.png"); nothing # hide
+```
+
+![Graphique #2](tutorial-plot3.png)
+
+La description complète des attributs des graphiques est disponible à ce lien: [http://docs.juliaplots.org/latest/attributes/](http://docs.juliaplots.org/latest/attributes/).

docs/src/mise_en_place.md

@@ -0,0 +1,79 @@
+# Mise en place de Julia
+## Julia
+Julia est un langage très récent : sa première version date de 2012 et il est actuellement en version 1.4. 
+Il est de plus en plus utilisé de par le monde, avec un public assez divers : quelques programmeurs bien sûr, 
+mais surtout des scientifiques, des ingénieurs, des analystes financiers, des statisticiens qui développent 
+les bibliothèques de fonctions qui leur sont utiles. 
+## Installation de Julia
+
+Le langage de programmation Julia peut être téléchargé sur le site web
+[Download Julia](https://julialang.org/downloads/). La version v1 ou une
+version plus récente doit être téléchargée.
+
+
+## Éditeur à utiliser 
+
+Pour que plus de gens utilisent le langage, il est nécessaire de fournir un environnement de développement
+complet et accessible pour ce public, avec de l’autocomplétion intelligente, l’intégration de graphiques, le débogage, etc. 
+Cet environnement prend le nom de [Juno](http://junolab.org/). 
+Le développement est parti d’un composant proposé par GitHub, [Atom](https://atom.io/), un éditeur de texte prévu pour être facile à personnaliser.
+Donc nous recommandons d'utiliser l'environnement Juno installé sur l'éditeur de texte Atom, mais rien ne vous empêche d'utiliser d'autres éditeurs comme  
+[Visual Studio Code ](https://code.visualstudio.com/)[avec l'extension Julia](https://www.julia-vscode.org/), [IntelliJ IDEA](https://www.jetbrains.com/idea/) de JetBrains avec le plugin Julia,... etc
+
+## Installation de l'éditeur Atom
+
+### Sous Linux
+Vous pouvez installer Atom sur Linux en téléchargeant ce fichier [.deb](https://atom.io/download/deb), ensuite allez au dossier contenant le fichier,
+ouvrez un terminal, puis installez l’éditeur Atom avec la commande suivante : `sudo dpkg -i atom-amd64.deb` 
+
+### Sous Windows
+- Téléchargez [Julia](https://julialang.org/downloads/)
+- Téléchargez [Atom](https://atom.io/)
+  
+## Installation de Juno
+
+Pour installer Juno, une fois Atom ouvert, suivez les étapes suivantes:
+
+1. Il faut aller dans `Packages -> Settings View -> Open` ou avec la commande `Ctrl + Virgule`
+1. Une fois dans `Setting`, sélectionnez l'onglet `Install à gauche`
+1. Installez le package `uber-juno`
+1. Ouvrez les `Settings` du package `uber-juno` et assurez vous que l'option *Disable - Don't run installation when Atom boots* est déselectionné.
+1. Redémarrez l'éditeur Atom. Atom devrait alors installer de nouveaux packages.
+1. Redémarrez une dernière fois l'éditeur Atom.
+
+Une nouvelle barre d'outils devrait apparaître sur l'interface d'Atom. Si cette
+barre n'est pas visible, vous pouvez la faire apparaître/disparaître avec la
+commande `Ctrl+Alt+T`. De plus, sous le menu Packages d'Atom, une entrée Julia
+devrait maintenant être présente. Si vous rencontrez des problèmes, assurez vous
+que les packages suivants d'Atom sont installés:
+
+- latex-completion
+- indent-detective
+- ink
+- julia-client
+- language-julia
+- tool-bar
+
+Besoin d'aide ? Consultez notre [F.A.Q.](FAQ.md)
+
+## Lancement des tests
+
+Dans le dossier `optinum/` faire :
+
+```julia
+(@v1.) pkg> activate .
+(Optinum) pkg> test
+```
+
+## Lancement d'un seul test
+
+Après une inclusion du fichier contenant la fonction à tester (`Lagrangien_Augmente` dans l'exemple), mettez la fonction en question en paramètre de la fonction de test correspondante dans `TestOptinum` (`tester_Lagrangien_Augmente` dans l'exemple) puis `true/false` pour l'affichage.
+
+#### Exemple (avec l'algorithme du Lagrangien augmenté ):
+
+```julia
+pkg> add https://github.com/mathn7/TestOptinum.git
+julia> using TestOptinum
+julia> include("src/Lagrangien_Augmente.jl") # inclusion de fichier contenant la fonction à tester
+julia> tester_Lagrangien_Augmente(true,Lagrangien_Augmente) # test
+```