{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# An IJulia Preview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "This notebook is a preview demo of **IJulia**: a [Julia-language](http://julialang.org/) backend combined with the [IPython](http://ipython.org/) interactive environment.   This combination allows you to interact with the Julia language using IPython's powerful [graphical notebook](http://ipython.org/notebook.html), which combines code, formatted text, math, and multimedia in a single document.\n",
    "\n",
    "* Note: this is a *preview*, because it relies on pre-release bleeding-edge versions of Julia, IPython, and several Julia packages, as explained on the [IJulia github page](https://github.com/JuliaLang/IJulia.jl), and functionality is evolving rapidly.  We hope to have a more polished release soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Basic Julia interaction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Basic mathematical expressions work like you expect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(::#1) (generic function with 1 method)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function f(x)\n",
    "    y = x.^2;\n",
    "    return y;\n",
    "end\n",
    "g = x -> x.^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " 0.0  0.0  0.0\n",
       " 0.0  0.0  0.0\n",
       " 0.0  0.0  0.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = randn(3,3);\n",
    "f(a) - g(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9-element Array{Float64,1}:\n",
       " -0.26112 \n",
       " -1.22173 \n",
       "  0.337164\n",
       " -1.41072 \n",
       " -0.368395\n",
       " -0.472308\n",
       "  0.411427\n",
       " -1.60946 \n",
       " -0.137196"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "You can define variables, write loops, and execute arbitrary multiline code blocks.  Here is an example of an alternating harmonic series $\\sum_{n=1}^\\infty \\frac{(-1)^n}{n}$ from a [Julia tutorial by Homer Reid](http://homerreid.ath.cx/teaching/18.330/JuliaProgramming.shtml#SimplePrograms):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6930971830599458"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 0.0\n",
    "for n = 1:2:10000\n",
    "    s += 1/n - 1/(n+1)\n",
    "end\n",
    "s # an expression on the last line (if it doesn't end with \";\") is printed as \"Out\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Previous outputs can be referred to via `Out[`*n*`]`, following the IPython, for example `Out[2]` for the result above.  You can also use the shorthand `_2`, or `_` for the previous result, as in IPython.  Like in Matlab, `ans` can also be used to refer to the previous result, *even if it was not printed* (when the command ended with `;`).\n",
    "\n",
    "For example, the harmonic series above should be converging (slowly) to $\\ln 2$, and we can check this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Array{Float64,2}:\n",
       " -0.693147  -0.693147  -0.693147\n",
       " -0.693147  -0.693147  -0.693147\n",
       " -0.693147  -0.693147  -0.693147"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Out[2] - log(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Like Matlab or Scipy + Numpy, Julia has lots of mathematical functions and linear algebra built in.  For example, we can define a $500\\times500$ random matrix $R$ and form the positive-definite matrix $R^* R$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "500×500 Array{Float64,2}:\n",
       " 168.059  133.334  126.666  123.144  …  120.416  127.723  127.33   125.626\n",
       " 133.334  184.044  132.761  134.857     125.833  129.424  129.752  132.378\n",
       " 126.666  132.761  169.95   129.903     121.587  129.969  127.314  122.971\n",
       " 123.144  134.857  129.903  165.669     119.301  128.909  123.129  124.133\n",
       " 124.958  125.936  123.389  123.695     116.835  125.323  118.102  122.092\n",
       " 125.606  128.414  125.355  124.912  …  119.155  126.15   123.898  120.259\n",
       " 124.857  132.309  125.604  123.341     121.31   124.498  124.141  125.517\n",
       " 128.086  128.129  129.275  123.25      119.013  129.562  127.62   125.14 \n",
       " 125.69   128.922  124.766  125.233     116.989  126.775  122.935  118.891\n",
       " 125.159  132.154  129.099  124.196     123.894  125.764  128.139  123.698\n",
       " 119.85   122.969  120.29   115.34   …  111.685  121.216  114.546  116.172\n",
       " 126.87   130.163  128.855  122.857     120.912  124.233  131.261  121.85 \n",
       " 124.215  130.578  126.594  121.72      118.905  127.143  121.654  126.218\n",
       "   ⋮                                 ⋱                                    \n",
       " 120.66   125.368  122.156  120.043     117.332  120.012  119.802  116.646\n",
       " 126.796  132.46   129.776  128.485     125.398  129.276  127.685  126.862\n",
       " 122.159  130.874  128.22   126.393  …  120.527  128.136  122.605  121.033\n",
       " 123.365  131.822  130.506  122.329     125.065  125.508  124.734  125.909\n",
       " 131.0    138.952  134.453  128.141     120.92   132.343  129.16   129.136\n",
       " 128.973  134.723  131.885  126.719     120.736  130.56   127.102  131.481\n",
       " 124.728  128.031  124.166  126.616     119.72   127.337  123.918  122.402\n",
       " 126.738  131.95   127.23   125.71   …  120.534  125.969  123.823  124.151\n",
       " 120.416  125.833  121.587  119.301     156.719  124.489  117.08   116.354\n",
       " 127.723  129.424  129.969  128.909     124.489  173.932  122.728  125.867\n",
       " 127.33   129.752  127.314  123.129     117.08   122.728  167.546  126.086\n",
       " 125.626  132.378  122.971  124.133     116.354  125.867  126.086  159.732"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = rand(500,500)\n",
    "R' * R  + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "(Notice that, by default, only a portion of a large matrix is shown.  You didn't really want to read $500^2 = 250,000$ numbers, did you?)\n",
    "\n",
    "Standard output from Julia is also captured and sent to the IJulia notebook as you'd expect:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Börk börk börk, some unicode output on stderr...\n",
      "\n"
     ]
    }
   ],
   "source": [
    "println(\"Hello world!\\n\")\n",
    "println(STDERR, \"Börk börk börk, some unicode output on stderr...\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "IJulia even captures output from external C libraries (and notice how easy it is using Julia's `ccall` intrinsic):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "UndefVarError: Uint8 not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: Uint8 not defined",
      "",
      " in anonymous at ./<missing>:?"
     ]
    }
   ],
   "source": [
    "ccall(:printf, Cint, (Ptr{Uint8},), \"Hello from C!!\\n\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can define functions, of course, and use them in later input cells:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Method definition f(Any) in module Main at In[9]:1 overwritten at In[22]:1.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(x) = x + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6-element Array{Int64,1}:\n",
       " 2\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 6\n",
       " 9"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "println(f(3))\n",
    "f([1,1,2,3,5,8])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Notice that the input above both printed an scalar to `STDOUT` and also returned a vector, the latter using Julia's ability to write polymorphic functions and built-in array operations.\n",
    "\n",
    "On the other hand adding a string to a number is not defined (there is no `+` method defined for those types, although we could easily add one), and attempting to do so will throw an exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching +(::String, ::Int64)\u001b[0m\nClosest candidates are:\n  +(::Any, ::Any, \u001b[1m\u001b[31m::Any\u001b[0m, \u001b[1m\u001b[31m::Any...\u001b[0m) at operators.jl:138\n  +(\u001b[1m\u001b[31m::Complex{Bool}\u001b[0m, ::Real) at complex.jl:151\n  +(\u001b[1m\u001b[31m::Char\u001b[0m, ::Integer) at char.jl:40\n  ...\u001b[0m",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching +(::String, ::Int64)\u001b[0m\nClosest candidates are:\n  +(::Any, ::Any, \u001b[1m\u001b[31m::Any\u001b[0m, \u001b[1m\u001b[31m::Any...\u001b[0m) at operators.jl:138\n  +(\u001b[1m\u001b[31m::Complex{Bool}\u001b[0m, ::Real) at complex.jl:151\n  +(\u001b[1m\u001b[31m::Char\u001b[0m, ::Integer) at char.jl:40\n  ...\u001b[0m",
      "",
      " in f(::String) at ./In[9]:1"
     ]
    }
   ],
   "source": [
    "f(\"Hello?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Julia–Python interoperability: SciPy and Matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Julia can easily and transparently call external Python code using a package called [PyCall](https://github.com/stevengj/PyCall.jl), and to illustrate that capability we will show some examples calling [SciPy](http://www.scipy.org/) and [Matplotlib](http://matplotlib.org/) from Julia.\n",
    "\n",
    "For example, we can use the [Newton solver in scipy.optimize](http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.newton.html) to solve a transcendental equation $\\cos(x) - x = 0$ given a *Julia* function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "PyError (:PyImport_ImportModule) <type 'exceptions.ImportError'>\nImportError('No module named scipy.optimize',)\n",
     "output_type": "error",
     "traceback": [
      "PyError (:PyImport_ImportModule) <type 'exceptions.ImportError'>\nImportError('No module named scipy.optimize',)\n",
      "",
      " in pyerr_check at /Users/gpeyre/.julia/v0.5/PyCall/src/exception.jl:56 [inlined]",
      " in pyerr_check at /Users/gpeyre/.julia/v0.5/PyCall/src/exception.jl:61 [inlined]",
      " in macro expansion at /Users/gpeyre/.julia/v0.5/PyCall/src/exception.jl:81 [inlined]",
      " in pyimport(::String) at /Users/gpeyre/.julia/v0.5/PyCall/src/PyCall.jl:394"
     ]
    }
   ],
   "source": [
    "using PyCall\n",
    "@pyimport scipy.optimize as so\n",
    "so.newton(x -> cos(x) - x, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "We can use the same `@pyimport` syntax to import Matplotlib (specifically, the `matplotlib.pyplot` module), but to integrate Matplotlib's graphics with the IJulia display requires a little more work.  To simplify this, we've created a [PyPlot module](https://github.com/stevengj/PyPlot.jl) for Julia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x328474150>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "PyObject <matplotlib.text.Text object at 0x328599a90>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using PyPlot\n",
    "x = linspace(0,2*pi,1000)\n",
    "y = sin(3*x + 4*cos(2*x))\n",
    "plot(x, y, color=\"red\", linewidth=2.0, linestyle=\"--\")\n",
    "ylabel(\"the y axis\")\n",
    "xlabel(\"the x axis\")\n",
    "title(\"a sinusoidally-modulated sinusoid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "PyError (:PyObject_Call) <type 'exceptions.ValueError'>\nValueError(u\"Only know how to handle extensions: [u'png']; with Pillow installed matplotlib can handle more images\",)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/pyplot.py\", line 2314, in imread\n    return _imread(*args, **kwargs)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/image.py\", line 1282, in imread\n    'more images' % list(six.iterkeys(handlers)))\n",
     "output_type": "error",
     "traceback": [
      "PyError (:PyObject_Call) <type 'exceptions.ValueError'>\nValueError(u\"Only know how to handle extensions: [u'png']; with Pillow installed matplotlib can handle more images\",)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/pyplot.py\", line 2314, in imread\n    return _imread(*args, **kwargs)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/image.py\", line 1282, in imread\n    'more images' % list(six.iterkeys(handlers)))\n",
      "",
      " in pyerr_check at /Users/gpeyre/.julia/v0.5/PyCall/src/exception.jl:56 [inlined]",
      " in pyerr_check at /Users/gpeyre/.julia/v0.5/PyCall/src/exception.jl:61 [inlined]",
      " in macro expansion at /Users/gpeyre/.julia/v0.5/PyCall/src/exception.jl:81 [inlined]",
      " in #_pycall#66(::Array{Any,1}, ::Function, ::PyCall.PyObject, ::String, ::Vararg{String,N}) at /Users/gpeyre/.julia/v0.5/PyCall/src/PyCall.jl:620",
      " in _pycall(::PyCall.PyObject, ::String, ::Vararg{String,N}) at /Users/gpeyre/.julia/v0.5/PyCall/src/PyCall.jl:608",
      " in #pycall#70(::Array{Any,1}, ::Function, ::PyCall.PyObject, ::Type{PyCall.PyAny}, ::String, ::Vararg{String,N}) at /Users/gpeyre/.julia/v0.5/PyCall/src/PyCall.jl:642",
      " in pycall(::PyCall.PyObject, ::Type{PyCall.PyAny}, ::String, ::Vararg{String,N}) at /Users/gpeyre/.julia/v0.5/PyCall/src/PyCall.jl:642",
      " in #imread#65(::Array{Any,1}, ::Function, ::String, ::Vararg{String,N}) at /Users/gpeyre/.julia/v0.5/PyPlot/src/PyPlot.jl:172",
      " in imread(::String, ::Vararg{String,N}) at /Users/gpeyre/.julia/v0.5/PyPlot/src/PyPlot.jl:169"
     ]
    }
   ],
   "source": [
    "g = imread(\"nt_toolbox/data/hibiscus.bmp\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "PyError (:PyObject_Call) <type 'exceptions.TypeError'>\nTypeError(u'Image data can not convert to float',)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/pyplot.py\", line 3157, in imshow\n    **kwargs)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/__init__.py\", line 1898, in inner\n    return func(ax, *args, **kwargs)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/axes/_axes.py\", line 5124, in imshow\n    im.set_data(X)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/image.py\", line 596, in set_data\n    raise TypeError(\"Image data can not convert to float\")\n",
     "output_type": "error",
     "traceback": [
      "PyError (:PyObject_Call) <type 'exceptions.TypeError'>\nTypeError(u'Image data can not convert to float',)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/pyplot.py\", line 3157, in imshow\n    **kwargs)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/__init__.py\", line 1898, in inner\n    return func(ax, *args, **kwargs)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/axes/_axes.py\", line 5124, in imshow\n    im.set_data(X)\n  File \"/Users/gpeyre/.julia/v0.5/Conda/deps/usr/lib/python2.7/site-packages/matplotlib/image.py\", line 596, in set_data\n    raise TypeError(\"Image data can not convert to float\")\n",
      "",
      " in pyerr_check at /Users/gpeyre/.julia/v0.5/PyCall/src/exception.jl:56 [inlined]",
      " in pyerr_check at /Users/gpeyre/.julia/v0.5/PyCall/src/exception.jl:61 [inlined]",
      " in macro expansion at /Users/gpeyre/.julia/v0.5/PyCall/src/exception.jl:81 [inlined]",
      " in #_pycall#66(::Array{Any,1}, ::Function, ::PyCall.PyObject, ::Function, ::Vararg{Function,N}) at /Users/gpeyre/.julia/v0.5/PyCall/src/PyCall.jl:625",
      " in (::PyCall.#kw##_pycall)(::Array{Any,1}, ::PyCall.#_pycall, ::PyCall.PyObject, ::Function, ::Vararg{Function,N}) at ./<missing>:0",
      " in #pycall#70(::Array{Any,1}, ::Function, ::PyCall.PyObject, ::Type{PyCall.PyAny}, ::Function, ::Vararg{Function,N}) at /Users/gpeyre/.julia/v0.5/PyCall/src/PyCall.jl:642",
      " in (::PyCall.#kw##pycall)(::Array{Any,1}, ::PyCall.#pycall, ::PyCall.PyObject, ::Type{PyCall.PyAny}, ::Function, ::Vararg{Function,N}) at ./<missing>:0",
      " in #imshow#67(::Array{Any,1}, ::Function, ::Function, ::Vararg{Function,N}) at /Users/gpeyre/.julia/v0.5/PyPlot/src/PyPlot.jl:172",
      " in (::PyPlot.#kw##imshow)(::Array{Any,1}, ::PyPlot.#imshow, ::Function, ::Vararg{Function,N}) at ./<missing>:0"
     ]
    }
   ],
   "source": [
    "imshow(g, interpolation=\"nearest\")\n",
    "set_cmap(\"gray\")\n",
    "axis(\"off\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching size(::##1#2, ::Int64)\u001b[0m\nClosest candidates are:\n  size{N}(::Any, ::Integer, \u001b[1m\u001b[31m::Integer\u001b[0m, \u001b[1m\u001b[31m::Integer...\u001b[0m) at abstractarray.jl:48\n  size(\u001b[1m\u001b[31m::BitArray{1}\u001b[0m, ::Any) at bitarray.jl:43\n  size(\u001b[1m\u001b[31m::Char\u001b[0m, ::Any) at char.jl:14\n  ...\u001b[0m",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching size(::##1#2, ::Int64)\u001b[0m\nClosest candidates are:\n  size{N}(::Any, ::Integer, \u001b[1m\u001b[31m::Integer\u001b[0m, \u001b[1m\u001b[31m::Integer...\u001b[0m) at abstractarray.jl:48\n  size(\u001b[1m\u001b[31m::BitArray{1}\u001b[0m, ::Any) at bitarray.jl:43\n  size(\u001b[1m\u001b[31m::Char\u001b[0m, ::Any) at char.jl:14\n  ...\u001b[0m",
      "",
      " in imageplot(::Function, ::String, ::Int64, ::Int64, ::Int64) at /Users/gpeyre/Dropbox/github/numerical-tours/julia/nt_toolbox/nt_signal.jl:9 (repeats 2 times)"
     ]
    }
   ],
   "source": [
    "include(\"nt_toolbox/nt_signal.jl\")\n",
    "using nt_signal\n",
    "imageplot(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Notice that, by default, the plots are displayed inline (just as for the `%pylab inline` \"magic\" in IPython).  This kind of multimedia display can be enabled for *any* Julia object, as explained in the next section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Multimedia display in IJulia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Like most programming languages, Julia has a built-in `print(x)` function for outputting an object `x` as text, and you can override the resulting text representation of a user-defined type by overloading Julia's `show` function.  The next version of Julia, however, will extend this to a more general mechanism to display **arbitrary multimedia representations** of objects, as defined by standard [MIME types](https://en.wikipedia.org/wiki/Internet_media_type).   More specifically, the Julia [multimedia I/O API](http://docs.julialang.org/en/latest/stdlib/base/#multimedia-i-o) provides:\n",
    "\n",
    "* A `display(x)` function requests the richest available multimedia display of a Julia object x (with a `text/plain` fallback).\n",
    "* Overloading `writemime` allows one to indicate arbitrary multimedia representations (keyed by standard MIME types) of user-defined types.\n",
    "* Multimedia-capable display backends may be registered by subclassing a generic `Display` type.  IJulia provides one such backend which, thanks to the IPython notebook, is capable of displaying HTML, LaTeX, SVG, PNG, and JPEG media formats.\n",
    "\n",
    "The last two points are critical, because they separate **multimedia export** (which is defined by functions associated with the originating Julia data) from **multimedia display** (defined by backends which know nothing about the source of the data).\n",
    "\n",
    "Precisely these mechanism were used to create the inline PyPlot plots above.   To start with, the simplest thing is to provide the MIME type of the data when you call `display`, which allows you to pass \"raw\" data in the corresponding format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "Hello <b>world</b> in <font color=\"red\">HTML</font>!"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(\"text/html\", \"\"\"Hello <b>world</b> in <font color=\"red\">HTML</font>!\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "However, it will be more common to attach this information to types, so that they display correctly automatically.  For example, let's define a simple `HTML` type in Julia that contains a string and automatically displays as HTML (given an HTML-capable backend such as IJulia):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "UndefVarError: @MIME not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: @MIME not defined",
      ""
     ]
    }
   ],
   "source": [
    "type HTML\n",
    "   s::String\n",
    "end\n",
    "import Base.writemime\n",
    "writemime(io::IO, ::@MIME(\"text/html\"), x::HTML) = print(io, x.s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Here, `writemime` is just a function that writes `x` in the corresponding format (`text/html`) to the I/O stream `io`.  The `@MIME` is a bit of magic to allow Julia's [multiple dispatch](http://en.wikipedia.org/wiki/Multiple_dispatch) to automatically select the correct `writemime` function for a given MIME type (here `\"text/html\"`) and object type (here `HTML`).  We also needed an `import` statement in order to add new methods to an existing function from another module.\n",
    "\n",
    "This `writemime` definition is all that we need to make any object of type `HTML` display automatically as HTML text in IJulia:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HTML(\"<ul> <li> Hello from a bulleted list! </ul>\")"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = HTML(\"<ul> <li> Hello from a bulleted list! </ul>\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HTML(\"<ul> <li> Hello from a bulleted list! </ul>\")"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HTML(\"<ul> <li> Hello from a bulleted list! </ul>\")\n"
     ]
    }
   ],
   "source": [
    "display(x)\n",
    "println(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Once this functionality becomes available in a Julia release, we expect that many Julia modules will provide rich representations of their objects for display in IJulia, and moreover that other backends will appear.  Not only can other backends (such as Tim Holy's [ImageView](https://github.com/timholy/ImageView.jl) package) provide more full-featured display of images etcetera than IJulia's inline graphics, but they can also add support for displaying MIME types not handled by the IPython notebook (such as video or audio)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.5.0",
   "language": "julia",
   "name": "julia-0.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}