2. Arrays and linear algebra.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Arrays and linear algebra\n",
    "\n",
    "## Arrays\n",
    "\n",
    "Arrays are the standard \"container\" objects, representing lists/vectors, matrices and higher order tensors.\n",
    "\n",
    "Arrays can be constructed using the literal syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = [1,2,3] # a vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3x3 Array{Int64,2}:\n",
       " 1  2  3\n",
       " 4  5  6\n",
       " 7  8  9"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = [1 2 3; 4 5 6; 7 8 9] # matrix: note the different separators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: syntax: unexpected comma in matrix expression\nwhile loading In[9], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: syntax: unexpected comma in matrix expression\nwhile loading In[9], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "[1 2 3,]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays are a parametric type with 2 parameters: \n",
    "* the first is the type of the element: this can be either concrete or abstract.\n",
    "* the second is the number of dimensions.\n",
    "\n",
    "The literal syntax will attempt to find a \"common\" type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 1.0\n",
       " 2.0\n",
       " 3.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2.0, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Complex{Float64},1}:\n",
       " 1.0+0.0im\n",
       " 2.0+0.0im\n",
       " 3.0+4.0im"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2.0, 3+4im]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also prefix with the desired type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Any,1}:\n",
       " 1\n",
       " 2\n",
       " 3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Any[1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0-element Array{Float64,1}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Float64[] # useful for constructing empty arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Vector` and `Matrix` are aliases for 1- and 2-dimensional `Array`s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{Float64,1}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector{Float64}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{Float64,2}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix{Float64}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Performance note:** there are performance and memory advantages to using Arrays with a concrete type (e.g. `Array{Float64,1}` vs `Array{AbstractFloat,1}` or `Array{Any,1}`), as the compiler is able to infer the type without looking at each element, and able to store them more efficiently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing\n",
    "Indexing is 1-based (like R and Matlab, not 0-based like Python or C), and via square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = [5,6,7]\n",
    "X[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 5\n",
       " 6\n",
       " 8"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[3] = 8 # replace 3rd element\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrices are stored in column-major order, and can be indexed by either 2 indices (row, column) or 1 index (raw ordering of the storage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = [1 2 3; 4 5 6; 7 8 9]\n",
    "M[2,1] # 2nd row, 1st column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[3] # 3rd element in column-major storage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1x3 Array{Int64,2}:\n",
       " 7  8  9"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[3,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1x2 Array{Int64,2}:\n",
       " 7  8"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M[3,1:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1x4 Array{Int64,2}:\n",
       " 1  2  3  4"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reshape(X,1,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array operations\n",
    "\n",
    "Julia distinguishes between functions that are applied to an Array, and functions that are applied to elements of an array.\n",
    "\n",
    "Operators preceded by a dot (`.`) are applied elementwise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = [1,2,3]; Y = [1,4,2]\n",
    "\n",
    "X == Y # true if and only if all elements are equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element BitArray{1}:\n",
       "  true\n",
       " false\n",
       " false"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X .== Y # compares each element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Same for arithmetic operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 1\n",
       " 8\n",
       " 6"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X .* Y # element-wise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 15\n",
       " 36\n",
       " 57"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M * Y # matrix multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One notable difference to other languages is that `min`/`max` are applied elementwise, and `minimum`/`maximum` are reducing (similar to `+` and `sum`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 2"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(X,Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "minimum(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other methods for constructing arrays\n",
    "\n",
    "* `zeros`/`ones` constructs arrays of zeros/ones\n",
    "* `rand`/`randn` constructs arrays of random U(0,1) or N(0,1) variates\n",
    "* `eye` constructs identity matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Float64,1}:\n",
       " 0.0\n",
       " 0.0\n",
       " 0.0\n",
       " 0.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeros(4) # note difference from matlab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3x4 Array{Float64,2}:\n",
       " 0.590506   0.580763   0.297574  0.451487\n",
       " 0.151956   0.0239065  0.561613  0.991008\n",
       " 0.0933139  0.380463   0.213581  0.740514"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rand(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{BigInt,1}:\n",
       " 1\n",
       " 1\n",
       " 1"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ones(BigInt,3) # optional first argument specifies type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4x4 Array{Float64,2}:\n",
       " 1.0  0.0  0.0  0.0\n",
       " 0.0  1.0  0.0  0.0\n",
       " 0.0  0.0  1.0  0.0\n",
       " 0.0  0.0  0.0  1.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eye(4) # gives matrix, not vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to call `Array` directly, though you may get unexpected results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3x3 Array{Float64,2}:\n",
       " 2.2103e-314  2.2103e-314  2.2103e-314 \n",
       " 2.2103e-314  2.2103e-314  2.2103e-314 \n",
       " 2.2103e-314  2.2103e-314  2.21406e-314"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Array(Float64,3,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Question:**\n",
    "> 1. Why does this happen?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Abstract Arrays and Ranges\n",
    "\n",
    "`Array` is a subtype of `AbstractArray`, which captures all \"array-like\" objects. The simplest example are the `Range` objects:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0:9"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = 0:9 # ranges are specied by start:end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0:0.1:1.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = 0:0.1:1 # optional middle element specifies step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R[3] # like arrays we can index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: indexed assignment not defined for FloatRange{Float64}\nwhile loading In[45], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: indexed assignment not defined for FloatRange{Float64}\nwhile loading In[45], in expression starting on line 1",
      "",
      " in setindex! at abstractarray.jl:595"
     ]
    }
   ],
   "source": [
    "R[4] = 7 # can't reassign values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0:0.3:5.0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2+3*R # can use usual arithmetic operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some other `AbstractArray`s:\n",
    "* `BitArray`: efficient storage of an array of `Bool`s (`true`/`false`)\n",
    "* `SparseMatrixCSC`: sparse matrix stored in \"Compressed Sparse Column\" format\n",
    "* `Diagonal`/`Bidiagonal`/`Tridiagonal`: efficient storage of special matrix types\n",
    "* `UpperTriangular`/`LowerTriangular`: triangular \"mask\" over a matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3x3 UpperTriangular{Float64,Array{Float64,2}}:\n",
       " 1.0  1.0  1.0\n",
       " 0.0  1.0  1.0\n",
       " 0.0  0.0  1.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "UpperTriangular(ones(3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comprehensions\n",
    "\n",
    "Comprehensions provide convenient and efficient ways to construct arrays from iterable objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11-element Array{Float64,1}:\n",
       " 0.0\n",
       " 0.1\n",
       " 0.2\n",
       " 0.3\n",
       " 0.4\n",
       " 0.5\n",
       " 0.6\n",
       " 0.7\n",
       " 0.8\n",
       " 0.9\n",
       " 1.0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in 0:0.1:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Array{Float64,1}:\n",
       " 1.64872\n",
       " 1.13315\n",
       " 1.0    \n",
       " 1.13315\n",
       " 1.64872"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[exp(x^2/2) for x = -1:0.5:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Performance tip**: this is actually much more efficient than the equivalent vectorised operation (`exp((-1:0.5:1).^2./2)`) as it doesn't require allocating any intermediate arrays.\n",
    "\n",
    "Comprehensions over multiple objects give arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5x5 Array{Int64,2}:\n",
       " 2  3  4  5   6\n",
       " 3  4  5  6   7\n",
       " 4  5  6  7   8\n",
       " 5  6  7  8   9\n",
       " 6  7  8  9  10"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i+j for i=1:5, j=1:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Char,1}:\n",
       " 'α'\n",
       " 'β'\n",
       " 'γ'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[c for c in \"αβγ\"] # can be used with any iterable object of known length"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "Tuples are small collections of values, and are created by comma-separated values inside regular parantheses `()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,2)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1,2) # 2-element tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "() # empty tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1,) # 1-element tuple (note the trailing comma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are immutable (you can't modify the values or change their length), but unlike arrays there is no performance penalty for using heterogeneous types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1,2.0,\"aa\")"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (1,2.0,\"aa\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[2] # can be indexed as arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Tuple{Int64,Float64,ASCIIString}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are often used as return types when functions return multiple values. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,4,6)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size(randn(3,4,6)) # returns array dimensions as a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, we can *splat* the values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,4,6)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x,y,z = size(randn(3,4,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Algebra\n",
    "\n",
    "Basic arithmetic operations:\n",
    "* `*` for matrix multiplication\n",
    "* `\\` and `/` for matrix division\n",
    "* `'` is for conjugate transpose (`.'` for non-conjugate version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Float64,1}:\n",
       " -0.38424   \n",
       " -0.00329067\n",
       "  0.107503  \n",
       "  0.0578994 "
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = randn(4,4); x = randn(4)\n",
    "M' \\ x # equivalent to inv(M') * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Standard factorizations are available:\n",
    "* `chol`, `qr`, `svd`, `lu`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\n",
       "7x4 Array{Float64,2}:\n",
       " -0.10389   -0.0136444  -0.652212   -0.15149  \n",
       " -0.663802  -0.365414    0.465703    0.215238 \n",
       " -0.329307  -0.511423   -0.546004    0.0515446\n",
       " -0.263036  -0.178468    0.0741023  -0.477041 \n",
       "  0.269697  -0.369167   -0.0295726   0.0420129\n",
       "  0.128996  -0.204607    0.197195   -0.808984 \n",
       "  0.530628  -0.628278    0.119864    0.210425 ,\n",
       "\n",
       "4x4 Array{Float64,2}:\n",
       " -1.51201  -1.03663   0.684255  -0.335779\n",
       "  0.0      -2.34072  -1.65708    0.312187\n",
       "  0.0       0.0      -2.08033   -1.09168 \n",
       "  0.0       0.0       0.0       -2.42551 )"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = randn(7,4)\n",
    "Q,R = qr(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However you often don't need these.\n",
    "\n",
    "Julia also has `Factorisation` objects: these perform the factorisation, but keep the object stored in a more efficient format (e.g. the Q matrix is stored as Householder reflectors)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Base.LinAlg.QRCompactWY{Float64,Array{Float64,2}}(7x4 Array{Float64,2}:\n",
       " -1.51201   -1.03663    0.684255    -0.335779   \n",
       "  0.60133   -2.34072   -1.65708      0.312187   \n",
       "  0.298315   0.373821  -2.08033     -1.09168    \n",
       "  0.238281   0.129101  -0.0710208   -2.42551    \n",
       " -0.244315   0.274461   0.253793     0.0503209  \n",
       " -0.116856   0.15193    0.00559796   0.589253   \n",
       " -0.480689   0.467752   0.35579     -0.000433283,4x4 Array{Float64,2}:\n",
       " 1.10389  -0.650158   0.565948   0.0125843\n",
       " 0.0       1.35721   -1.36525   -0.578512 \n",
       " 0.0       0.0        1.67214    0.136534 \n",
       " 0.0       0.0        0.0        1.48175  )"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = qrfact(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7x4 Array{Float64,2}:\n",
       " -1.51201   -1.03663    0.684255    -0.335779   \n",
       "  0.60133   -2.34072   -1.65708      0.312187   \n",
       "  0.298315   0.373821  -2.08033     -1.09168    \n",
       "  0.238281   0.129101  -0.0710208   -2.42551    \n",
       " -0.244315   0.274461   0.253793     0.0503209  \n",
       " -0.116856   0.15193    0.00559796   0.589253   \n",
       " -0.480689   0.467752   0.35579     -0.000433283"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F.factors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Float64,1}:\n",
       " -0.518118 \n",
       "  1.03513  \n",
       " -0.0203734\n",
       "  0.378598 "
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F \\ ones(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are particularly useful when\n",
    "* you can exploit the structure of the array: e.g. you know the matrix is symmetric positive definite, so can use `cholfact(M)\\x`\n",
    "* you reuse the same matrix, e.g. perform `qrfact` outside the loop, then reuse the object inside.\n",
    "\n",
    "By convention, methods ending in a ! mutate their arguments: this is particularly useful for large arrays as it can save memory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6x2 Array{Float64,2}:\n",
       " -0.964697   0.385148 \n",
       " -0.689135   0.0278044\n",
       "  0.726723   0.628839 \n",
       "  0.799998   1.19807  \n",
       "  0.751188  -0.543631 \n",
       " -1.11252   -0.142759 "
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y=randn(6,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Base.LinAlg.QRCompactWY{Float64,Array{Float64,2}}(6x2 Array{Float64,2}:\n",
       "  2.09181    0.370581 \n",
       "  0.225465  -1.46918  \n",
       " -0.237763   0.423312 \n",
       " -0.261736   0.80463  \n",
       " -0.245767  -0.361552 \n",
       "  0.363986  -0.0991238,2x2 Array{Float64,2}:\n",
       " 1.46118      0.0490323\n",
       " 2.1754e-314  1.01669  )"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = qrfact!(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6x2 Array{Float64,2}:\n",
       "  2.09181    0.370581 \n",
       "  0.225465  -1.46918  \n",
       " -0.237763   0.423312 \n",
       " -0.261736   0.80463  \n",
       " -0.245767  -0.361552 \n",
       "  0.363986  -0.0991238"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia's linear algebra routines also work for other numeric types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3x3 Array{Rational{Int64},2}:\n",
       " 1//3  3//5  3//1\n",
       " 1//2  3//2  8//7\n",
       " 2//1  9//2  3//8"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = [1//3 3//5 6//2; 1//2 3//2 8//7; 2//1 9//2 3//8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Base.LinAlg.LU{Rational{Int64},Array{Rational{Int64},2}}(3x3 Array{Rational{Int64},2}:\n",
       " 1//3  3//5     3//1 \n",
       " 3//2  3//5   -47//14\n",
       " 6//1  3//2  -705//56,[1,2,3],0)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F = lufact(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Rational{Int64},1}:\n",
       " -393//94\n",
       "    5//2 \n",
       "   14//47"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "F \\ [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.4.1",
   "language": "julia",
   "name": "julia-0.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}