3 - Eléments de programmation-Julia.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Eléments de programmation\n",
    "\n",
    "Pour mener à bien un calcul algorithmique le nombre d'éléments de langage n'est pas très important et peut se résumer aux 3 syntaxes suivantes\n",
    "\n",
    "* Le choix conditionnel **if**-**elseif**-**else**-**end**.\n",
    "* La boucle **for**-**end**.\n",
    "* La boucle **while**-**end**\n",
    "\n",
    "\n",
    "# if ... elseif ... else ... end\n",
    "\n",
    "Un choix simple si le test est vrai (k==1) alors le bloc d'instruction est évalué"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k=1\n"
     ]
    }
   ],
   "source": [
    "k=1;\n",
    "if k==1\n",
    "    println(\"k=1\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le **else** permet de donner un résultat par défaut..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k=1\n"
     ]
    }
   ],
   "source": [
    "k=1;\n",
    "if k!=1\n",
    "    println(\"k<>1\")\n",
    "else\n",
    "    println(\"k=1\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une succession de **elseif** permet de choisir parmi plusieurs critères, dans la succession des blocs de **if** et **elseif** le premier qui est \"vrai\" est évaluer et l'instruction s'arrète."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k>1\n"
     ]
    }
   ],
   "source": [
    "k=2;\n",
    "if k==1\n",
    "    println(\"k=1\")\n",
    "elseif k>1\n",
    "    println(\"k>1\")\n",
    "else \n",
    "    println(\"k<1\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La boucle for\n",
    "\n",
    "Elle peut se définir à l'aide d'itérateurs ou de tableaux de valeurs les syntaxes \"=\" ou \"in\" sont équivalentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i=1:10\n",
    "    println(i)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String\n",
      "Int64\n",
      "Complex{Bool}\n"
     ]
    }
   ],
   "source": [
    "for i in [\"un\" 2 im]\n",
    "    println(typeof(i))\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande **break** permet de sortir d'une boucle à tout moment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i = 1:1000\n",
    "    println(i)\n",
    "    if i >= 5\n",
    "       break\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La commande **continue** permet elle de courtcircuiter la boucle en court et de passer à la valeur suivante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i = 1:10\n",
    "    if i % 3 != 0 # i modulo 3 different de 0\n",
    "        continue\n",
    "    end\n",
    "    println(i)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La boucle while\n",
    "\n",
    "Tant que le test est \"vrai\" le bloc est évalué, le test se faisant en entrée de bloc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "k=0;\n",
    "while k<10\n",
    "    k+=1  # k=k+1\n",
    "    println(k)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De même que la boucle **for** les commandes **break** et **continue** sont valables ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "15\n",
      "20\n",
      "25\n",
      "30\n",
      "35\n"
     ]
    }
   ],
   "source": [
    "k=0;\n",
    "while k<1000\n",
    "    k+=1  # k=k+1\n",
    "    if k % 5 != 0 # k modulo 5 diffèrent de 0\n",
    "        continue # retour en début de boucle avec de nouveau un test sur k\n",
    "    end\n",
    "    println(k)\n",
    "    if k>30\n",
    "        break\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Un peu d'optimisation\n",
    "\n",
    "JULIA est dit un langage performant, regardons rapidement quelques exemples à faire ou ne pas faire.\n",
    "\n",
    "## Exemple de préallocation et utilisation de push!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "InterruptException",
     "evalue": "InterruptException:",
     "output_type": "error",
     "traceback": [
      "InterruptException:",
      "",
      "Stacktrace:",
      " [1] __cat(::Array{Float64,1}, ::Tuple{Int64}, ::Tuple{Bool}, ::Array{Float64,1}, ::Vararg{Any,N} where N) at ./abstractarray.jl:1402",
      " [2] vcat(::Array{Float64,1}, ::Int64) at ./abstractarray.jl:1392",
      " [3] top-level scope at ./In[34]:4"
     ]
    }
   ],
   "source": [
    "start = time()\n",
    "A=zeros(0);\n",
    "for i=1:1000000\n",
    "    A=[A;i];   # a chaque itération on change la taille de A\n",
    "end\n",
    "elapsed = time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{Float64,1}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000-element Array{Float64,1}:\n",
       "     1.0\n",
       "     2.0\n",
       "     3.0\n",
       "     4.0\n",
       "     5.0\n",
       "     6.0\n",
       "     7.0\n",
       "     8.0\n",
       "     9.0\n",
       "    10.0\n",
       "    11.0\n",
       "    12.0\n",
       "    13.0\n",
       "     ⋮  \n",
       "  9989.0\n",
       "  9990.0\n",
       "  9991.0\n",
       "  9992.0\n",
       "  9993.0\n",
       "  9994.0\n",
       "  9995.0\n",
       "  9996.0\n",
       "  9997.0\n",
       "  9998.0\n",
       "  9999.0\n",
       " 10000.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1355280876159668"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time()\n",
    "A=zeros(0);\n",
    "for i=1:1000000\n",
    "    push!(A,i);   # a chaque itération on change la taille de A\n",
    "end\n",
    "elapsed = time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000-element Array{Float64,1}:\n",
       "     1.0\n",
       "     2.0\n",
       "     3.0\n",
       "     4.0\n",
       "     5.0\n",
       "     6.0\n",
       "     7.0\n",
       "     8.0\n",
       "     9.0\n",
       "    10.0\n",
       "    11.0\n",
       "    12.0\n",
       "    13.0\n",
       "     ⋮  \n",
       "  9989.0\n",
       "  9990.0\n",
       "  9991.0\n",
       "  9992.0\n",
       "  9993.0\n",
       "  9994.0\n",
       "  9995.0\n",
       "  9996.0\n",
       "  9997.0\n",
       "  9998.0\n",
       "  9999.0\n",
       " 10000.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.06244397163391113"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time()\n",
    "A=zeros(Int64,1000000)\n",
    "for i=1:1000000\n",
    "    A[i]=i;\n",
    "end\n",
    "elapsed = time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.029053926467895508"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time()\n",
    "A=[i for i=1:1000000]\n",
    "elapsed = time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{Int64,1}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cet exemple montre le coût prohibitif d'une réallocation dynamique qui impose une recopie totale de A à chaque itération.\n",
    "\n",
    "## Exemple de vectorisation\n",
    "\n",
    "Regardons la vectorisation sous JULIA à l'aide de la construction d'une matrice de Vandermond\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.813478946685791"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time()\n",
    "n=3000;\n",
    "x=range(0,stop=1,length=n);\n",
    "V=zeros(n,n);\n",
    "for i=1:n\n",
    "    V[:,i]=x.^(i-1) # calcul vectorisé\n",
    "end\n",
    "elapsed = time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 1.0  0.0486277  0.0521712\n",
       " 1.0  0.916497   0.832676 \n",
       " 1.0  0.251161   0.257908 "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=rand(3,3)\n",
    "A[:,1].=1\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.014601945877075"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time()\n",
    "n=3000;\n",
    "x=range(0,stop=1,length=n);\n",
    "X=zeros(n,n);\n",
    "for i=1:n\n",
    "    for j=1:n\n",
    "        X[i,j]=x[i]^(j-1) # calcul dévectorisé\n",
    "    end\n",
    "end\n",
    "elapsed = time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9836759567260742"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time()\n",
    "n=3000;\n",
    "x=range(0,stop=1,length=n);\n",
    "W=[x[i]^(j-1) for i=1:n, j=1:n];\n",
    "elapsed = time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(W)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.21810603141784668"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function Vander(n)\n",
    "    x=range(0,stop=1,length=n);\n",
    "    V=zeros(n,n);\n",
    "    for i=1:n\n",
    "        #V[:,i]=x.^(i-1)\n",
    "        for j=1:n\n",
    "            V[i,j]=x[i]^(j-1) # calcul dévectorisé\n",
    "        end\n",
    "    end\n",
    "    return V\n",
    "end\n",
    "start = time(); Z=Vander(3000); elapsed = time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1992809772491455"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time(); Z=Vander(3000); elapsed = time() - start "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2188708782196045"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time(); Z=Vander(3000); elapsed = time() - start  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.37661004066467285"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function Vander2(n)\n",
    "    x=range(0,stop=1,length=n);\n",
    "    [x[i]^(j-1) for i=1:n, j=1:n];\n",
    "end\n",
    "start = time(); Z2=Vander2(3000); elapsed = time() - start "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{Float64,2}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time(); Z2=Vander2(3000); elapsed = time() - start  \n",
    "typeof(Z2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La conclusion n'est pas toujours évidente a priori... Néanmoins on peut voir que le fait de mettre le code dans une fonction impose une optimisation à la compilation et une contextualisation du type et que l'écriture explicite des boucles donne un meilleur résultat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.1.0",
   "language": "julia",
   "name": "julia-1.1"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.1.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}