Julia, a fresh approach to technical computing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Julia: a fresh approach to technical computing\n",
    "\n",
    "\n",
    "* Julia is a high-level programming language for technical computing which allows you to manipulate and analyse large data sets\n",
    "* Other programming languages similar to Julia are Matlab and Python\n",
    "* Unlike Python, Julia is build from the ground for techical computing\n",
    "* Unlike Matlab, julia is free and open-source software\n",
    "* Julia is fast (http://julialang.org/benchmarks/: these are microbenchmark (with explicit loops) to be taken with a grain of salt, and see also benchmarks below)\n",
    "\n",
    "\n",
    "## Try Julia\n",
    "\n",
    "* Try julia online at https://juliabox.com/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Install Julia\n",
    "\n",
    "* Go to http://julialang.org/downloads/\n",
    "* Install also a text editor with julia support (e.g. emacs with the julia mode)\n",
    "\n",
    "### Optionally\n",
    "\n",
    "* Install Jupyter http://jupyter.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Variable declarations \n",
    "\n",
    "## Unicode\n",
    "\n",
    "* Unicode in in variables names and function\n",
    "* For example greek letters\n",
    "* Typed as, e.g. \\alpha followed by Tab (in text editor with Julia support)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "α = π/2\n",
    "σ² = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "* Also for function names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "my_serious_function😼 (generic function with 1 method)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function my_serious_function😼(x,y)\n",
    "    return y,x\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_serious_function😼(1,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* also for build-in operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ∈ Set([2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 in Set([2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Do not get crazy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.345"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "𝔳𝔞𝔯𝔦𝔞𝔟𝔩𝔢 = 1.234\n",
    "שคгเค๒ɭє = 2.345"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions\n",
    "\n",
    "* Functions are central in julia:\n",
    "  * functions are \"first-class\" (e.g. a variable/parameter can hold a function)\n",
    "  * all operators are defined as functions: `1+2` is in fact `+(1,2)`\n",
    "  * functions are very flexible due to [multiple dispatch](https://en.wikipedia.org/wiki/Multiple_dispatch)\n",
    "* There are 3 ways to define a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "times_two (generic function with 1 method)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function times_two(x)\n",
    "    return 2x\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `return` is actually optional. If it is not present, then the last value of a function is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "times2 (generic function with 1 method)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "times2(x) = 2x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#43 (generic function with 1 method)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x -> 2x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operators\n",
    "\n",
    "* Julia has all the usual operators: +, -, *, / as most programming languages have\n",
    "\n",
    "## Additional interesting operators\n",
    "\n",
    "* Multiply by the inverse of a matrix: A \\ x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 0.5\n",
       " 0.5"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1; 1]; A = [2 0; 0 2]; A \\ x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* do you like shell pipes? (in DIVA 1081 shell pipes for 154 scripts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "54"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1:5;]  |> x->x.^2 |> x-> x[x .> 2] |> sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* function composition f ∘ g (x) (type \\circ followed by the tab key), in julia 0.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8414709848078965"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(abs ∘ sin)(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Arrays\n",
    "\n",
    "* Arrays can be homogenous or heterogenous\n",
    "* Julia figures this out for you\n",
    "\n",
    "* Homogenous arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elements can also be converted if necessary to make an homogenous array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 2.0\n",
       " 4.0\n",
       " 5.0"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr2 = [2.,4.,5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Example of an heterogeneous array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Any,1}:\n",
       " 1\n",
       " 2\n",
       "  \"this is a string\""
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = [1,2,\"this is a string\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Automatic type inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "speed (generic function with 1 method)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function speed(u,v)\n",
    "    u2 = u.^2\n",
    "    v2 = v.^2\n",
    "    s2 = u2 + v2\n",
    "    s = sqrt.(s2)\n",
    "    return s\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variables\n",
      "  #self#\u001b[36m::Core.Compiler.Const(speed, false)\u001b[39m\n",
      "  u\u001b[36m::Float64\u001b[39m\n",
      "  v\u001b[36m::Float64\u001b[39m\n",
      "  u2\u001b[36m::Float64\u001b[39m\n",
      "  v2\u001b[36m::Float64\u001b[39m\n",
      "  s2\u001b[36m::Float64\u001b[39m\n",
      "  s\u001b[36m::Float64\u001b[39m\n",
      "\n",
      "Body\u001b[36m::Float64\u001b[39m\n",
      "\u001b[90m1 ─\u001b[39m %1  = Core.apply_type(Base.Val, 2)\u001b[36m::Core.Compiler.Const(Val{2}, false)\u001b[39m\n",
      "\u001b[90m│  \u001b[39m %2  = (%1)()\u001b[36m::Core.Compiler.Const(Val{2}(), false)\u001b[39m\n",
      "\u001b[90m│  \u001b[39m %3  = Base.broadcasted(Base.literal_pow, Main.:^, u, %2)\u001b[36m::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0},Nothing,typeof(Base.literal_pow),Tuple{Base.RefValue{typeof(^)},Float64,Base.RefValue{Val{2}}}}\u001b[39m\n",
      "\u001b[90m│  \u001b[39m       (u2 = Base.materialize(%3))\n",
      "\u001b[90m│  \u001b[39m %5  = Core.apply_type(Base.Val, 2)\u001b[36m::Core.Compiler.Const(Val{2}, false)\u001b[39m\n",
      "\u001b[90m│  \u001b[39m %6  = (%5)()\u001b[36m::Core.Compiler.Const(Val{2}(), false)\u001b[39m\n",
      "\u001b[90m│  \u001b[39m %7  = Base.broadcasted(Base.literal_pow, Main.:^, v, %6)\u001b[36m::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0},Nothing,typeof(Base.literal_pow),Tuple{Base.RefValue{typeof(^)},Float64,Base.RefValue{Val{2}}}}\u001b[39m\n",
      "\u001b[90m│  \u001b[39m       (v2 = Base.materialize(%7))\n",
      "\u001b[90m│  \u001b[39m       (s2 = u2 + v2)\n",
      "\u001b[90m│  \u001b[39m %10 = Base.broadcasted(Main.sqrt, s2)\u001b[36m::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{0},Nothing,typeof(sqrt),Tuple{Float64}}\u001b[39m\n",
      "\u001b[90m│  \u001b[39m       (s = Base.materialize(%10))\n",
      "\u001b[90m└──\u001b[39m       return s\n"
     ]
    }
   ],
   "source": [
    "@code_warntype speed(1.,2.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 2.23606797749979\n",
       " 3.605551275463989"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speed([1.,2.],[2.,3.])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Code generation\n",
    "\n",
    "* The julia compiler generates efficient machine code\n",
    "* Loops are not slow (compared to Python, Matlab or Octave)\n",
    "* It is still possible to use vectorized code\n",
    "  * vectorized code typically uses more memory than code with explicit loops\n",
    "  * vectorized code is slightly slower than code with with explicit loops\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      ";  @ In[63]:1 within `speed'\n",
      "define double @julia_speed_6536(double, double) {\n",
      "top:\n",
      ";  @ In[63]:2 within `speed'\n",
      "; ┌ @ broadcast.jl:837 within `materialize'\n",
      "; │┌ @ broadcast.jl:852 within `copy'\n",
      "; ││┌ @ broadcast.jl:575 within `getindex'\n",
      "; │││┌ @ broadcast.jl:621 within `_broadcast_getindex'\n",
      "; ││││┌ @ broadcast.jl:648 within `_broadcast_getindex_evalf'\n",
      "; │││││┌ @ intfuncs.jl:296 within `literal_pow'\n",
      "; ││││││┌ @ float.jl:405 within `*'\n",
      "         %2 = fmul double %0, %0\n",
      "; └└└└└└└\n",
      ";  @ In[63]:3 within `speed'\n",
      "; ┌ @ broadcast.jl:837 within `materialize'\n",
      "; │┌ @ broadcast.jl:852 within `copy'\n",
      "; ││┌ @ broadcast.jl:575 within `getindex'\n",
      "; │││┌ @ broadcast.jl:621 within `_broadcast_getindex'\n",
      "; ││││┌ @ broadcast.jl:648 within `_broadcast_getindex_evalf'\n",
      "; │││││┌ @ intfuncs.jl:296 within `literal_pow'\n",
      "; ││││││┌ @ float.jl:405 within `*'\n",
      "         %3 = fmul double %1, %1\n",
      "; └└└└└└└\n",
      ";  @ In[63]:4 within `speed'\n",
      "; ┌ @ float.jl:401 within `+'\n",
      "   %4 = fadd double %2, %3\n",
      "; └\n",
      ";  @ In[63]:5 within `speed'\n",
      "; ┌ @ broadcast.jl:837 within `materialize'\n",
      "; │┌ @ broadcast.jl:852 within `copy'\n",
      "; ││┌ @ broadcast.jl:575 within `getindex'\n",
      "; │││┌ @ broadcast.jl:621 within `_broadcast_getindex'\n",
      "; ││││┌ @ broadcast.jl:648 within `_broadcast_getindex_evalf'\n",
      "; │││││┌ @ math.jl:574 within `sqrt'\n",
      "        %5 = call double @llvm.sqrt.f64(double %4)\n",
      "; └└└└└└\n",
      ";  @ In[63]:6 within `speed'\n",
      "  ret double %5\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "@code_llvm speed(1.,2.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t.text\n",
      "; ┌ @ In[63]:2 within `speed'\n",
      "; │┌ @ broadcast.jl:837 within `materialize'\n",
      "; ││┌ @ broadcast.jl:852 within `copy'\n",
      "; │││┌ @ broadcast.jl:575 within `getindex'\n",
      "; ││││┌ @ broadcast.jl:621 within `_broadcast_getindex'\n",
      "; │││││┌ @ broadcast.jl:648 within `_broadcast_getindex_evalf'\n",
      "; ││││││┌ @ intfuncs.jl:296 within `literal_pow'\n",
      "; │││││││┌ @ float.jl:405 within `*'\n",
      "\tvmulsd\t%xmm0, %xmm0, %xmm0\n",
      "; │└└└└└└└\n",
      "; │ @ In[63]:3 within `speed'\n",
      "; │┌ @ broadcast.jl:837 within `materialize'\n",
      "; ││┌ @ broadcast.jl:852 within `copy'\n",
      "; │││┌ @ broadcast.jl:575 within `getindex'\n",
      "; ││││┌ @ broadcast.jl:621 within `_broadcast_getindex'\n",
      "; │││││┌ @ broadcast.jl:648 within `_broadcast_getindex_evalf'\n",
      "; ││││││┌ @ intfuncs.jl:296 within `literal_pow'\n",
      "; │││││││┌ @ float.jl:405 within `*'\n",
      "\tvmulsd\t%xmm1, %xmm1, %xmm1\n",
      "; │└└└└└└└\n",
      "; │ @ In[63]:4 within `speed'\n",
      "; │┌ @ float.jl:401 within `+'\n",
      "\tvaddsd\t%xmm1, %xmm0, %xmm0\n",
      "; │└\n",
      "; │ @ In[63]:5 within `speed'\n",
      "; │┌ @ broadcast.jl:837 within `materialize'\n",
      "; ││┌ @ broadcast.jl:852 within `copy'\n",
      "; │││┌ @ broadcast.jl:575 within `getindex'\n",
      "; ││││┌ @ broadcast.jl:621 within `_broadcast_getindex'\n",
      "; │││││┌ @ broadcast.jl:648 within `_broadcast_getindex_evalf'\n",
      "; ││││││┌ @ math.jl:574 within `sqrt'\n",
      "\tvsqrtsd\t%xmm0, %xmm0, %xmm0\n",
      "; │└└└└└└\n",
      "; │ @ In[63]:6 within `speed'\n",
      "\tretq\n",
      "\tnopw\t%cs:(%rax,%rax)\n",
      "\tnopl\t(%rax,%rax)\n",
      "; └\n"
     ]
    }
   ],
   "source": [
    "@code_native speed(1.,2.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Benchmarks\n",
    "\n",
    "\n",
    "### Mandelbrod fractals\n",
    "\n",
    "* Median times of 30 runs\n",
    "\n",
    "| program                 |      style | run time (sec)  |\n",
    "|------------------|------------|-----------------|\n",
    "| matlab R2013a    |       loops|   5.67     |\n",
    "| matlab R2013a    |  vectorized|   2.40  |\n",
    "|  octave 3.8.1    |       loops| 184.56  |\n",
    "|  octave 3.8.1    |  vectorized|   4.72  |\n",
    "|     julia 0.5    |       loops|   0.19 |\n",
    "|     julia 0.5    |  vectorized|   2.24  |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Ensemble Transform Kalman Filter (ETKF)\n",
    "\n",
    "#### Parameters\n",
    "\n",
    "| parameter                               | value  |\n",
    "|-----------------------------------------|--------|\n",
    "| number of elements in the state vector  | 50     |\n",
    "| ensemble size                           | 100    |\n",
    "| number of observations                  | 5      |\n",
    "| number of water columns                 | 10000  |\n",
    "\n",
    "#### Run-time\n",
    "\n",
    "| Language | version | comments | run-time (s) |\n",
    "|----------|---------|----------|--------------|\n",
    "| Julia    | 0.4.5   | -          | 43.362 |\n",
    "| Fortran (gfortran)  | 4.8.4   | intrinsic matmul             |  136.481 |\n",
    "| Fortran (gfortran) | 4.8.4   | matmul calls external BLAS    |  32.483  |\n",
    "| Matlab   | R2013a  | -         | 31.1854      |\n",
    "| Octave   | 3.8.1   | -         | 58.019       |\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "| Language | version | comments | run-time (s) |\n",
    "|----------|---------|----------|--------------|\n",
    "| Fortran (gfortran) | 4.8.4   | matmul calls external BLAS    |  32.483  |\n",
    "| Julia    | 0.5.0   | type-stable, without bounds check         | 29.948924 |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Working with files\n",
    "* open a file, and load every line sequentially"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this\n",
      "is\n",
      "a test\n"
     ]
    }
   ],
   "source": [
    "f = open(\"file.txt\")\n",
    "for l in eachline(f)\n",
    "         println(l)\n",
    "end\n",
    "close(f)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* a common error is to forget to close the file\n",
    "* with a do-block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this\n",
      "is\n",
      "a test\n"
     ]
    }
   ],
   "source": [
    "open(\"file.txt\") do f\n",
    "  for l in eachline(f)\n",
    "     println(l)\n",
    "  end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* similar to python's `with` statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Visualization\n",
    "\n",
    "* Julia can call all Python modules, for instance also matplotlib\n",
    "* `PyPlot` is a matplotlib wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PyPlot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 2 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = randn(10,10)\n",
    "pcolor(x)\n",
    "xlabel(\"x-axis\")\n",
    "ylabel(\"y-axis\")\n",
    "title(\"my plot\")\n",
    "colorbar();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Custom types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "using PyPlot\n",
    "using Base"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Create a new type `ParamCovar` which represents an error covariance matrix\n",
    "* It behaves like an Array of 2 dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "mutable struct ParamCovar{T} <: AbstractArray{T, 2} \n",
    "    n:: Int64       # dimension\n",
    "    len:: T         # correlation length\n",
    "    var:: T         # variance\n",
    "    x:: Array{T,2}  # x[i,:] are the n coordinates of the i-th grid point\n",
    "end\n",
    "\n",
    "function Base.size(PC::ParamCovar)\n",
    "    return (PC.n,PC.n)\n",
    "end\n",
    "\n",
    "function Base.getindex(PC::ParamCovar,i,j)\n",
    "    d2 = sum((PC.x[i,:] - PC.x[j,:]).^2)\n",
    "    return PC.var * exp(-d2 / (PC.len^2))\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Define a domain [-10,10] x [-10,10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "imax = 50\n",
    "jmax = imax\n",
    "\n",
    "vx1 = range(-10,stop=10,length=imax)\n",
    "vx2 = range(-10,stop=10,length=jmax)\n",
    "\n",
    "x1 = [x1 for x1 in vx1, x2 in vx2];\n",
    "x2 = [x2 for x1 in vx1, x2 in vx2];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* create an instance of the `ParamCovar` type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = length(x1)\n",
    "m = 3\n",
    "\n",
    "# n: number of grid points (total)\n",
    "# len = 4 (correlation length)\n",
    "# var = 1 (background variance)\n",
    "\n",
    "# Pf = ParamCovar{Float64}(n,4.,1.,[x1[:] x2[:]]) or just\n",
    "Pf = ParamCovar(n,4.,1.,[x1[:] x2[:]]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* setup additional matrices (observation operator $\\mathbf H$, observation error covariance matrix $\\mathbf R$, forecast $\\mathbf x_f$)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1225"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using SparseArrays, LinearAlgebra\n",
    "\n",
    "# index of the middle of the domain\n",
    "ind = LinearIndices(size(x1))[Int64(imax/2),Int64(jmax/2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "H = sparse([1,2,3],\n",
    "           [1,ind,n], [1.,1.,1.], 3,n)\n",
    "\n",
    "R = Diagonal([1,1,1])\n",
    "yo = [1,-1,1]\n",
    "\n",
    "\n",
    "xf = zeros(n);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* optimal interpolation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 2 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.colorbar.Colorbar object at 0x7f83a94d34f0>"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xa = xf + Pf * (H' * ((H*Pf*H' + R) \\ (yo - H*xf)))\n",
    "\n",
    "xa = reshape(xa,size(x1))\n",
    "pcolor(xa)\n",
    "colorbar()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "# Parallel programming\n",
    "\n",
    "* start julia with\n",
    "  * `-p`: local machine\n",
    "  * `--machinefile`:  cluster\n",
    "* or use, e.g. `addprocs(4)` to use 4 workers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lower-level constructs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myid() = 1\n",
      "nprocs() = 9\n",
      "workers() = [2, 3, 4, 5, 6, 7, 8, 9]\n",
      "fetch(#= In[79]:14 =# @spawnat(4, myid())) = 4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Distributed\n",
    "addprocs(4, exeflags=\"--project\")\n",
    "\n",
    "# process ID\n",
    "@show myid()\n",
    "\n",
    "# number of all process\n",
    "@show nprocs()\n",
    "\n",
    "# id of all workers\n",
    "@show workers()\n",
    "\n",
    "# run myid() on process 4\n",
    "@show fetch(@spawnat 4 myid())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@everywhere heavy_computation(x) =  x.^5;\n",
    "r = @spawn heavy_computation(2)\n",
    "fetch(r)\n",
    "\n",
    "r = @spawnat 2 heavy_computation(2)\n",
    "fetch(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Distributed arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fetch(#= In[81]:7 =# @spawnat(2, localpart(y))) = [1, 2]\n",
      "      From worker 3:\tI[1] = 3:4\n",
      "      From worker 2:\tI[1] = 1:2\n",
      "      From worker 5:\tI[1] = 6:6\n",
      "      From worker 4:\tI[1] = 5:5\n",
      "      From worker 7:\tI[1] = 8:8\n",
      "      From worker 6:\tI[1] = 7:7\n",
      "      From worker 9:\tI[1] = 10:10\n",
      "      From worker 8:\tI[1] = 9:9\n",
      "res = [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10-element DArray{Int64,1,Array{Int64,1}}:\n",
       "   1\n",
       "   4\n",
       "   9\n",
       "  16\n",
       "  25\n",
       "  36\n",
       "  49\n",
       "  64\n",
       "  81\n",
       " 100"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@everywhere using DistributedArrays\n",
    "\n",
    "y = distribute([1:10;])\n",
    "\n",
    "\n",
    "# get data from worker 2-5\n",
    "@show fetch(@spawnat 2 localpart(y))\n",
    "\n",
    "\n",
    "function some_complex_work(y::DArray)\n",
    "    return DArray(size(y),procs(y)) do I\n",
    "        @show I[1]        \n",
    "        return localpart(y).^2\n",
    "    end\n",
    "end\n",
    "\n",
    "res = some_complex_work(y)\n",
    "@show res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* work with two distributed arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      From worker 4:\tI = (5:5,)\n",
      "      From worker 2:\tI = (1:2,)\n",
      "      From worker 3:\tI = (3:4,)\n",
      "      From worker 5:\tI = (6:6,)\n",
      "      From worker 9:\tI = (10:10,)\n",
      "      From worker 7:\tI = (8:8,)\n",
      "      From worker 8:\tI = (9:9,)\n",
      "      From worker 6:\tI = (7:7,)\n",
      "res = [5, 20, 45, 80, 125, 180, 245, 320, 405, 500]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10-element DArray{Int64,1,Array{Int64,1}}:\n",
       "   5\n",
       "  20\n",
       "  45\n",
       "  80\n",
       " 125\n",
       " 180\n",
       " 245\n",
       " 320\n",
       " 405\n",
       " 500"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function some_complex_work2(y::DArray, z::DArray)\n",
    "    return DArray(size(y),procs(y)) do I\n",
    "        @show I\n",
    "        localpart(y).^2 + localpart(z).^2\n",
    "    end\n",
    "end\n",
    "\n",
    "z = distribute(2*[1:10;])\n",
    "\n",
    "res = some_complex_work2(y,z)\n",
    "@show res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element DArray{Float64,1,Array{Float64,1}}:\n",
       " -0.9822486727396194\n",
       " -0.21548852186253303\n",
       " -0.8013202743544913\n",
       " -1.3612933462788264\n",
       " -0.8519575644011128\n",
       " -1.3734693004181975\n",
       " -0.34974976239346994\n",
       "  0.9567885862367794\n",
       "  0.9438356072506824\n",
       "  1.219620667344538"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function smoothing(y::DArray)\n",
    "    return DArray(size(y),procs(y)) do I\n",
    "        tmp = zeros(length(I[1])); \n",
    "        for i = I[1]\n",
    "            if i > 1 && i < length(y)\n",
    "                tmp[i - first(I[1]) + 1] = 0.1 * y[i-1] + 0.8 * y[i] + 0.1 * y[i+1]\n",
    "            else\n",
    "                tmp[i - first(I[1]) + 1] = y[i]\n",
    "            end\n",
    "        end\n",
    "        return tmp\n",
    "    end    \n",
    "end\n",
    "\n",
    "x = drandn(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot(x); \n",
    "xs = smoothing(x); plot(xs);\n",
    "xs = smoothing(xs); plot(xs);\n",
    "xs = smoothing(xs); plot(xs);\n",
    "xs = smoothing(xs); plot(xs);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Julia with SLURM (e.g. nic4,...)\n",
    "\n",
    "* Use the package [ClusterManager](https://github.com/JuliaParallel/ClusterManagers.jl) for parallel processing\n",
    "* Do not use the option `--machinefile` as it bypasses SLURM.\n",
    "* A full example would be (`submit_julia.sh`):\n",
    "\n",
    "```bash\n",
    "#!/bin/bash\n",
    "#SBATCH --job-name=julia\n",
    "#SBATCH --output=output-%N-%j.out\n",
    "#SBATCH --cpus-per-task=1\n",
    "\n",
    "export script=\"$1\"\n",
    "echo Julia script $script\n",
    "\n",
    "bt0=$(date +%s)\n",
    "\n",
    "julia <<EOF\n",
    "using ClusterManagers\n",
    "addprocs(SlurmManager($SLURM_NTASKS))\n",
    "\n",
    "# Test the connection\n",
    "hosts = []\n",
    "for i in workers()\n",
    "    host, pid = fetch(@spawnat i (gethostname(), getpid()))\n",
    "    push!(hosts, host)\n",
    "end\n",
    "\n",
    "@show hosts\n",
    "\n",
    "# Run the script\n",
    "include(\"$script\")\n",
    "\n",
    "# The Slurm resource allocation is released when all the workers have\n",
    "# exited\n",
    "for i in workers()\n",
    "    rmprocs(i)\n",
    "end\n",
    "EOF\n",
    "\n",
    "bt1=$(date +%s)\n",
    "\n",
    "awk  \" BEGIN { print \\\"Run time (hours): \\\",($bt1 - $bt0)/3600 } \"\n",
    "```\n",
    "\n",
    "* The script can be used as:\n",
    "\n",
    "```bash\n",
    "sbatch --ntasks=2 --time=20:00:00 --mem-per-cpu=3000 --job-name=myjob submit_julia.sh /path/to/julia/script.jl\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Other nice features of Julia\n",
    "\n",
    "* good document of the Julia language: http://docs.julialang.org/en/stable/\n",
    "* find documentation from the julia REPL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statistics.cor\n"
     ]
    }
   ],
   "source": [
    "apropos(\"Pearson\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22m \u001b[0m\u001b[1mC\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22me a\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22mr Ve\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mO\u001b[22m\u001b[0m\u001b[1mr\u001b[22mMat Ve\u001b[0m\u001b[1mc\u001b[22mt\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22m fa\u001b[0m\u001b[1mc\u001b[22mt\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22mial fa\u001b[0m\u001b[1mc\u001b[22mt\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22mize Fa\u001b[0m\u001b[1mc\u001b[22mt\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mr\u001b[22mization\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "cor(x::AbstractVector)\n",
       "\\end{verbatim}\n",
       "Return the number one.\n",
       "\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "cor(X::AbstractMatrix; dims::Int=1)\n",
       "\\end{verbatim}\n",
       "Compute the Pearson correlation matrix of the matrix \\texttt{X} along the dimension \\texttt{dims}.\n",
       "\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "cor(x::AbstractVector, y::AbstractVector)\n",
       "\\end{verbatim}\n",
       "Compute the Pearson correlation between the vectors \\texttt{x} and \\texttt{y}.\n",
       "\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "cor(X::AbstractVecOrMat, Y::AbstractVecOrMat; dims=1)\n",
       "\\end{verbatim}\n",
       "Compute the Pearson correlation between the vectors or matrices \\texttt{X} and \\texttt{Y} along the dimension \\texttt{dims}.\n",
       "\n"
      ],
      "text/markdown": [
       "```\n",
       "cor(x::AbstractVector)\n",
       "```\n",
       "\n",
       "Return the number one.\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "cor(X::AbstractMatrix; dims::Int=1)\n",
       "```\n",
       "\n",
       "Compute the Pearson correlation matrix of the matrix `X` along the dimension `dims`.\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "cor(x::AbstractVector, y::AbstractVector)\n",
       "```\n",
       "\n",
       "Compute the Pearson correlation between the vectors `x` and `y`.\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "cor(X::AbstractVecOrMat, Y::AbstractVecOrMat; dims=1)\n",
       "```\n",
       "\n",
       "Compute the Pearson correlation between the vectors or matrices `X` and `Y` along the dimension `dims`.\n"
      ],
      "text/plain": [
       "\u001b[36m  cor(x::AbstractVector)\u001b[39m\n",
       "\n",
       "  Return the number one.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  cor(X::AbstractMatrix; dims::Int=1)\u001b[39m\n",
       "\n",
       "  Compute the Pearson correlation matrix of the matrix \u001b[36mX\u001b[39m along the dimension\n",
       "  \u001b[36mdims\u001b[39m.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  cor(x::AbstractVector, y::AbstractVector)\u001b[39m\n",
       "\n",
       "  Compute the Pearson correlation between the vectors \u001b[36mx\u001b[39m and \u001b[36my\u001b[39m.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  cor(X::AbstractVecOrMat, Y::AbstractVecOrMat; dims=1)\u001b[39m\n",
       "\n",
       "  Compute the Pearson correlation between the vectors or matrices \u001b[36mX\u001b[39m and \u001b[36mY\u001b[39m\n",
       "  along the dimension \u001b[36mdims\u001b[39m."
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?cor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* get all field names of a type (introspection)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(:m, :n, :colptr, :rowval, :nzval)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using SparseArrays\n",
    "S = sparse([1,2],[1,2],[2,3]);\n",
    "fieldnames(typeof(S))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Most of julia (the programming environement) is written in julia (the language). It is easy to find out where functions or operators are defined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "sparse(I, J, V::<b>AbstractArray{T,1} where T</b>) in SparseArrays at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/SparseArrays/src/sparsematrix.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/SparseArrays/src/sparsematrix.jl:888</a>"
      ],
      "text/plain": [
       "sparse(I, J, V::AbstractArray{T,1} where T) in SparseArrays at /opt/julia-1.7.0/share/julia/stdlib/v1.5/SparseArrays/src/sparsematrix.jl:888"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@which sparse([1,2],[1,2],[2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* List all functions with a given name (but operating on a different type)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "# 21 methods for generic function <b>diag</b>:<ul><li> diag(B::<b>BitArray{2}</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/bitarray.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/bitarray.jl:79</a></li> <li> diag(M::<b>SymTridiagonal{var\"#s828\",V} where V<:AbstractArray{var\"#s828\",1} where var\"#s828\"<:Number</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:173</a></li> <li> diag(M::<b>SymTridiagonal{var\"#s827\",V} where V<:AbstractArray{var\"#s827\",1} where var\"#s827\"<:Number</b>, n::<b>Integer</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:173</a></li> <li> diag(M::<b>SymTridiagonal</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:188</a></li> <li> diag(M::<b>SymTridiagonal</b>, n::<b>Integer</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:188</a></li> <li> diag(M::<b>Tridiagonal{T,V} where V<:AbstractArray{T,1}</b>)<i> where T</i> in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:611</a></li> <li> diag(M::<b>Tridiagonal{T,V} where V<:AbstractArray{T,1}</b>, n::<b>Integer</b>)<i> where T</i> in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:611</a></li> <li> diag(A::<b>LowerTriangular</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl:425</a></li> <li> diag(A::<b>UnitLowerTriangular</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl:426</a></li> <li> diag(A::<b>UpperTriangular</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl:427</a></li> <li> diag(A::<b>UnitUpperTriangular</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl:428</a></li> <li> diag(D::<b>Diagonal</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/diagonal.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/diagonal.jl:550</a></li> <li> diag(D::<b>Diagonal</b>, k::<b>Integer</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/diagonal.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/diagonal.jl:550</a></li> <li> diag(M::<b>Bidiagonal</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/bidiag.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/bidiag.jl:332</a></li> <li> diag(M::<b>Bidiagonal</b>, n::<b>Integer</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/bidiag.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/bidiag.jl:332</a></li> <li> diag(A::<b>SparseArrays.AbstractSparseMatrixCSC{Tv,Ti}</b>)<i> where {Tv, Ti}</i> in SparseArrays at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/SparseArrays/src/sparsematrix.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/SparseArrays/src/sparsematrix.jl:3510</a></li> <li> diag(A::<b>SparseArrays.AbstractSparseMatrixCSC{Tv,Ti}</b>, d::<b>Integer</b>)<i> where {Tv, Ti}</i> in SparseArrays at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/SparseArrays/src/sparsematrix.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/SparseArrays/src/sparsematrix.jl:3510</a></li> <li> diag(A::<b>AbstractArray{T,1} where T</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/generic.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/generic.jl:425</a></li> <li> diag(A::<b>AbstractArray{T,2} where T</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/dense.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/dense.jl:246</a></li> <li> diag(A::<b>AbstractArray{T,2} where T</b>, k::<b>Integer</b>) in LinearAlgebra at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/LinearAlgebra/src/dense.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/dense.jl:246</a></li> <li> diag(F::<b>SuiteSparse.CHOLMOD.Factor{Tv}</b>)<i> where Tv</i> in SuiteSparse.CHOLMOD at <a href=\"file:///buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.5/SuiteSparse/src/cholmod.jl\" target=\"_blank\">/opt/julia-1.7.0/share/julia/stdlib/v1.5/SuiteSparse/src/cholmod.jl:1766</a></li> </ul>"
      ],
      "text/plain": [
       "# 21 methods for generic function \"diag\":\n",
       "[1] diag(B::BitArray{2}) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/bitarray.jl:79\n",
       "[2] diag(M::SymTridiagonal{var\"#s828\",V} where V<:AbstractArray{var\"#s828\",1} where var\"#s828\"<:Number) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:173\n",
       "[3] diag(M::SymTridiagonal{var\"#s827\",V} where V<:AbstractArray{var\"#s827\",1} where var\"#s827\"<:Number, n::Integer) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:173\n",
       "[4] diag(M::SymTridiagonal) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:188\n",
       "[5] diag(M::SymTridiagonal, n::Integer) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:188\n",
       "[6] diag(M::Tridiagonal{T,V} where V<:AbstractArray{T,1}) where T in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:611\n",
       "[7] diag(M::Tridiagonal{T,V} where V<:AbstractArray{T,1}, n::Integer) where T in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/tridiag.jl:611\n",
       "[8] diag(A::LowerTriangular) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl:425\n",
       "[9] diag(A::UnitLowerTriangular) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl:426\n",
       "[10] diag(A::UpperTriangular) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl:427\n",
       "[11] diag(A::UnitUpperTriangular) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/triangular.jl:428\n",
       "[12] diag(D::Diagonal) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/diagonal.jl:550\n",
       "[13] diag(D::Diagonal, k::Integer) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/diagonal.jl:550\n",
       "[14] diag(M::Bidiagonal) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/bidiag.jl:332\n",
       "[15] diag(M::Bidiagonal, n::Integer) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/bidiag.jl:332\n",
       "[16] diag(A::SparseArrays.AbstractSparseMatrixCSC{Tv,Ti}) where {Tv, Ti} in SparseArrays at /opt/julia-1.7.0/share/julia/stdlib/v1.5/SparseArrays/src/sparsematrix.jl:3510\n",
       "[17] diag(A::SparseArrays.AbstractSparseMatrixCSC{Tv,Ti}, d::Integer) where {Tv, Ti} in SparseArrays at /opt/julia-1.7.0/share/julia/stdlib/v1.5/SparseArrays/src/sparsematrix.jl:3510\n",
       "[18] diag(A::AbstractArray{T,1} where T) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/generic.jl:425\n",
       "[19] diag(A::AbstractArray{T,2} where T) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/dense.jl:246\n",
       "[20] diag(A::AbstractArray{T,2} where T, k::Integer) in LinearAlgebra at /opt/julia-1.7.0/share/julia/stdlib/v1.5/LinearAlgebra/src/dense.jl:246\n",
       "[21] diag(F::SuiteSparse.CHOLMOD.Factor{Tv}) where Tv in SuiteSparse.CHOLMOD at /opt/julia-1.7.0/share/julia/stdlib/v1.5/SuiteSparse/src/cholmod.jl:1766"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using LinearAlgebra\n",
    "methods(diag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* integrated package manager\n",
    "\n",
    "```julia\n",
    "Pkg.add(\"DataAssim\")\n",
    "```\n",
    "\n",
    "* Have a look at: http://pkg.julialang.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Easy to write documentation in markdown\n",
    "* Support for jupyter\n",
    "* Easy to use with github, travis-ci, codecov.io\n",
    "* Support of macros (function that can transform your code)\n",
    "* Numerous constructs to avoid copying data\n",
    "  * pass argument by reference instead of by value\n",
    "  * `reshape` gives a different view on the data\n",
    "  * `SubArray` ` \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A = [1 2 3; 4 5 6]\n",
      "b = [1, 4]\n",
      "A = [100 2 3; 4 5 6]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2×3 Array{Int64,2}:\n",
       " 100  2  3\n",
       "   4  5  6"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [1 2 3; 4 5 6];\n",
    "@show A\n",
    "b = view(A,:,1)\n",
    "@show b\n",
    "b[1] = 100\n",
    "@show A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6-element Array{Float64,1}:\n",
       " 0.0\n",
       " 0.5877852522924731\n",
       " 0.9510565162951535\n",
       " 0.9510565162951536\n",
       " 0.5877852522924732\n",
       " 1.2246467991473532e-16"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [sin(π * x) for x = 0:0.2:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6×6 Array{Float64,2}:\n",
       " 0.0  0.0          0.0          0.0          0.0          0.0\n",
       " 0.0  0.345492     0.559017     0.559017     0.345492     7.19829e-17\n",
       " 0.0  0.559017     0.904508     0.904508     0.559017     1.16471e-16\n",
       " 0.0  0.559017     0.904508     0.904508     0.559017     1.16471e-16\n",
       " 0.0  0.345492     0.559017     0.559017     0.345492     7.19829e-17\n",
       " 0.0  7.19829e-17  1.16471e-16  1.16471e-16  7.19829e-17  1.49976e-32"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [sin(π * x) * sin(π * y) for x = 0:0.2:1, y = 0:0.2:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* do you like shell pipes? (in DIVA 1081 shell pipes for 154 scripts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "54"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1:5;]  |> x->x.^2 |> x-> x[x .> 2] |> sum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Support for GPU programming with GPUArray.jl, CuArray.jl and CUDAnative.jl\n",
    "* Interesting read: [A Journey Through Julia: A dynamic and fast language](http://hdl.handle.net/2268/203491) from Thibaut Cuvelier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Caveats\n",
    "\n",
    "* Plotting data with missing values is/was not as straight-foreward as in Matlab/Octave. Now PyPlot ignored NaNs as in Matlab/Octave\n",
    "* It takes some time to compile/recompile modules  (which can be a bit annoying in interactive use)\n",
    "* Still a young language\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Julia 1.7.2",
   "language": "julia",
   "name": "julia-1.7"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}