julia_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Julia basics\n",
    "\n",
    "- https://learnxinyminutes.com/docs/julia/\n",
    "\n",
    "### Numeric Types\n",
    "\n",
    "\n",
    "#### Arrays\n",
    "\n",
    "You can define an array by using:\n",
    "\n",
    "- a = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Array{Int64,1}:\n",
       " 1\n",
       " 2\n",
       " 3\n",
       " 4\n",
       " 5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: syntax: incomplete: premature end of input\nwhile loading In[7], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: syntax: incomplete: premature end of input\nwhile loading In[7], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "for k=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = [x for x in 1:1000];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: UndefVarError: a not defined\nwhile loading In[2], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: UndefVarError: a not defined\nwhile loading In[2], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "append!(a,23);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000015"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "append!(a,-123)\n",
    "length(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Generate an array of length 1000000\n",
    "n = 1000000\n",
    "a = [1]\n",
    "\n",
    "# julia arrays start at position 1 \n",
    "for k = 2:n\n",
    "    append!(a,k)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000015"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 480,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 480,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+ (3,3,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 514,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "op (generic function with 1 method)"
      ]
     },
     "execution_count": 514,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function op(x,y)\n",
    "    return x+y\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 515,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first call: 6\n",
      "second call: 9.8"
     ]
    }
   ],
   "source": [
    "print( \"first call: \", op(3,3), \"\\nsecond call: \", op(5.5,4.3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Passing vectors to functions\n",
    "\n",
    "If a function modifies the first argument passed it is a convention to write an exclamation mark\n",
    "at the end of the name of the funcion.\n",
    "\n",
    "For example, let us build a function that modifies the incoming vector and writes 10 at every even position."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 529,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "modificar_posiciones_par! (generic function with 1 method)"
      ]
     },
     "execution_count": 529,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "workspace()\n",
    "function modificar_posiciones_par!(x)\n",
    "    n = length(x)\n",
    "    \n",
    "    for k=1:n\n",
    "        if k%2==0\n",
    "            x[k] = 10\n",
    "        end\n",
    "    end\n",
    "    return x\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 538,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×20 Array{Int64,2}:\n",
       " 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20"
      ]
     },
     "execution_count": 538,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = Vector(1:20);\n",
    "x'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 539,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "modificar_posiciones_par!(x);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 541,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×20 Array{Int64,2}:\n",
       " 1  10  3  10  5  10  7  10  9  10  11  10  13  10  15  10  17  10  19  10"
      ]
     },
     "execution_count": 541,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 542,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "modificar_posiciones_par (generic function with 1 method)"
      ]
     },
     "execution_count": 542,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "workspace()\n",
    "function modificar_posiciones_par(x)\n",
    "    n = length(x)\n",
    "    x_copy = copy(x)\n",
    "    \n",
    "    for k=1:n\n",
    "        if k%2==0\n",
    "            x_copy[k] = 10\n",
    "        end\n",
    "    end\n",
    "    return x_copy\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 543,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×20 Array{Int64,2}:\n",
       " 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20"
      ]
     },
     "execution_count": 543,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = Vector(1:20);\n",
    "x'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 544,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x_modified = modificar_posiciones_par(x);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 545,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×20 Array{Int64,2}:\n",
       " 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20"
      ]
     },
     "execution_count": 545,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 546,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1×20 Array{Int64,2}:\n",
       " 1  10  3  10  5  10  7  10  9  10  11  10  13  10  15  10  17  10  19  10"
      ]
     },
     "execution_count": 546,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_modified'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Defining your own type\n",
    "\n",
    "Types can be thought as boxes containing fields. Every field has a name and it is highly recoomended to have a type as well (but not required)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "workspace()\n",
    "type troll{T}\n",
    "    weight::T\n",
    "    height::T\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "troll{Int64}(3,4)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_troll = troll(3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "troll{Float64}(3.0,4.0)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_troll"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WE can use other types to define a troll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "troll{Float64}(3.0,4.0)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_troll = troll(3., 4.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nevertheless we defined ty type stating that every filed had to be form the same type. Therefore troll(3,4.) will not work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: UndefVarError: troll not defined\nwhile loading In[72], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: UndefVarError: troll not defined\nwhile loading In[72], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "a_troll = troll(3,4.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating inner constructors\n",
    "\n",
    "We can add a function inside a type used to instanciate the type.\n",
    "\n",
    "This function can be used for example in order to..\n",
    "\n",
    "- Put restrictions on the type, such as..\n",
    "     - not allow negative values \n",
    "     - Not allow 'rare' characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "workspace()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type Giant{T}\n",
    "    weight::T\n",
    "    height::T\n",
    "    intelligence::String\n",
    "    \n",
    "    function Giant(w, h, i)\n",
    "        if h<2\n",
    "            throw(ArgumentError(\"Giants are taller\\n\"))\n",
    "        end\n",
    "        return new(w,h,i)\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "0-element Array{Method,1}"
      ],
      "text/plain": [
       "0-element Array{Method,1}"
      ]
     },
     "execution_count": 374,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methodswith(Giant)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that if a constructor is defined inside a type we must explicitly define a way to instanciate new elements for every possible type T."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: MethodError: no method matching Giant{T}(::Float64, ::Float64, ::String)\nClosest candidates are:\n  Giant{T}{T}(::Any) at sysimg.jl:53\nwhile loading In[375], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: MethodError: no method matching Giant{T}(::Float64, ::Float64, ::String)\nClosest candidates are:\n  Giant{T}{T}(::Any) at sysimg.jl:53\nwhile loading In[375], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "Giant(3.,4.,\"low\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us do it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Giant{T}"
      ]
     },
     "execution_count": 376,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Giant{T}(weight::T, height::T, intelligence::String) = Giant{T}(weight, height, intelligence)\n",
    "\n",
    "#Giant{T}(weight::T, height::T) = Giant{T}(weight, height ; intelligence=\"low\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "0-element Array{Method,1}"
      ],
      "text/plain": [
       "0-element Array{Method,1}"
      ]
     },
     "execution_count": 377,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methodswith(Giant)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Giant{Float64}(3.0,4.0,\"low\")"
      ]
     },
     "execution_count": 378,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "giant = Giant(3., 4., \"low\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4.0,3.0,\"low\")"
      ]
     },
     "execution_count": 379,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "giant.height, giant.weight, giant.intelligence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that, sice we have written a restriction on the height of the giant\n",
    "we cannot instanciate giants with less than 2 meter height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Giant{Float64}(3.0,4.0,\"medium\")"
      ]
     },
     "execution_count": 380,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "giant = Giant(3.,4.,\"medium\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4.0,3.0,\"medium\")"
      ]
     },
     "execution_count": 381,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "giant.height, giant.weight, giant.intelligence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 382,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: ArgumentError: Giants are taller\n\nwhile loading In[382], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: ArgumentError: Giants are taller\n\nwhile loading In[382], in expression starting on line 1",
      "",
      " in Type at ./In[373]:8 [inlined]",
      " in Giant{T}(::Float64, ::Float64, ::String) at ./In[376]:1"
     ]
    }
   ],
   "source": [
    "giant = Giant(3.,1.,\"medium\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assigning  a default value to a type \n",
    "\n",
    "By default we might think that Giants are quite stupid and therefore we might be interested into assigning \"stupid\" intelligence as default.\n",
    "\n",
    "Notice that default values in Julia are defined after ```;```\n",
    "\n",
    "This can be specially handly in order to provide default values for types, for example when there could be 'standard values' for some of the fileds inside a type and we do not want to bother the user selecting field values. \n",
    "\n",
    "Using this trick we can allow the user to set values to all the fields the user wants to but at the same time, allow the user **not to** define all possible fields ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "workspace()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Giant{T}"
      ]
     },
     "execution_count": 462,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type Giant{T}\n",
    "    weight::T\n",
    "    height::T\n",
    "    intelligence::String\n",
    "    \n",
    "    function Giant(w, h ; intelligence=\"stupid\")\n",
    "        if h<2\n",
    "            throw(ArgumentError(\"Giants are taller\\n\"))\n",
    "        end\n",
    "        return new(w, h ,  intelligence)\n",
    "    end\n",
    "    \n",
    "end\n",
    "\n",
    "## IMPORTANT TO ADD CONSTRUCTOR FOR EVERY TYPE T !!!!\n",
    "Giant{T}(weight::T, height::T) = Giant{T}(weight, height)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 463,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Giant{Float64}(3.0,5.0,\"stupid\")"
      ]
     },
     "execution_count": 463,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "giant = Giant(3.,5.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 464,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.0,5.0,\"stupid\")"
      ]
     },
     "execution_count": 464,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "giant.weight, giant.height, giant.intelligence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 465,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"smart\""
      ]
     },
     "execution_count": 465,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "giant.intelligence = \"smart\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 466,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.0,5.0,\"smart\")"
      ]
     },
     "execution_count": 466,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "giant.weight, giant.height, giant.intelligence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we cannot pass now a value for the field intelligence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 467,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: MethodError: no method matching Giant{T}(::Float64, ::Float64, ::String)\nClosest candidates are:\n  Giant{T}{T}(::T, ::T; intelligence) at In[462]:16\n  Giant{T}{T}(::Any) at sysimg.jl:53\nwhile loading In[467], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: MethodError: no method matching Giant{T}(::Float64, ::Float64, ::String)\nClosest candidates are:\n  Giant{T}{T}(::T, ::T; intelligence) at In[462]:16\n  Giant{T}{T}(::Any) at sysimg.jl:53\nwhile loading In[467], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "rare_giant = Giant(5.,4.,\"smart\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that we cannot use this definition since we need to specify how to create a Giant  when we pass the intelligence field."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Allowing types to have fields with defeault values\n",
    "\n",
    "https://groups.google.com/forum/#!topic/julia-users/9jM7GIoh7YY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 475,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Giant{T}"
      ]
     },
     "execution_count": 475,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "workspace()\n",
    "\n",
    "type Giant{T}\n",
    "    weight::T\n",
    "    height::T\n",
    "    intelligence::String\n",
    "    \n",
    "    function Giant(w, h ; intelligence=\"stupid\")\n",
    "        if h<2\n",
    "            throw(ArgumentError(\"Giants are taller\\n\"))\n",
    "        end\n",
    "        return new(w, h, intelligence)\n",
    "    end\n",
    "    \n",
    "    function Giant(w, h, intelligence)\n",
    "        if h<2\n",
    "            throw(ArgumentError(\"Giants are taller\\n\"))\n",
    "        end\n",
    "        return new(w, h, intelligence)\n",
    "    end\n",
    "end\n",
    "\n",
    "## IMPORTANT TO ADD CONSTRUCTOR FOR EVERY TYPE T !!!!\n",
    "Giant{T}(weight::T, height::T) = Giant{T}(weight, height)\n",
    "Giant{T}(weight::T, height::T, intelligence::String) = Giant{T}(weight, height, intelligence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 477,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Giant{Float64}(5.0,4.0,\"smart\")"
      ]
     },
     "execution_count": 477,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rare_giant = Giant(5., 4., \"smart\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 478,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Giant{Float64}(3.0,5.0,\"stupid\")"
      ]
     },
     "execution_count": 478,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "giant = Giant(3., 5.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Type man"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The following example is the type man that contains 3 fields, **```heigh```**,**``` weight```** and **```name```**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type man{T}\n",
    "    height::T\n",
    "    weight::T\n",
    "    name::String\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A type can be instanciated by assigning values to its fields, the fields of a type can be checked with the **```fieldnames```** function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "man{Int64}(183,80,\"David\")"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "david = man(183, 80, \"David\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Symbol,1}:\n",
       " :height\n",
       " :weight\n",
       " :name  "
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fieldnames(david)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Notice that **you cannot specify a particular value on a field**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: syntax: \"name=\"Julia\"\" inside type definition is reserved\nwhile loading In[18], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: syntax: \"name=\"Julia\"\" inside type definition is reserved\nwhile loading In[18], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "type girl{T}\n",
    "    height::T\n",
    "    weight::T\n",
    "    name=\"Julia\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nevertheless you can define a type and a (so called) inner constructor which might specify a particular value of the type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type girl2{T}\n",
    "    height::T\n",
    "    weight::T\n",
    "    name::String\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "girl2{Int64}(23,123,\"julia\")"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "girl2(23, 123, \"julia\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataType"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(girl2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "0-element Array{Method,1}"
      ],
      "text/plain": [
       "0-element Array{Method,1}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methodswith(girl2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inner constructor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type girl4{T}\n",
    "    height::T\n",
    "    weight::T\n",
    "    name::String\n",
    "    \n",
    "    function girl4(height, weight, name)\n",
    "        new(23,12,\"lala\")\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: MethodError: no method matching girl4{T}(::Int64, ::Int64, ::String)\nClosest candidates are:\n  girl4{T}{T}(::Any) at sysimg.jl:53\nwhile loading In[54], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: MethodError: no method matching girl4{T}(::Int64, ::Int64, ::String)\nClosest candidates are:\n  girl4{T}{T}(::Any) at sysimg.jl:53\nwhile loading In[54], in expression starting on line 1",
      ""
     ]
    }
   ],
   "source": [
    "girl4(23,123,\"julia\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The importance of declaring code inside functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 15.190851 seconds (380.49 M allocations: 7.160 GB, 4.46% gc time)\n"
     ]
    }
   ],
   "source": [
    "@time begin\n",
    "pos = 0\n",
    "num_steps = 10^4\n",
    "numwalkers = 10^4\n",
    "final_square_positions = Int[]\n",
    "\n",
    "for i in 1:numwalkers\n",
    "    for j in 1:num_steps\n",
    "        pos += ifelse( rand() < 0.5, -1, +1)\n",
    "    end\n",
    "        push!(final_square_positions, pos^2)\n",
    "end\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "fool_function (generic function with 1 method)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function fool_function()\n",
    "    pos = 0\n",
    "    num_steps = 10^4\n",
    "    numwalkers = 10^4\n",
    "    final_square_positions = Int[]\n",
    "\n",
    "    for i in 1:numwalkers\n",
    "        for j in 1:num_steps\n",
    "            pos += ifelse( rand() < 0.5, -1, +1)\n",
    "        end\n",
    "            push!(final_square_positions, pos^2)\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.299746 seconds (18 allocations: 256.859 KB)\n"
     ]
    }
   ],
   "source": [
    "@time fool_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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": 0
}