Week1_7-Variables.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\n",
       "\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: #ddd;\n",
       "    color: #000000;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Philosopher', sans-serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 2.2em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(0, 80, 120);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    font-weight: 400;\n",
       "    font-size: 1.9em;\n",
       "    line-height: 100%;\n",
       "    color: rgb(200,100,0);\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\t\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "    margin-top:12px;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: italic;\n",
       "    color: rgb(94,127,192);\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {\n",
       "    font-family: 'Philosopher', serif;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {\n",
       "    font-family: 'Alegreya Sans', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 16pt;\n",
       "    color: grey;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .1em;\n",
       "    margin-top: 0.1em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 {\n",
       "    font-family: 'PT Mono', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 10pt;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: \"PT Mono\";\n",
       "        font-size: 100%;\n",
       "}\n",
       "\n",
       "</style>\n",
       "\n"
      ],
      "text/plain": [
       "HTML{ASCIIString}(\"<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\\n<link href='http://fonts.googleapis.com/css?family=Philosopher:400,700,400italic,700italic' rel='stylesheet' type='text/css'>\\n\\n<style>\\n\\n@font-face {\\n    font-family: \\\"Computer Modern\\\";\\n    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\\n}\\n\\n#notebook_panel { /* main background */\\n    background: #ddd;\\n    color: #000000;\\n}\\n\\n\\n\\n/* Formatting for header cells */\\n.text_cell_render h1 {\\n    font-family: 'Philosopher', sans-serif;\\n    font-weight: 400;\\n    font-size: 2.2em;\\n    line-height: 100%;\\n    color: rgb(0, 80, 120);\\n    margin-bottom: 0.1em;\\n    margin-top: 0.1em;\\n    display: block;\\n}\\t\\n.text_cell_render h2 {\\n    font-family: 'Philosopher', serif;\\n    font-weight: 400;\\n    font-size: 1.9em;\\n    line-height: 100%;\\n    color: rgb(200,100,0);\\n    margin-bottom: 0.1em;\\n    margin-top: 0.1em;\\n    display: block;\\n}\\t\\n\\n.text_cell_render h3 {\\n    font-family: 'Philosopher', serif;\\n    margin-top:12px;\\n    margin-bottom: 3px;\\n    font-style: italic;\\n    color: rgb(94,127,192);\\n}\\n\\n.text_cell_render h4 {\\n    font-family: 'Philosopher', serif;\\n}\\n\\n.text_cell_render h5 {\\n    font-family: 'Alegreya Sans', sans-serif;\\n    font-weight: 300;\\n    font-size: 16pt;\\n    color: grey;\\n    font-style: italic;\\n    margin-bottom: .1em;\\n    margin-top: 0.1em;\\n    display: block;\\n}\\n\\n.text_cell_render h6 {\\n    font-family: 'PT Mono', sans-serif;\\n    font-weight: 300;\\n    font-size: 10pt;\\n    color: grey;\\n    margin-bottom: 1px;\\n    margin-top: 1px;\\n}\\n\\n.CodeMirror{\\n        font-family: \\\"PT Mono\\\";\\n        font-size: 100%;\\n}\\n\\n</style>\\n\\n\")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Setting up a custom stylesheet in IJulia\n",
    "file = open(\"style.css\") # A .css file in the same folder as this notebook file\n",
    "styl = readall(file) # Read the file\n",
    "HTML(\"$styl\") # Output as HTML"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables in Julia have a name, a value and a type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<h2>In this lecture</h2>\n",
    "\n",
    "- [Outcome](#Outcome)\n",
    "- [Array types](#Array-types)\n",
    "- [Assignment: how variables get their values](#Assignment:-how-variables-get-their-values)\n",
    "- [Valid variable names in Julia](#Valid-variable-names-in-Julia)\n",
    "- [The three parts of a Julia variable](#The-three-parts-of-a-Julia-variable)\n",
    "- [Example of a variable created with abstract type](#Example-of-a-variable-created-with-abstract-type)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<h2>Outcome</h2>\n",
    "\n",
    "After this lecture, you will be able to: \n",
    "\n",
    "- Describe Array types and say how to create values using Array()\n",
    "- Say how to access values in an array\n",
    "- Say how a variable gets a value in Julia\n",
    "- Say exactly how a variable in Julia is structured\n",
    "- Determine the type of a variable in Julia\n",
    "- Say why variables (unlike values) can have abstract types\n",
    "- Use brackets to access an element of an array\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Array types</h2>\n",
    "\n",
    "Julia has excellent support for arrays, on par with Matlab.\n",
    "\n",
    "Multidimensional arrays are easy to create in Julia. For example, Array(Int64, 3) creates a 3 x 1 array of integers:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Int64,1}:\n",
       " 4600236944\n",
       " 4659495376\n",
       " 4659560176"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Array(Int64, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of the array is Array{Int64, 1}. Note the use of braces here. \n",
    "\n",
    "Also note that the type is has a 1 where the creation has a 3. They refer to completely different things! In the statement Array(Int64, 3), the 3 is the number of elements in the first dimension. Since this is the only dimension, we end up with a one-dimensional array. The type is Array{Int64, 1}. The 1 specifies that it is a one-dimensional array; the Int64 specifies that each element of the array has type Int64."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Assignment: how variables get their values</h2>\n",
    "\n",
    "The assignment operator is ="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello, world!\""
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greeting = \"Hello, world!\"  # creates a variable called \"greeting\" whose value is a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "println(greeting)          # println uses the value of greeting when it prints the message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be very careful to use \"=\" when you want do assignments and \"==\" when you want to do comparisons. The similarity of these operators is an unfortunate heritage from many older programming languages. You just have to work on not using the one where the other is intended.\n",
    "\n",
    "And no matter how careful you are, some mistakes will occur. The possible errors because of \"=\" for \"==\" is one of the most prolific sources of bugs.\n",
    "\n",
    "### That's it!\n",
    "\n",
    "That's how variables get values in Julia: they are assigned using =.\n",
    "\n",
    "To be exact, the *value* of the expression on the right of \"=\" is bound to the name on the left. It is useful to remember that one could read \"a = 5\" as \"a takes the value 5\". Similarly, \"a = b\" can be read as \"a takes the value of b\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Valid variable names in Julia</h2>\n",
    "\n",
    "A variable name can be almost any string that starts with a letter and continues with letters, numbers or a few other characters.\n",
    "\n",
    "Note that here, letters include many Unicode characters. You could name all your variables using Mandarin, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Float64,1}:\n",
       " 20.0  \n",
       " 11.111"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "人 = 20\n",
    "生 = 11.111\n",
    "[人, 生]           # another way to make a 1-dimensional array: comma-separated list inside brackets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The initial character may also be an underscore (as can later ones):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"short string\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_this_is_my_idea_of_a_long_variable_name_ = \"short string\"  # community standard is NOT to use underscores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"wake-up call\""
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "very_important!pay_attention = \"wake-up call\"       # again, this example violates Julia community standard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "User-defined variables should avoid capital letters. This is the community standard, it is not absolutely obligatory, but is widely observed. Here's why\n",
    "\n",
    "*oficial Julia code reserves initial capitals for two uses: type names and module names.* \n",
    "\n",
    "User-defined types and modules (we don't discuss modules on this course) do usually have initial capitals, and sometimes also internal capitals (so-called camel type). The community standard on camel type is also to reserve it for the names of types and modules.\n",
    "\n",
    "Likewise, a final \"!\" on a function name, by general agreement, is reserved for those functions that modify their arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>The three parts of a Julia variable</h2>\n",
    "\n",
    "A Julia variable has name and a value. The assignment operator binds the name to the value.\n",
    "\n",
    "But there is a third item: the type. As noted in the lecture on types, in Julia only values have types. So what does it mean to say that a variable has a type?\n",
    "\n",
    "Well, if the variable has a definite value, then the type of the variable is the type of its value.\n",
    "\n",
    "But it is often the case that one refers to a variable only by its name. In that case its value is not known. It may even be that the variable has not yet been created (or, what it the same, loaded). For instance, consider the command \"println(greeting)\" we used above. The function println() was been written without knowing the type of the variable \"greeting\".\n",
    "\n",
    "When a variable is known only by its name, it is given the abstract type Any, which is the most abstract type in Julia. That means it has no supertype, only subtypes. It is often useful to use a more restricted but still abstract subtype like Integer or AbstractString, but we will not go into the details of that in this course.\n",
    "\n",
    "A variable with an abstract type can do quite a lot of things without actually being given a value that has a concrete type (see below for a simple example).\n",
    "\n",
    "A variable with abstract type must be given a value before it is used in a computation, otherwise Julia throws an error (see below).\n",
    "\n",
    "It is therefore slightly wrong to say that a variable has a type. It is the value of the variable that has a type. It's just that while a variable waits to have a particular value and hence a concrete type, it can useful to have in hand a limited set of possible types it can have. For that we use abstract types.\n",
    "\n",
    "Another slightly wrong way to say all this is the following: a variable may have abstract type only while it waits for its value to be assigned.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Example of a variable created with abstract type</h2>\n",
    "\n",
    "As noted above, a variable may have abstract type. Since it is not obvious how to create a variable with abstract type, I give an example here, using Array(...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Back to the top](#In-this-lecture)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2x3 Array{Integer,2}:\n",
       " #undef  #undef  #undef\n",
       " #undef  #undef  #undef"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable = Array(Integer, 2,3) # A two-dimensional array with 2 rows and 3 columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the value of abstypevariable is now an array where the elements are of type Integer, which is an abstract type. \n",
    "\n",
    "But note that there are actually no values in here---the elements of the array remain undefined. So this is a variable still waiting to get its values. In a sense it has only be been half-created.\n",
    "\n",
    "I illustrate this by attempting to access an element of the array.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: UndefRefError: access to undefined reference\nwhile loading In[16], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: UndefRefError: access to undefined reference\nwhile loading In[16], in expression starting on line 1",
      "",
      " in getindex at array.jl:283"
     ]
    }
   ],
   "source": [
    "abstypevariable[2,1]    #NB --- note the brackets, that's how to access elements of an array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously, attempting to access a value that does not exist must be an error.\n",
    "\n",
    "However, you can assign a value to a single element. For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable[1,1] = 1    # Int64 is a subtype of Integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that abstypevariable is still abstract, even if it contains an element of definite type\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2x3 Array{Integer,2}:\n",
       "   1     #undef  #undef\n",
       " #undef  #undef  #undef"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia will convert values that are assigned if it can:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable[1,2] = 5.0  # given value is of type Float64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2x3 Array{Integer,2}:\n",
       "   1       5     #undef\n",
       " #undef  #undef  #undef"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstypevariable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So although 5.0 was given to abstypevariable as a value, what Julia actually put there was a value converted to a subtype of Integer. Julia will do such conversions whenever it can, in order to keep your program running. But if it has to do lots of conversions, your code will be running slower than it can---the fastest code *never* has to do any conversions.\n",
    "\n",
    "By the way, if you attempt to assign a value that cannot be converted, Julia throws an error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "LoadError: MethodError: `convert` has no method matching convert(::Type{Integer}, ::ASCIIString)\nThis may have arisen from a call to the constructor Integer(...),\nsince type constructors fall back to convert methods.\nClosest candidates are:\n  call{T}(::Type{T}, ::Any)\n  convert(::Type{Integer}, !Matched::Integer)\n  convert{T<:Integer}(::Type{T<:Integer}, !Matched::Rational{T<:Integer})\n  ...\nwhile loading In[21], in expression starting on line 1",
     "output_type": "error",
     "traceback": [
      "LoadError: MethodError: `convert` has no method matching convert(::Type{Integer}, ::ASCIIString)\nThis may have arisen from a call to the constructor Integer(...),\nsince type constructors fall back to convert methods.\nClosest candidates are:\n  call{T}(::Type{T}, ::Any)\n  convert(::Type{Integer}, !Matched::Integer)\n  convert{T<:Integer}(::Type{T<:Integer}, !Matched::Rational{T<:Integer})\n  ...\nwhile loading In[21], in expression starting on line 1",
      "",
      " in setindex! at array.jl:314"
     ]
    }
   ],
   "source": [
    "abstypevariable[2,2] = \"stringystringstr\"  # strings cannot be converted to any Integer type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, and this is often a good idea, you can create a variable with unknown but concrete values, for example by by replacing type Integer above with type Int64. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2x3 Array{Int64,2}:\n",
       " 8589934594  0  4589574624\n",
       " 2147483649  0  4589574624"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arbconcretevariable = Array(Int64, 2,3)  # no actual value specified, \n",
    "#                                             ... so Julia assigns arbitrary values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## YOU CAN ALMOST ALWAYS IGNORE TYPES WHEN YOU WRITE JULIA CODE\n",
    "\n",
    "One of the nicest things about Julia is that, while its type system is totally amazing, you can ignore it if you like. People often do---you write code as rapidly as you can, to see whether an idea could possibly work. Then if you like what you see, but the code runs slowly, you tweak it. And in Julia, this means you work on getting the types right, and thereby avoiding type conversion.\n",
    "\n",
    "There is one case however where type cannot be ignored: when you get an error message that complains about type. That is, for purposes of debugging it is essential to know about Julia's type system, and that is why we include it this early in the course, even though you need never specify type in any of the assignments in this course."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.4.5",
   "language": "julia",
   "name": "julia-0.4"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.4.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}