{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Travaux pratiques sur les réseaux d'eau" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 0. Données et fonctions du problème" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### On charge dans l'environnement :\n", "1. les fonctions de Julia qui seront utilisées,\n", "2. les données du problème,\n", "3. les fonctions utilitaires du problème." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "using LinearAlgebra\n", "using PyPlot" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "include(\"Probleme_R.jl\")\n", "include(\"Structures_N.jl\")\n", "println()\n", "println(\"Tailles du reseau etudie\")\n", "println(\"Nombre de tuyaux : \", n)\n", "println(\"Nombre de noeuds : \", m)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "include(\"Visualg.jl\")\n", "include(\"Verification.jl\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### On charge les prototypes d'algorithmes d'optimisation :\n", "\n", "* **Gradient_F** : algorithme de gradient à pas fixe,\n", "* **Newton_F** : algorithme de Newton à pas fixe." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function Gradient_F(Oracle, x0, alpha0)\n", "\n", " ##### Initialisation des variables\n", "\n", " iter = 10000\n", " alphai = alpha0\n", " tol = 1e-6\n", "\n", " nx = length(x0)\n", " \n", " logG = Float64[]\n", " logP = Float64[]\n", " cout = Float64[]\n", " \n", " F = Inf\n", " G = zeros(Float64, nx)\n", " D = zeros(Float64, nx)\n", "\n", " x = copy(x0)\n", "\n", " ##### Boucle sur les iterations\n", "\n", " tic = time()\n", "\n", " kstar = iter\n", " for k = 1:iter\n", "\n", " # Appel de l'oracle\n", " F, G = Oracle(x)\n", "\n", " # Test de convergence\n", " if norm(G) <= tol\n", " kstar = k\n", " break\n", " end\n", "\n", " # Direction de descente\n", " D = -G\n", "\n", " # Calcul du pas de gradient\n", " alphan = alphai\n", "\n", " # Mise a jour du point courant\n", " x = x + (alphan*D)\n", "\n", " # Evolution du gradient, du pas et du critere\n", " push!(logG, log10(norm(G)))\n", " push!(logP, log10(alphan))\n", " push!(cout, F)\n", "\n", " end\n", "\n", " ##### Resultats de l'optimisation\n", " \n", " fopt = F\n", " gopt = G\n", " xopt = x\n", " tcpu = time() - tic\n", " \n", " println()\n", " println(\"Iteration : \", kstar)\n", " println(\"Temps CPU : \", tcpu)\n", " println(\"Critere optimal : \", fopt)\n", " println(\"Norme du gradient : \", norm(G))\n", "\n", " # Visualisation de la convergence\n", " Visualg(logG, logP, cout)\n", " \n", " return fopt, gopt, xopt\n", " \n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function Newton_F(Oracle, x0, alpha0)\n", "\n", " ##### Initialisation des variables\n", "\n", " iter = 100\n", " alphai = alpha0\n", " tol = 1e-6\n", "\n", " nx = length(x0)\n", " \n", " logG = Float64[]\n", " logP = Float64[]\n", " cout = Float64[]\n", "\n", " F = Inf\n", " G = zeros(Float64, nx)\n", " H = zeros(Float64, nx, nx)\n", " D = zeros(Float64, nx)\n", "\n", " x = copy(x0)\n", "\n", " ##### Boucle sur les iterations\n", "\n", " tic = time()\n", "\n", " kstar = iter\n", " for k = 1:iter\n", "\n", " # Appel de l'oracle\n", " F, G, H = Oracle(x)\n", "\n", " # Test de convergence\n", " if norm(G) <= tol\n", " kstar = k\n", " break\n", " end\n", "\n", " # Direction de descente\n", " D = - H \\ G\n", "\n", " # Test de la direction de descente\n", " coe = D' * G\n", " if coe >= 0.0\n", " D = -G\n", " #println(\"Direction de montee --- iteration \", k)\n", " end\n", "\n", " # Calcul du pas de gradient\n", " alphan = alphai\n", "\n", " # Mise a jour du point courant\n", " x = x + (alphan*D)\n", "\n", " # Evolution du gradient, du pas et du critere\n", "\n", " push!(logG, log10(norm(G)))\n", " push!(logP, log10(alphan))\n", " push!(cout, F)\n", "\n", " end\n", "\n", " ##### Resultats de l'optimisation\n", "\n", " fopt = F\n", " gopt = G \n", " xopt = x\n", " tcpu = time() - tic\n", " \n", " println()\n", " println(\"Iteration : \", kstar)\n", " println(\"Temps CPU : \", tcpu)\n", " println(\"Critere optimal : \", fopt)\n", " println(\"Norme du gradient : \", norm(G))\n", "\n", " # Visualisation de la convergence\n", " Visualg(logG, logP, cout)\n", " \n", " return fopt, gopt, xopt\n", " \n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## I. Résolution du problème primal" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "include(\"HydrauliqueP.jl\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### I.a On écrit les oracles pour le problème primal d'optimisation :\n", "\n", "* **OraclePG** : calcul de la fonction et du gradient,\n", "* **OraclePH** : calcul de la fonction du gradient et du Hessien." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function OraclePG(qc)\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", "\n", " return F, G\n", "\n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function OraclePH(qc)\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", "\n", " return F, G, H\n", "\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### On teste la validité des oracles en résolvant le problème :\n", "\n", "* **OraclePG** avec la méthode du gradient à pas fixe,\n", "* **OraclePH** avec la méthode de Newton à pas fixe" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 0.1 * rand(n-md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME PRIMAL\")\n", "println()\n", "println(\"ALGORITHME DU GRADIENT A PAS FIXE\")\n", "copt, gopt, xopt = Gradient_F(OraclePG, x0, 0.0005)\n", "qopt, zopt, fopt, popt = HydrauliqueP(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 0.1 * rand(n-md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME PRIMAL\")\n", "println()\n", "println(\"ALGORITHME DE NEWTON A PAS FIXE\")\n", "copt, gopt, xopt = Newton_F(OraclePH, x0, 1.0)\n", "qopt, zopt, fopt, popt = HydrauliqueP(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### I.b On écrit l'algorithme de recherche linéaire (conditions de Wolfe)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function Wolfe(alpha, x, D, Oracle)\n", "\n", " ##### Coefficients de la recherche lineaire\n", "\n", " omega1 = 0.1\n", " omega2 = 0.9\n", "\n", " alphamin = 0.0\n", " alphamax = Inf\n", "\n", " ok = 0\n", " dltx = 0.00000001\n", "\n", " ##### Algorithme de Fletcher-Lemarechal\n", "\n", " # Appel de l'oracle au point initial\n", " F, G = Oracle(x)\n", "\n", " # Initialisation de l'algorithme\n", " alphan = alpha\n", " xn = copy(x)\n", " xp = copy(x)\n", " Gn = zeros(Float64, length(x))\n", " \n", " # Boucle de calcul du pas\n", " # xn represente le point pour la valeur courante du pas,\n", " # xp represente le point pour la valeur precedente du pas.\n", " while ok == 0\n", "\n", " # Point precedent pour tester l'indistinguabilite\n", " xp[:] = xn\n", "\n", " # Point actuel\n", " xn[:] = x .+ alphan*D\n", "\n", " # Calcul des conditions de Wolfe\n", " #\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", " \n", " # Test des conditions de Wolfe\n", " # - Si les deux conditions de Wolfe sont verifiees,\n", " # poser ok = 1 : on sort alors de la boucle while\n", " # - Sinon, modifier la valeur de alphan et reboucler\n", " #\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", "\n", " # Test d'indistingabilite\n", " if norm(xn-xp) < dltx\n", " ok = 2\n", " end\n", " end\n", "\n", " return alphan\n", " \n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### I.c On écrit l'algorithme du gradient à pas variable et on le teste" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function Gradient_V(Oracle, x0, alpha0)\n", "\n", " ##### Initialisation des variables\n", "\n", " iter = 1000\n", " alphai = alpha0\n", " tol = 1e-6\n", "\n", " nx = length(x0)\n", " \n", " logG = Float64[]\n", " logP = Float64[]\n", " cout = Float64[]\n", " \n", " F = Inf\n", " G = zeros(Float64, nx)\n", " D = zeros(Float64, nx)\n", "\n", " x = copy(x0)\n", "\n", " ##### Boucle sur les iterations\n", "\n", " tic = time()\n", "\n", " kstar = iter\n", " for k = 1:iter\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", "\n", " end\n", "\n", " ##### Resultats de l'optimisation\n", " \n", " fopt = F\n", " gopt = G\n", " xopt = x\n", " tcpu = time() - tic\n", " \n", " println()\n", " println(\"Iteration : \", kstar)\n", " println(\"Temps CPU : \", tcpu)\n", " println(\"Critere optimal : \", fopt)\n", " println(\"Norme du gradient : \", norm(G))\n", "\n", " # Visualisation de la convergence\n", " Visualg(logG, logP, cout)\n", " \n", " return fopt, gopt, xopt\n", " \n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "x0 = 0.1 * rand(n-md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME PRIMAL\")\n", "println()\n", "println(\"ALGORITHME DU GRADIENT A PAS VARIABLE\")\n", "copt, gopt, xopt = Gradient_V(OraclePG, x0, 1.0)\n", "qopt, zopt, fopt, popt = HydrauliqueP(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### I.d On écrit l'algorithme de gradient conjugué (Polak-Ribière) et on le teste" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function PolakRibiere(Oracle, x0, alpha0)\n", "\n", " ##### Initialisation des variables\n", "\n", " iter = 1000\n", " alphai = alpha0\n", " tol = 1e-6\n", "\n", " nx = length(x0)\n", " \n", " logG = Float64[]\n", " logP = Float64[]\n", " cout = Float64[]\n", " \n", " F = Inf\n", " G = zeros(Float64, nx)\n", " D = zeros(Float64, nx)\n", "\n", " x = copy(x0)\n", "\n", " ##### Boucle sur les iterations\n", "\n", " tic = time()\n", "\n", " kstar = iter\n", " for k = 1:iter\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", " #\n", " # Attention a l'initialisation de l'algorithme !\n", "\n", " end\n", "\n", " ##### Resultats de l'optimisation\n", " \n", " fopt = F\n", " gopt = G\n", " xopt = x\n", " tcpu = time() - tic\n", " \n", " println()\n", " println(\"Iteration : \", kstar)\n", " println(\"Temps CPU : \", tcpu)\n", " println(\"Critere optimal : \", fopt)\n", " println(\"Norme du gradient : \", norm(G))\n", "\n", " # Visualisation de la convergence\n", " Visualg(logG, logP, cout)\n", " \n", " return fopt, gopt, xopt\n", " \n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 0.1 * rand(n-md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME PRIMAL\")\n", "println()\n", "println(\"ALGORITHME DU GRADIENT CONJUGUE\")\n", "copt, gopt, xopt = PolakRibiere(OraclePG, x0, 1.0)\n", "qopt, zopt, fopt, popt = HydrauliqueP(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### I.e On écrit l'algorithme de quasi-Newton (BFGS) et on le teste" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function BFGS(Oracle, x0, alpha0)\n", "\n", " ##### Initialisation des variables\n", "\n", " iter = 250\n", " alphai = alpha0\n", " tol = 1e-6\n", "\n", " nx = length(x0)\n", " \n", " logG = Float64[]\n", " logP = Float64[]\n", " cout = Float64[]\n", " \n", " F = Inf\n", " G = zeros(Float64, nx)\n", " D = zeros(Float64, nx)\n", "\n", " x = copy(x0)\n", "\n", " ##### Boucle sur les iterations\n", "\n", " tic = time()\n", "\n", " kstar = iter\n", " for k = 1:iter\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", " #\n", " # Attention a l'initialisation de l'algorithme !\n", " \n", " end\n", "\n", " ##### Resultats de l'optimisation\n", " \n", " fopt = F\n", " gopt = G\n", " xopt = x\n", " tcpu = time() - tic\n", " \n", " println()\n", " println(\"Iteration : \", kstar)\n", " println(\"Temps CPU : \", tcpu)\n", " println(\"Critere optimal : \", fopt)\n", " println(\"Norme du gradient : \", norm(G))\n", "\n", " # Visualisation de la convergence\n", " Visualg(logG, logP, cout)\n", " \n", " return fopt, gopt, xopt\n", "\n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 0.1 * rand(n-md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME PRIMAL\")\n", "println()\n", "println(\"ALGORITHME DE QUASI-NEWTON\")\n", "copt, gopt, xopt = BFGS(OraclePG, x0, 1.0)\n", "qopt, zopt, fopt, popt = HydrauliqueP(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### I.f On écrit l'algorithme de Newton à pas variable et on le teste" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function Newton_V(Oracle, x0, alpha0)\n", "\n", " ##### Initialisation des variables\n", "\n", " iter = 100\n", " alphai = alpha0\n", " tol = 1e-6\n", "\n", " nx = length(x0)\n", " \n", " logG = Float64[]\n", " logP = Float64[]\n", " cout = Float64[]\n", "\n", " F = Inf\n", " G = zeros(Float64, nx)\n", " H = zeros(Float64, nx, nx)\n", " D = zeros(Float64, nx)\n", "\n", " x = copy(x0)\n", "\n", " ##### Boucle sur les iterations\n", "\n", " tic = time()\n", "\n", " kstar = iter\n", " for k = 1:iter\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", "\n", " end\n", "\n", " ##### Resultats de l'optimisation\n", "\n", " fopt = F\n", " gopt = G \n", " xopt = x\n", " tcpu = time() - tic\n", " \n", " println()\n", " println(\"Iteration : \", kstar)\n", " println(\"Temps CPU : \", tcpu)\n", " println(\"Critere optimal : \", fopt)\n", " println(\"Norme du gradient : \", norm(G))\n", "\n", " # Visualisation de la convergence\n", " Visualg(logG, logP, cout)\n", " \n", " return fopt, gopt, xopt\n", " \n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 0.1 * rand(n-md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME PRIMAL\")\n", "println()\n", "println(\"ALGORITHME DE NEWTON A PAS VARIABLE\")\n", "copt, gopt, xopt = Newton_V(OraclePH, x0, 1.0)\n", "qopt, zopt, fopt, popt = HydrauliqueP(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## II. Résolution du problème dual" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "include(\"HydrauliqueD.jl\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### II.a On écrit les oracles pour le problème dual d'optimisation :\n", "\n", "* **OracleDG** : calcul de la fonction et du gradient,\n", "* **OracleDH** : calcul de la fonction du gradient et du Hessien." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function OracleDG(pd)\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", " \n", " return F, G\n", "\n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function OracleDH(pd)\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", " \n", " return F, G, H\n", "\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### II.b On exécute tous les algorithmes d'optimisation déjà écrits" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 100.0 .+ rand(md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME DUAL\")\n", "println()\n", "println(\"ALGORITHME DU GRADIENT A PAS VARIABLE\")\n", "copt, gopt, xopt = Gradient_V(OracleDG, x0, 5.0)\n", "qopt, zopt, fopt, popt = HydrauliqueD(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 100.0 .+ rand(md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME DUAL\")\n", "println()\n", "println(\"ALGORITHME DU GRADIENT CONJUGUE\")\n", "copt, gopt, xopt = PolakRibiere(OracleDG, x0, 5.0)\n", "qopt, zopt, fopt, popt = HydrauliqueD(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 100 .+ rand(md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME DUAL\")\n", "println()\n", "println(\"ALGORITHME DE QUASI-NEWTON\")\n", "copt, gopt, xopt = BFGS(OracleDG, x0, 1.0)\n", "qopt, zopt, fopt, popt = HydrauliqueD(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "x0 = 100 .+ rand(md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME DUAL\")\n", "println()\n", "println(\"ALGORITHME DE NEWTON A PAS VARIABLE\")\n", "copt, gopt, xopt = Newton_V(OracleDH, x0, 1.0)\n", "qopt, zopt, fopt, popt = HydrauliqueD(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## III. Résolution de grands réseaux (facultatif)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### On charge dans l'environnement les données du problème\n", "\n", "Ces données correspondent à un réseau de taille paramétrable." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "include(\"Probleme_P.jl\")\n", "include(\"Structures_S.jl\")\n", "println()\n", "println(\"Tailles du reseau etudie\")\n", "println(\"Nombre de niveaux :\", T)\n", "println(\"Nombre de tuyaux :\", n)\n", "println(\"Nombre de noeuds :\", m)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### III.a On écrit des oracles primal et dual avec Hessien creux" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function OraclePHS(qc)\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", " \n", " return F, G, H\n", " \n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function OracleDHS(pd)\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", " \n", " return F, G, H\n", " \n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### III.b On écrit un algorithme de Newton exploitant le creux" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "function Newton_S(Oracle, x0, alpha0)\n", "\n", " # ---> A COMPLETER\n", " # ---> A COMPLETER\n", " \n", " return fopt, gopt, xopt\n", " \n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### III.c On résoud le problème dans le primal et dans le dual" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 0.1 * rand(n-md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME PRIMAL DE GRANDE TAILLE\")\n", "println()\n", "println(\"ALGORITHME DE NEWTON A PAS VARIABLE\")\n", "copt, gopt, xopt = Newton_S(OraclePHS, x0, 1.0)\n", "qopt, zopt, fopt, popt = HydrauliqueP(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x0 = 100 .+ rand(md)\n", "println()\n", "println(\"MINIMISATION DU PROBLEME DUAL DE GRANDE TAILLE\")\n", "println()\n", "println(\"ALGORITHME DE NEWTON A PAS VARIABLE\")\n", "copt, gopt, xopt = Newton_S(OracleDHS, x0, 1.0)\n", "qopt, zopt, fopt, popt = HydrauliqueD(xopt)\n", "Verification(qopt, zopt, fopt, popt)" ] } ], "metadata": { "kernelspec": { "display_name": "Julia 1.2.0", "language": "julia", "name": "julia-1.2" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.2.0" } }, "nbformat": 4, "nbformat_minor": 2 }