{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Basic Arithmetic" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This notebook will be used as an introduction to the basic syntax of julia. If you have any experience with Python or Matlab then much of this should seem quite familiar. We will start, as is allways the case, with hello world..." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hello, World\n" ] } ], "source": [ "println(\"Hello, World\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can define variables quickly and easilly just as we would in Python as well as use intuitive basic arithmetic such as +, -, *, / and ^ (Not $**$ as in Python)." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "24, 4.0\n" ] } ], "source": [ "a = 24\n", "b = a/6\n", "println(a, \", \",b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When using the notebook we can also use unicode characters for variable names for example $\\alpha$ by typing \"\\\\alpha\" and TAB completing or using the actual code. Functions are also overloaded to use unicode characters" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "36, 7\n" ] } ], "source": [ "α = 36\n", "β = α ÷ 5\n", "println(α, \", \", β)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You will have noticed that while the above divisions are easilly divisable, using the / method will always result in floating point division, whereas using the unicode character will only do integer division, even if using floating point variables" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also substitute variables into strings using the $ symbol" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "\"This is a string with the number 2 in it\"" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = 2\n", "string = \"This is a string with the number $a in it\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Basic Types" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The precision of a variable will be dependent on your architecture but it can be specified by passing a value to a method (all available under tab completion)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Int64,Float16\n" ] } ], "source": [ "a = 4\n", "b = float16(4)\n", "\n", "println(typeof(a), \",\", typeof(b))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note the type conversion method does not have a capital letter, this is the name of the type." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is also an arbritary precision type than machine precision which can be defined using big()" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "BigInt (constructor with 10 methods)" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = big(4)\n", "typeof(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also define arrays quickly and easilly with no added packages, using different deliiting characters for columns and rows. Spaces indicates column seperation and semicolons indicate row seperation. (NOTE INDEXING IN JULIA STARTS AT 1 NOT 0)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "2x3 Array{Int64,2}:\n", " 1 2 3\n", " 4 5 6" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr1 = [1 2 3; 4 5 6]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see above that the result is an array of type integer (the particular integer type is dependent of the architecture of your machine), and of dimension 2" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false }, "source": [ "Vectors can be defined using comma seperation" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3-element Array{Float64,1}:\n", " 1.0\n", " 2.0\n", " 3.0" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vec1 = [1.,2,3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Which we can see is now a floating point array with dimension 1. Julia automatically detects the best type to use." ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "1x3 Array{Any,2}:\n", " \"Hello\" 2 \"the world\"" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "strangearr = [\"Hello\" 2 \"the world\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Arrays can be sliced as you would expect, however the end of an array is specified with end, not -1 as in python" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "2-element Array{Int64,1}:\n", " 3\n", " 4" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = [1, 2, 3, 4, 5, 6]\n", "subarr1 = arr[3:4]" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "4-element Array{Int64,1}:\n", " 2\n", " 3\n", " 4\n", " 5" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "subarr2 = arr[2:end-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Arrays are dynamic, and can be pushed into using the push!() method or appended with the append!() method. Note that the type of an array is not dynamic and it cannot aquire new members of different types. To do this, define the type of the array using T[1, 2, 3] where T is the desired type (remember that the Any type contains all types)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "7-element Array{Int64,1}:\n", " 1\n", " 2\n", " 3\n", " 4\n", " 5\n", " 6\n", " 1" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "push!(arr, 1)" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "10-element Array{Int64,1}:\n", " 1\n", " 2\n", " 3\n", " 4\n", " 5\n", " 6\n", " 1\n", " 3\n", " 2\n", " 1" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "append!(arr, [3, 2, 1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Operations on arrays are not elementwise in general. Julia uses the matlab convention of prepending operations with a . for elementwise operations. Transposes can be accesed with '" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3-element Array{Int64,1}:\n", " 1\n", " 4\n", " 9" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = [1, 2, 3]\n", "arr .* arr" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "1-element Array{Int64,1}:\n", " 14" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr' * arr" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Remember that unicode chars like \\cdot and \\times both work as a dot and cross product" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Other Useful Types" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Complex and rational numbers are built into Julia and can be accessed using im and //" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Complex{Int64}, Rational{Int64}\n" ] } ], "source": [ "compl = 1 + im\n", "rat = 1//2\n", "println(typeof(compl),\", \",typeof(rat))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Control flow" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "White space in Julia means nothing as opposed to python, therefore loops and ifs require ends" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "i = 0\n", "while i < 5\n", " println(i)\n", " i += 1\n", "end" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "for i in 0:4\n", " println(i)\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that 1:3 is not an array, it is a special type unit range. To use arrays then do as below" ] }, { "cell_type": "code", "execution_count": 56, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0,1,2,3,4]\n", "0\n", "1\n", "2\n", "3\n", "4\n" ] } ], "source": [ "arr = collect(0:4)\n", "println(arr)\n", "for i in arr\n", " println(i)\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If statement are intuitive" ] }, { "cell_type": "code", "execution_count": 57, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] } ], "source": [ "for i in 0:4\n", " if i == 2\n", " println(i)\n", " end\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Functions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Simple functions can be written inline" ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "f (generic function with 1 method)" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f(x) = 1 + 4x" ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "9" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f(2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Julia does not require the multiplication method for this and does not require a return statement. Without a return statement Julia will return the last value that was calculated, of course and explicit return statement can be used" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Longer functions can be defined as below" ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "g (generic function with 1 method)" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function g(a, b)\n", " c = rand() * b\n", " d = c^a\n", "end" ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "0.9841976344864111" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g(2,4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can look at any defined methods or function usind the methods method. Built in functions will provide a link to the definitions" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "1 method for generic function g:" ], "text/plain": [ "# 1 method for generic function \"g\":\n", "g(a,b) at In[60]:2" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "methods(g)" ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "1 method for generic function cross:" ], "text/plain": [ "# 1 method for generic function \"cross\":\n", "cross(a::AbstractArray{T,1},b::AbstractArray{T,1}) at linalg/generic.jl:27" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "methods(cross)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that the cross method has listed types for its parameters, whereas ours does not. This is because our method will take the Any type unless we specify otherwise." ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "1 method for generic function g2:" ], "text/plain": [ "# 1 method for generic function \"g2\":\n", "g2(a::FloatingPoint,b::FloatingPoint) at In[65]:2" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function g2(a::FloatingPoint, b::FloatingPoint)\n", " c = rand() * b\n", " d = c^a\n", "end\n", "\n", "methods(g2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also find methods that take certain types with the methodswith method" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "collapsed": false, "scrolled": true }, "outputs": [ { "data": { "text/html": [ "188-element Array{Method,1}:" ], "text/plain": [ "188-element Array{Method,1}:\n", " repmat(a::AbstractArray{T,1},m::Int64) at abstractarray.jl:987 \n", " repmat(a::Union(AbstractArray{T,1},AbstractArray{T,2}),m::Int64) at abstractarray.jl:973 \n", " repmat(a::Union(AbstractArray{T,1},AbstractArray{T,2}),m::Int64,n::Int64) at abstractarray.jl:973\n", " similar{T}(a::Array{T,1},m::Int64) at array.jl:111 \n", " similar{T}(a::Array{T,2},m::Int64) at array.jl:114 \n", " airyx(k::Int64,z::Complex{Float64}) at special/bessel.jl:93 \n", " set_bigfloat_precision(x::Int64) at mpfr.jl:568 \n", " hash(x::Int64,h::Uint64) at hashing.jl:60 \n", " trailing_zeros(x::Int64) at int.jl:233 \n", " <(x::Int64,y::Int64) at int.jl:247 \n", " <(x::Float64,y::Int64) at float.jl:178 \n", " <(x::Int64,y::Float64) at float.jl:180 \n", " <(x::Float32,y::Int64) at float.jl:183 \n", " ⋮ \n", " oct(x::Char,p::Int64) at intfuncs.jl:261 \n", " oct(x::Integer,p::Int64) at intfuncs.jl:263 \n", " ==(x::Float64,y::Int64) at float.jl:168 \n", " ==(x::Int64,y::Float64) at float.jl:170 \n", " ==(x::Float32,y::Int64) at float.jl:173 \n", " ==(x::Int64,y::Float32) at float.jl:175 \n", " parseint(c::Char,base::Integer,a::Int64) at string.jl:1484 \n", " +(x::Int64,y::Int64) at int.jl:33 \n", " mod2pi(x::Int64) at math.jl:354 \n", " Array{T}(::Type{T},m::Int64) at base.jl:226 \n", " Array{T}(::Type{T},m::Int64,n::Int64) at base.jl:228 \n", " Array{T}(::Type{T},m::Int64,n::Int64,o::Int64) at base.jl:230 " ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "methodswith(Int64)" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "# Files" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Basic input and output is easy, we simply open a stream and we can print to it as we do the stdout" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [], "source": [ "outfile = open(\"outtest.txt\", \"w\")\n", "println(outfile, \"This is a file write\")\n", "close(outfile)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "1-element Array{Union(UTF8String,ASCIIString),1}:\n", " \"This is a file write\\n\"" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "infile = open(\"outtest.txt\", \"r\")\n", "lines = readlines(infile)\n", "close(infile)\n", "lines" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can read and write arrays as data even more easilly" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "201x5 Array{Float64,2}:\n", " 3.5 0.000112128 0.0487974 0.000545818 -0.660368\n", " 3.49 0.000114023 0.0495844 0.000532472 -0.662889\n", " 3.48 0.000116247 0.0500274 0.00054961 -0.66487 \n", " 3.47 0.000118043 0.0507657 0.00054868 -0.667649\n", " 3.46 0.000120362 0.0502661 0.000557468 -0.669491\n", " 3.45 0.000121039 0.0505524 0.000560066 -0.673057\n", " 3.44 0.00012745 0.0510202 0.000558522 -0.675708\n", " 3.43 0.000123557 0.0509297 0.000566048 -0.677931\n", " 3.42 0.000126512 0.0512843 0.000573482 -0.680688\n", " 3.41 0.000127708 0.0513921 0.000570771 -0.683322\n", " 3.4 0.00013223 0.0517467 0.000586531 -0.685907\n", " 3.39 0.000134207 0.0517399 0.000575348 -0.689142\n", " 3.38 0.000133705 0.0518661 0.000580012 -0.691536\n", " ⋮ \n", " 1.61 1.76108e-5 0.978815 0.000271218 -1.92564 \n", " 1.6 1.70064e-5 0.979542 0.000265324 -1.92798 \n", " 1.59 1.62134e-5 0.980373 0.000252414 -1.93068 \n", " 1.58 1.55264e-5 0.981135 0.000244068 -1.93321 \n", " 1.57 1.45818e-5 0.981917 0.000233641 -1.93572 \n", " 1.56 1.45415e-5 0.982631 0.000229931 -1.93813 \n", " 1.55 1.36733e-5 0.983359 0.000221392 -1.94048 \n", " 1.54 1.31531e-5 0.984072 0.000213844 -1.94285 \n", " 1.53 1.29772e-5 0.984638 0.00020845 -1.94486 \n", " 1.52 1.25104e-5 0.985264 0.000201348 -1.94692 \n", " 1.51 1.18011e-5 0.985878 0.000191881 -1.94906 \n", " 1.5 1.11283e-5 0.986592 0.000182427 -1.95141 " ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = readdlm(\"dat.txt\")" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [], "source": [ "col2 = arr[:,2]\n", "writedlm(\"dat2.txt\", col2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#Excercise 1: Fibbonacci Sequence" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Write a function which creates a generalised Fibonacci sequence which takes any two numbers and uses them as the first two numbers of a 1000 long sequence.\n", "\n", "Your function should write the values to a file and return the ratio between the last and second to last values of the sequence" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Plotting" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Pyplot" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There are a number of options for plotting figures in Julia. Here we will show 2 of them, PyPlot and Gadfly" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can call the matplotlib plotting functions from Python using the PyPlot package. This is added to julia using the Pkg.add(\"PyPlot\") command, and then can be used with using PyPlot" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "1-element Array{Any,1}:\n", " PyObject " ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using PyPlot\n", "\n", "x = collect(1:10)\n", "plot(x, x.^3)" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "([92.0,107.0,102.0,87.0,103.0,86.0,94.0,103.0,109.0,117.0],[0.000368773,0.100296,0.200224,0.300152,0.400079,0.500007,0.599934,0.699862,0.799789,0.899717,0.999645],{PyObject ,PyObject ,PyObject ,PyObject ,PyObject ,PyObject ,PyObject ,PyObject ,PyObject ,PyObject })" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dist = rand(1000)\n", "plt.hist(dist)" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAqsAAAIUCAYAAAA9h2VRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAIABJREFUeJzs3X14VdWdt/E7YAgRAeGAkpiq1TYKFoTwolZlRIqiBLVFsLQOLQjOIDVUpJZBi1MzhmmRQmeYBxgbRStFQXRqgqVVqiRaa0CCw1SoWFs1MSIxvkRICJA8f8ScEhI04Dln5yT357pyheyzzl6/DXH7zcraayXU1dXVIUmSJLVCHYIuQJIkSToSw6okSZJaLcOqJEmSWi3DqiRJklotw6okSZJaLcOqJEmSWi3DqiRJklotw6okSZJaLcOqJEmSWi3DqiRJklqtFofVPXv2cOeddzJ69Gh69uxJhw4deOCBBxq1qaurY8WKFVx11VWceuqpnHDCCfTv35+7776bffv2NXve3Nxc+vbtS3JyMunp6SxZsuTzXZEkxVhL7o8Ntm/fzujRo+natSuhUIhJkyZRXl7ebNuW3h8/+OADbrzxRnr37s0JJ5zApZdeSnFxccSuT5KC1OKwunv3brKzs/nzn//MwIEDAUhISGjUZs+ePUyZMoX33nuP6dOn8/Of/5xhw4Zx5513csUVVzQ55/Lly5k2bRr9+/dnyZIlXHDBBWRlZfHTn/70c16WJMVOS+6PACUlJQwfPpzXX3+d+fPnM3v2bNatW8eoUaPYv39/o7YtvT/W1tYyZswYVq1aFX793Xff5ZJLLuG1116L3kVLUqzUtdC+ffvqdu3aVVdXV1e3efPmuoSEhLoHHnigUZuampq6F154ocl777rrrrqEhIS6p59+Onxs7969daFQqG7s2LGN2l5//fV1J5xwQt3777/f0tIkKVAtuT/W1dXVTZ8+va5Lly51b731VvjY008/XZeQkFD33//93+FjR3N/fOSRR+oSEhLq1q5dGz62e/fuuh49etR961vfitg1SlJQWjyy2qlTJ0466aSGgNtsm8TERM4///wmx6+55hoAduzYET72zDPPUFFRwU033dSo7YwZM9izZw/r1q1raWmSFKiW3B8B1q5dS2ZmJmlpaeFjI0eOJD09ndWrV4ePHc398dFHH6VPnz584xvfCB/r1asXEyZM4Ne//nWTEVtJijcxecDqnXfeAepvoA0a5lMNGTKkUduMjAw6dOjA1q1bY1GaJMVEaWkpu3fvbnLPAxg6dGijOaZHc38sLi4mIyOj2XPu3buXV199NVKXIEmBiElY/elPf0r37t0bzVstKyujY8eOjQIs1I9QhEIh3n777ViUJkkxUVZWBkBKSkqT11JSUqioqAiPgh7N/bGsrOyI5wS8l0qKe8dFu4OcnBw2bNjA0qVL6datW/h4VVUVnTp1avY9SUlJVFVVNTleXl7Ob3/7W04//XSSk5OjVrOk9quqqoq//e1vXH755U3C4uc9L9Tf3w7XuXPncJvExMSjuj9WV1d/5jkP571UUjRF+j4a1bD6yCOP8KMf/YipU6fyT//0T41eS05Opqamptn3VVdXN3sD/e1vf8v1118flVol6VAPPfQQ3/72tyN2voZ7WnPL+FVXVzdqczT3x+Tk5Bad81DeSyXFQqTuo1ELq0899RSTJk0iMzOTZcuWNXk9JSWFgwcPUl5e3ih119TUUFFRQWpqapP3nH766UD9xfft2zdapQfulltuYdGiRUGXETVeX/xry9e4fft2rr/++vD9JlIafi3fMB3gUGVlZYRCIRITE8NtW3p/TElJafZX/Q39tMZ7aZDfP0F/77bXa2+vfQfdf1B933bbdjZsiNx9NCph9cUXX+TrX/86w4YNY/Xq1XTo0HRq7KBBgwDYtGlTo7msmzdvpra2NrxW4aEaRgj69u3b7AMFbUX37t29vjjW1q8P2sc1RvrX46eccgq9e/dm06ZNTV4rKipqdM87mvvjwIEDKSwspK6urtHari+++CJdunQhPT29SX9B30uD/P4J+nu3vV57e+076P6D6vuvf63/HKn7aMQfsNq+fTtjxozhjDPOID8/v9m5VACXXnopPXv2ZOnSpY2OL126lC5dujBmzJhIlyZJgRo3bhz5+fmUlJSEj23YsIGdO3cyfvz48LGjuT9ee+217Nq1i8ceeyx8rLy8nDVr1jB27NjwaK0kxcJ778Hrr0f2nEc1srpkyRI++OCD8K+cnnjiCd58800AsrKySEhI4PLLL+eDDz7gtttuIy8vr9H7v/SlL4XXYe3cuTPZ2dnMmDGDCRMmcNlll1FYWMjKlSvJycnhxBNPjMT1SVJMfNb9sVu3bsydO5c1a9YwYsQIZs6cSWVlJQsWLGDAgAFMnjw5fK6juT9ee+21nH/++UyePJlXXnmFUCjE//t//4+6ujp+/OMfx/YvQVK799xzkT/nUYXVhQsX8sYbbwD1Wwk+/vjjPPbYYyQkJDBp0iRqa2spKSkhISGBOXPmNHn/d7/73UabBkyfPp3ExEQWLlzIE088wamnnsrixYvJysr6nJclSbH1WffHbt26kZaWxsaNG5k1axZz5swhKSmJzMxMFi5c2GQEtKX3xw4dOvDkk0/ygx/8gP/4j/+gqqqKYcOG8eCDD/LlL385ZtcvSQAFBXDyybBrV+TOeVRh9a8NkxA+RW1t7VEVMHXqVKZOnXpU72nrJk6cGHQJUeX1xb/2cI1HqyX3R4B+/fqxfv36FrVt6f3xxBNP5N577+Xee+9t0XmDFuT3T9Dfu+312ttr30H3H0TfhYWQkQG/+U3kzplQ92l7A7YyW7ZsYfDgwbz00ktt/uEOScFoD/eZ9nCNkmKvshJ69IA5c7Zw992Ru8fEZAcrSZIktW0vvAAHD8InC5pEjGFVkiRJn1thIfTuDRFeptqwKkmSpM+voAAuvhgOWfI5IqK63aokfV579+5lx44dMetv+/btMetLktqKffvgxRfhJz+J/LkNq5JatR07djB48OCgy5AkfYpNm+oD68UXR/7chlVJceIhIBb72D8J/CgG/UhS21FQAF27wrnnwssvR/bchlVJcaIvEItllpwGIElHq7AQLrwQOnaM/Ll9wEqSJEnH7MABeP55GD48Ouc3rEqSJOmYvfxy/YYAhlVJkiS1OoWFkJQEQ4ZE5/yGVUmSJB2zggI4//z6wBoNhlVJkiQdk7q6+pHVaE0BAMOqJEmSjtGOHVBeHp31VRsYViVJknRMCgrql6u64ILo9WFYlSRJ0jEpLISMDDjhhOj1YViVJEnSUaurg40boztfFQyrkiRJOgZvvAElJYZVSZIktUKFhfWfL7wwuv0YViVJknTUCgrgK1+BUCi6/RhWJUmSdNSivb5qA8OqJEmSjsquXfDnP0d3fdUGhlVJkiQdlYb5qoZVSZIktTqFhXDGGXDKKdHvy7AqSZKko1JQEJv5qmBYlSRJ0lH44AN4+WXDqiRJklqhP/yhfveqWMxXBcOqJEmSjkJBAaSkwJlnxqY/w6okSZJarGG+akJCbPozrEqSJKlF9u6FzZtjNwUADKuSJElqoRdfhP37Y/dwFRhWJUmS1EKFhdCjB5xzTuz6NKxKkiSpRQoK4KKLoEMME6RhVZIkSZ9p/3544YXYTgEAw6okSZJaYMuW+gesYvlwFRhWJUmS1AIFBXD88ZCREdt+j4ttd5Li3d69e9mxY0fM+tu+fXvM+pIkHVlBAVxwASQmxrZfw6qko7Jjxw4GDx4cdBmSpBiqrYXnnoNbbol934ZVScfoIaBvDPp5EvhRDPqRJB3J//0ffPBB7B+uAsOqpGPWF4jFxCWnAUhS0AoL63/9f955se/bB6wkSZL0qQoKYOhQSE6Ofd+GVUmSJB1RXV19WA1iCgAYViVJkvQp/vIXeOed2K+v2sCwKkmSpCMqKICEBLjwwmD69wGrzxDrNSUbnH322Rx//PEx71eSJOlQBQVw7rnQvXsw/RtWP0NQa0q+9NJLZMR6iwhJkqTDFBZCZmZw/RtWWyxWa0puB66PQT+SJEmfrrQUXn89uIerwLB6FGK1pqQkSVLrUFhY//mii4KrwQesJEmS1KyCAjjrLDj55OBqMKxKkiSpWUGur9rAsCpJkqQm3nsP/vSn4NZXbWBYlSRJUhPPPVf/2ZFVSZIktToFBfCFL8BppwVbh2FVkiRJTRQWBj+qCoZVSZIkHaayErZsMaxKkiSpFXrhBTh4MPiHq8CwKkmSpMMUFkKvXnD22UFXYliVJEnSYRrWV01ICLoSw6okSZIOsW8fvPhi65gCAIZVSZIkHWLTpvrA2hoergI4LugC1L7s3buXHTt2xLzfs88+m+OPPz7m/cZCrP9Ot2/fHrO+JEmxV1AAXbvCuecGXUk9w6piaseOHQwePDjm/b700ktkZGTEvN9YCOrvVJLUNhUWwoUXQseOQVdSz7CqgDwE9I1BP9uB62PQT2sQq7/TJ4EfxaAfSVKsHTgAzz8P//IvQVfyd4ZVBaQv0DZHOoMTq79TpwFIUlv18sv1GwK0loerwLDaClUBsZ8X2JbndEqSpJYpLISkJBg6NOhK/s6w2ur8DYDrr4/tr67b8pxOSZLUMgUFcP759YG1tWjx0lV79uzhzjvvZPTo0fTs2ZMOHTrwwAMPNNt2+/btjB49mq5duxIKhZg0aRLl5eXNts3NzaVv374kJyeTnp7OkiVLju1K2pyHgJdi8PFQrC5IkiS1YnV19SOrrWkKABzFyOru3bvJzs7mtNNOY+DAgTz77LMkNLOtQUlJCcOHD6dHjx7Mnz+fyspK7rnnHrZt20ZRURGJiYnhtsuXL2f69Olce+21zJ49m4KCArKysti7dy+33XZbZK4wbjmnU5Ikxc6OHVBe3nrWV23Q4rCamprKO++8w0knncRLL73E0CNMZsjJyaGqqori4mLS0tIAGDZsGKNGjWLFihVMmzYNgKqqKm6//XYyMzNZvXo1ADfccAO1tbVkZ2dz4403cuKJJ37e65MkSVILFBTUL1d1wQVBV9JYi6cBdOrUiZNOOgmAurq6I7Zbu3YtmZmZ4aAKMHLkSNLT08OhFOCZZ56hoqKCm266qdH7Z8yYwZ49e1i3bl2LL0KSJEmfT2EhZGTACScEXUljEd1utbS0lN27dzNkyJAmrw0dOpTi4uLw1w1/PrxtRkYGHTp0YOvWrZEsTZIkSUdQVwcbN7a+KQAQ4bBaVlYGQEpKSpPXUlJSqKioYP/+/eG2HTt2pFevXo3aderUiVAoxNtvvx3J0iRJknQEb7wBJSWt7+EqiHBYraqqXyM0qZn1Djp37tyoTVVVFZ06dWr2PElJSeF2kiRJiq7CwvrPF10UbB3Nieg6q8nJyQDs27evyWvV1dWN2iQnJ1NTU9Pseaqrq8PtmnPLLbfQvXv3RscmTpzIxIkTj6luSe3Vqk8+DlUSRCGSFKiCAjjnHAiFgq6kqYiG1YZf/zdMBzhUWVkZoVAovHRVSkoKBw8epLy8vNFUgJqaGioqKkhNTT1iP4sWLXIBe0kRMPGTj0OtBGK7KYckBa2wEC69NOgqmhfRaQCnnHIKvXv3ZtOmTU1eKyoqYuDAgeGvBw0aBNCk7ebNm6mtrW3UVpIkSdGxaxf8+c+t8+EqiHBYBRg3bhz5+fmUlPz9V2kbNmxg586djB8/Pnzs0ksvpWfPnixdurTR+5cuXUqXLl0YM2ZMpEuTJEnSYRrmq7bGh6vgKKcBLFmyhA8++CD8pP4TTzzBm2++CUBWVhbdunVj7ty5rFmzhhEjRjBz5kwqKytZsGABAwYMYPLkyeFzde7cmezsbGbMmMGECRO47LLLKCwsZOXKleTk5LghgCRJUgwUFsIZZ8AppwRdSfOOKqwuXLiQN954A4CEhAQef/xxHnvsMRISEpg0aRLdunUjLS2NjRs3MmvWLObMmUNSUhKZmZksXLiw0VarANOnTycxMZGFCxfyxBNPcOqpp7J48WKysrIid4WSJEk6ooKC1jsFAI4yrP71r39tUbt+/fqxfv36FrWdOnUqU6dOPZoyJEmSFAEffAAvvww33xx0JUcW8TmrkiRJig9/+EP97lWteWTVsCpJktROFRRAnz5w5plBV3JkhlVJipHNmzdz9dVXk5qaSpcuXejbty/Z2dlNduzbvn07o0ePpmvXroRCISZNmkR5eXmz58zNzaVv374kJyeTnp7OkiVLYnEpktqIhvmqCQlBV3JkEd0UQJLUvG3btnHRRReRmprK97//fXr27Mkf/vAH7rzzTl566SX+53/+B4CSkhKGDx9Ojx49mD9/PpWVldxzzz1s27aNoqKiRg+qLl++nOnTp3Pttdcye/ZsCgoKyMrKYu/evdx2221BXaqkOLF3L2zeDN/+dtCVfDrDqiTFwMMPP0xNTQ3r1q2jb9++QP0DprW1tTz44IN8+OGHdO/enZycHKqqqiguLiYtLQ2AYcOGMWrUKFasWMG0adMAqKqq4vbbbyczM5PVq1cDcMMNN1BbW0t2djY33nijSwBK+lQvvgj797fe9VUbOA1AkmIgOTkZgJNOOqnR8T59+tCxY0c6deoEwNq1a8nMzAwHVYCRI0eSnp4eDqUAzzzzDBUVFdx0002Nzjdjxgz27NnDunXronUpktqIwkI48UT4yleCruTTGVYlKQamTJnCySefzA033MDLL7/MW2+9xSOPPMKyZcvIysoiOTmZ0tJSdu/ezZAhQ5q8f+jQoRQXF4e/bvjz4W0zMjLo0KEDW7duje4FSYp7BQX1o6odWnkadBqAJMVAamoqzz//PFdeeSWDBg0KH7/jjju46667ACgrKwMgJSWlyftTUlKoqKhg//79JCYmUlZWRseOHenVq1ejdp06dSIUCoV3GpSk5uzfDy+8AP/6r0FX8tkMq5IUA7t27eKKK64A4N577yUUCpGfn8/dd9/NySefzIwZM8KrAiQlJTV5f+fOnYH6uaqJiYlUVVWFpw4cLikpqckKA5J0qC1b6h+was3rqzYwrEpSDGRnZ1NaWsqrr75KamoqANdccw21tbX88Ic/ZOLEieF5rfv27Wvy/urqauDvc1+Tk5Opqalptq/q6upwu09zyy230L1790bHJk6cyMSJE1t+YZLiUkEBHH88ZGR8vvOsWrWKVatWNTr24Ycffr6THsawKkkx8NxzzzFo0KBwUG0wduxYVqxYwdatWznrrLOAv08HOFRZWRmhUCi8dFVKSgoHDx6kvLy80VSAmpoaKioqmvTTnEWLFpHxef9PJSkuFRTABRfAIavhHZPmfsDdsmULgwcP/nwnPkQrn1IrSW3D/v37OXjwYLPHAQ4cOMApp5xC79692bRpU5N2RUVFDBw4MPx1w7zXw9tu3ryZ2traRm0l6VC1tfDcc/ExBQAMq5IUExkZGWzZsoWdO3c2Or5q1So6duzIgAEDABg3bhz5+fmUlJSE22zYsIGdO3cyfvz48LFLL72Unj17snTp0kbnW7p0KV26dGHMmDFRvBpJ8ez//g8++KD1r6/awGkAkhQDP/jBD1i7di0XX3wx3/ve9+jZsyf5+fmsX7+eadOm0adPHwDmzp3LmjVrGDFiBDNnzqSyspIFCxYwYMAAJk+eHD5f586dyc7OZsaMGUyYMIHLLruMwsJCVq5cSU5OjhsCSDqiwsL6X/+fd17QlbSMYVWSYmDAgAE8++yz3HnnnSxYsIDq6mrOOOMMcnJyGm2NmpaWxsaNG5k1axZz5swhKSmJzMxMFi5c2GirVYDp06eTmJjIwoULeeKJJzj11FNZvHgxWVlZsb48SXGkoACGDq1/wCoeGFYlKUaGDRvGb37zm89s169fP9avX9+ic06dOpWpU6d+3tIktRN1dfVh9TvfCbqSljOsShG0d+9eduzYEdM+t2/fHtP+JEnx6y9/gXfeiZ+Hq8CwKkXUjh07IrpchyRJkVRQAAkJ8NWvBl1JyxlWpah4COgbo76eBH4Uo74kSfGsoADOPRfi6RlMw6oUFX2BWC227jQASVLLFBZCZmbQVRwd11mVJElqB0pL4fXX42d91QaGVUmSpHagsLD+s2FVkiRJrU5BAZx1Fpx8ctCVHB3DqiRJUjtQUBB/o6oQpw9Ybd68mY8++igmfb366qsx6UeSJCla3nsP/vQn+OEPg67k6MVlWP2nf/qnoEuQJEmKG889V//ZkdWYWQTEYt2FPcDAGPQjSZIUPQUF8IUvwGmnBV3J0YvTsNoH+FIM+vk4Bn1IkiRFV2Fh/RarCQlBV3L0fMBKkiSpDaushC1b4nMKABhWJUmS2rQXXoCDB+tHVuORYVWSJKkNKyyEXr3g7LODruTYGFYlSZLasIb1VeNxvioYViVJktqsffvgxRfjdwoAGFYlSZLarE2b6gNrvD5cBYZVSZKkNqugALp2hXPPDbqSY2dYlSRJaqMKC+HCC+G4OF1ZHwyrkiRJbdKBA/D88/E9BQAMq5IkSW3Syy/XbwgQzw9XgWFVkiSpTSoshKQkGDo06Eo+H8OqJElSG1RQAOedVx9Y45lhVZIkqY2pq6sfWY33KQBgWJUkSWpzduyA8vL4f7gKDKuSJEltTkEBdOwIF1wQdCWfn2FVkiSpjXnmGcjIqN8QIN7F8RKxiowqALZv3x6T3mLVjyRJ7dX+/bB+PcycGXQlkWFYbff+BsD1118fbBmSJCkinnsOPvwQxo4NupLIMKzqEw8BfWPQz5PAj2LQjyRJ7VNeHqSk1E8DaAsMq/pEXyAW39VOA5AkKVrq6urDamYmdGgjTyYZVtXGOSdXktR+/PnP8Npr8LOfBV1J5BhW1cb9DXBOriSpfcjLg86dYeTIoCuJHMOq2gnn5EqS2r68PPja1+D444OuJHIMq2onnJMrSWrb3nsPnn8eli4NupLIaiNTbyVJktq33/wGamvrH65qSwyrkiRJbUBeHgweDKmpQVcSWYZVSZKkONewa1Vb2QjgUIZVSZKkOFdYCB99ZFiVJElSK5SXB6ecAoMGBV1J5BlWJUmS4tihu1YlJARdTeQZViVJkuLYjh3wl7+0zSkAYFiVJEmKa3l5kJwMl14adCXRYViVJEmKYw27ViUnB11JdBhWJUmS4tR778Ef/tB2pwCAYVWSJCluPflk29y16lCGVUmSpDiVlwdDhkBKStCVRI9hVZIkKQ7V1LTdXasOZViVJEmKQwUFUFlpWD0mmzdv5uqrryY1NZUuXbrQt29fsrOzqaqqatRu+/btjB49mq5duxIKhZg0aRLl5eXRKEmSJKlNycuDtDQYODDoSqLruEifcNu2bVx00UWkpqby/e9/n549e/KHP/yBO++8k5deeon/+Z//AaCkpIThw4fTo0cP5s+fT2VlJffccw/btm2jqKiIxMTESJcmSZLUJrT1XasOFfGw+vDDD1NTU8O6devo27cvAFOnTqW2tpYHH3yQDz/8kO7du5OTk0NVVRXFxcWkpaUBMGzYMEaNGsWKFSuYNm1apEuTJElqE155Bf7617Y/BQCiMA0g+ZMVaU866aRGx/v06UPHjh3p1KkTAGvXriUzMzMcVAFGjhxJeno6q1evjnRZkiRJbUZeHhx/fNvdtepQEQ+rU6ZM4eSTT+aGG27g5Zdf5q233uKRRx5h2bJlZGVlkZycTGlpKbt372bIkCFN3j906FCKi4sjXZYkSVKbkZcHo0ZB585BVxJ9EZ8GkJqayvPPP8+VV17JoEGDwsfvuOMO7rrrLgDKysoASGlmUbCUlBQqKirYv3+/81YlSZIOs3s3vPAC3Htv0JXERsTD6q5du7jiiisAuPfeewmFQuTn53P33Xdz8sknM2PGjPCqAElJSU3e3/mTHxGqqqoMq5IkSYd58sn6B6zGjAm6ktiIeFjNzs6mtLSUV199ldTUVACuueYaamtr+eEPf8jEiRPD81r37dvX5P3V1dXA3+e+Nm8B8KvDjk385EOSWmrVJx+HKgmiEElqsbw8GDYM+vQJupLYiHhYfe655xg0aFA4qDYYO3YsK1asYOvWrZx11lnA36cDHKqsrIxQKPQZo6o/AL4ZwaoltU/N/ZC7Erg+gFok6bPt2we//S388IdBVxI7EX/Aav/+/Rw8eLDZ4wAHDhzglFNOoXfv3mzatKlJu6KiIga29dVtJUmSjkFBAXz8cftYsqpBxMNqRkYGW7ZsYefOnY2Or1q1io4dOzJgwAAAxo0bR35+PiUlf/+V24YNG9i5cyfjx4+PdFmSJElxLy8PvvAF+CROtQsRnwbwgx/8gLVr13LxxRfzve99j549e5Kfn8/69euZNm0afT6ZYDF37lzWrFnDiBEjmDlzJpWVlSxYsIABAwYwefLkSJclSZIU1xp2rRo7tu3vWnWoiI+sDhgwgGeffZZBgwaxYMECbrnlFv7617+Sk5PD0qVLw+3S0tLYuHEjZ555JnPmzOGee+4hMzOTp556ylUAJEmSDvOnP8Hf/ta+pgBAFEZWoX7b1N/85jef2a5fv36sX78+GiVIkiS1KXl50KULXHJJ0JXEVsRHViVJkhR5eXlw2WXtY9eqQxlWJUmSWrl334U//rH9TQEAw6okSVKr9+ST9Z/by65VhzKsSpIktXJ5eXDeeXDSSUFXEnuGVUmSpFZs3z743e/a5xQAMKxKkiS1as8+2/52rTqUYVWSJKkVy8uD006Dr3wl6EqCYViVJElqpdrrrlWHMqxKkiS1Utu2wZtvtt8pAGBYlSRJarXy8uCEE+Af/iHoSoJjWJUkSWqlGnatSkoKupLgGFYlSZJaoV27oKiofU8BAMOqJElSq7RuXf3nK68Mto6gGVYlSZJaobw8OP/89rlr1aEMq5IkSa1MdXX73rXqUIZVSZKkVubZZ2HvXsMqGFYlSZJanbw8OP10OOecoCsJnmFVkiSpFXHXqsYMq5IUQ1u2bOGqq64iFArRpUsX+vfvz3/+5382arN9+3ZGjx5N165dCYVCTJo0ifLy8mbPl5ubS9++fUlOTiY9PZ0lS5bE4jIkRdH//i+89ZZTABocF3QBktRe/O53v2Ps2LEMHjyYefN341qbAAAgAElEQVTmccIJJ/Daa69RWloablNSUsLw4cPp0aMH8+fPp7KyknvuuYdt27ZRVFREYmJiuO3y5cuZPn061157LbNnz6agoICsrCz27t3LbbfdFsQlSoqAvDzo2rV971p1KMOqJMXARx99xKRJkxg7diyPPvroEdvl5ORQVVVFcXExaWlpAAwbNoxRo0axYsUKpk2bBkBVVRW33347mZmZrF69GoAbbriB2tpasrOzufHGGznxxBOjf2GSIi4vDy6/HDp1CrqS1sFpAJIUA7/61a949913ufvuuwHYs2cPtbW1TdqtXbuWzMzMcFAFGDlyJOnp6eFQCvDMM89QUVHBTTfd1Oj9M2bMYM+ePaxrWE1cUlx55x13rTqcYVWSYuDpp5+mW7duvPXWW5x11ll07dqV7t27c9NNN7Fv3z4ASktL2b17N0OGDGny/qFDh1JcXBz+uuHPh7fNyMigQ4cObN26NYpXIyla1q2DDh3ctepQhlVJioGdO3dy4MABrrnmGq644goee+wxpkyZwrJly5g8eTIAZWVlAKSkpDR5f0pKChUVFezfvz/ctmPHjvTq1atRu06dOhEKhXj77bejfEWSoiEvDy64AA77T7tdc86qJMXAxx9/zN69e5k+fTqLFy8G4JprrqGmpobly5dz1113UVVVBUBSUlKT93fu3Bmon6uamJhIVVUVnY4woS0pKSl8Lknxo7oannoK5s0LupLWxbAqSTGQnJwMwMSJExsdnzhxIsuXL+ePf/wjZ599NkB4WsChqqurG50nOTmZmpqaZvuqrq4Ot/s0t9xyC927d29Sz+E1SoqN3/8+/natWrVqFatWrWp07MMPP4xoH4ZVSYqB1NRUXnnlFU4++eRGx0866SQA3n//fVJTU4G/Twc4VFlZGaFQKLx0VUpKCgcPHqS8vLzRVICamhoqKirC5/o0ixYtIiMj45ivSVJk5eXBGWdA375BV9Jyzf2Au2XLFgYPHhyxPpyzKkkx0PAgVElJSaPjDXNLe/fuTWpqKr1792bTpk1N3l9UVMTAgQPDXw8aNAigSdvNmzdTW1vbqK2k1q+uDvLz3bWqOYZVSYqBCRMmAPU7Th3qF7/4BYmJiVxyySUAjBs3jvz8/EahdsOGDezcuZPx48eHj1166aX07NmTpUuXNjrf0qVL6dKlC2PGjInSlUiKhq1boaQkvqYAxIrTACQpBgYOHMiUKVO47777OHDgAMOHD+fZZ5/l0UcfZe7cufTp0weAuXPnsmbNGkaMGMHMmTOprKxkwYIFDBgwILxqANQ/cJWdnc2MGTOYMGECl112GYWFhaxcuZKcnBw3BJDiTF4edOsGF18cdCWtj2FVkmJk2bJlnHrqqdx///08/vjjnH766SxevJisrKxwm7S0NDZu3MisWbOYM2cOSUlJZGZmsnDhwkZbrQJMnz6dxMREFi5cyBNPPMGpp57a5HyS4kNeHowe7a5VzTGsSlKMHHfcccybN495n7EuTb9+/Vi/fn2Lzjl16lSmTp0aifIkBeTtt2HzZpg5M+hKWifnrEqSJAWoYdeqK64IupLWybAqSZIUoLw8uPBCCIWCrqR1MqxKkiQFpKoKnn7aVQA+jWFVkiQpIBs21AdWw+qRGVYlSZICkp8PX/oSnHVW0JW0XoZVSZKkADTsWpWZ6a5Vn8awKkmSFIDiYigtdQrAZzGsSpIkBSAvD7p3d9eqz2JYlSRJCkDDrlWHbU6nwxhWJUmSYuztt+Gll5wC0BKGVUmSpBjLz4eOHd21qiUMq5IkSTHWsGtVz55BV9L6GVYlSZJiaO9ed606GoZVSZKkGNqwAaqrDastZViVJEmKobw8+PKX3bWqpQyrkiRJMVJbW/9wlaOqLWdYlSRJipEtW6CszLB6NAyrkiRJMZKXByeeWL8SgFrGsCpJkhQjeXn1a6u6a1XLGVYlSZJioKQEioudAnC0DKuSJEkx0LBr1ejRQVcSXwyrkiRJMZCXBxdfDD16BF1JfDGsSpIkRdmePfWbATgF4OgZViVJkqLs6adh3z7D6rEwrEqSJEVZXl79jlVf/nLQlcQfw6okSVIU1dbCunWOqh4rw6okSVIUvfQSvPOOYfVYGVYlSZKiKC+vfgWAr3416Erik2FVkiQpivLy4Mor4bjjgq4kPhlWJUmSouStt2DrVqcAfB6GVUmSpCjJz68fUXXXqmNnWJUkSYqSvDwYPhy6dw+6kvhlWJUkSYqCPXvg9793CsDnZViVJEmKgqeecteqSIhaWN2yZQtXXXUVoVCILl260L9/f/7zP/+zUZvt27czevRounbtSigUYtKkSZSXl0erJEmSpJjJy4Ozz4Yzzwy6kvgWlUUUfve73zF27FgGDx7MvHnzOOGEE3jttdcoLS0NtykpKWH48OH06NGD+fPnU1lZyT333MO2bdsoKioiMTExGqVJkiRF3YED9Q9Xfec7QVcS/yIeVj/66CMmTZrE2LFjefTRR4/YLicnh6qqKoqLi0lLSwNg2LBhjBo1ihUrVjBt2rRIlyZJkhQTTz4J774L3/pW0JXEv4hPA/jVr37Fu+++y9133w3Anj17qK2tbdJu7dq1ZGZmhoMqwMiRI0lPT2f16tWRLkuSJClm7rsPMjJg4MCgK4l/EQ+rTz/9NN26deOtt97irLPOomvXrnTv3p2bbrqJffv2AVBaWsru3bsZMmRIk/cPHTqU4uLiSJclSZIUE++8Uz8F4IYbgq6kbYh4WN25cycHDhzgmmuu4YorruCxxx5jypQpLFu2jMmTJwNQVlYGQEpKSpP3p6SkUFFRwf79+yNdmiRJUtQ9+CAkJjoFIFIiPmf1448/Zu/evUyfPp3FixcDcM0111BTU8Py5cu56667qKqqAiApKanJ+zt37gxAVVWVD1lJkqS4UlcHubkwbhyceGLQ1bQNEQ+rycnJAEycOLHR8YkTJ7J8+XL++Mc/cvbZZwOEpwUcqrq6utF5mrcA+NVhxyZ+8iFJLbXqk49DlQRRiKQ24vnn4dVXYenSoCtpOyIeVlNTU3nllVc4+eSTGx0/6aSTAHj//fdJTU0F/j4d4FBlZWWEQqHPGFX9AfDNSJUsqd1q7ofclcD1AdQiqS3IzYUvfhEuuSToStqOiM9ZbXhoqqSk8ejE22+/DUDv3r1JTU2ld+/ebNq0qcn7i4qKGOijc5IkKc5UVsLq1TBlCnRwj9CIifhf5YQJEwDIzc1tdPwXv/gFiYmJXPLJjxrjxo0jPz+/UajdsGEDO3fuZPz48ZEuS5IkKaoeeQSqq+G73w26krYl4tMABg4cyJQpU7jvvvs4cOAAw4cP59lnn+XRRx9l7ty59OnTB4C5c+eyZs0aRowYwcyZM6msrGTBggUMGDAgvGqAJElSvMjNhcsvh0OWkFcERGW71WXLlnHqqady//338/jjj3P66aezePFisrKywm3S0tLYuHEjs2bNYs6cOSQlJZGZmcnChQtdBUCSJMWVV16BP/4R1qwJupK2Jyph9bjjjmPevHnMmzfvU9v169eP9evXR6MESZKkmMnNhV694Kqrgq6k7XH6ryRJ0udQU1O/EcA//iN06hR0NW2PYVWSJOlzyM+H8nK3V40Ww6okSdLnkJsL550H55wTdCVtk2FVkiTpGJWWwvr1jqpGk2FVkiTpGK1YAZ07w3XXBV1J22VYlSRJOga1tXDffTB+PHTrFnQ1bVdUlq6SJElq6zZuhNdfrx9dVfQ4sipJknQM7rsP0tPhoouCrqRtM6xKkiQdpQ8+gEcfhSlTICEh6GraNsOqJEnSUVq1Cvbvh0mTgq6k7TOsSpIkHaXcXLjySkhJCbqSts+wKkmSdBRefhleesm1VWPFsCpJknQUcnPh5JPrR1YVfYZVSZKkFqquhocegu98BxITg66mfTCsSpIktdCvfw3vvw+TJwddSfthWJUkSWqh3Fy48EI4++ygK2k/DKuSJEkt8MYb8PTTPlgVa4ZVSZKkFrj/fujSBcaPD7qS9sWwKkmS9Blqa+vD6je/CSecEHQ17YthVZIk6TNs2ABvvukUgCAYViVJkj5Dbi707QvnnRd0Je2PYVWSJOlTvPcePP54/ahqQkLQ1bQ/hlVJkqRPsXJl/ZzVf/zHoCtpnwyrkiRJR1BXVz8F4Kqr4KSTgq6mfTKsSpIkHcGWLfC//+uDVUEyrEqSJB1Bbi6kpsJllwVdSftlWJUkSWpGVRX86lfw3e/CcccFXU37ZViVJElqxtq18OGHMGVK0JW0b4ZVSZKkZuTmwiWXwJlnBl1J++agtiRJ0mH+8hd49ln45S+DrkSOrEqSJB3m/vuhWzf4xjeCrkSGVUmSpEMcPAgrVsC3vgXHHx90NTKsSpIkHeK3v4XSUtdWbS0Mq5IkSYfIzYUBA2Dw4KArERhWJSkwd999Nx06dKB///5NXtu+fTujR4+ma9euhEIhJk2aRHl5ebPnyc3NpW/fviQnJ5Oens6SJUuiXbrUZr37LjzxRP2oakJC0NUIDKuSFIiSkhJycnLo0qULCYf9H7GkpIThw4fz+uuvM3/+fGbPns26desYNWoU+/fvb9R2+fLlTJs2jf79+7NkyRIuuOACsrKy+OlPfxrLy5HajF/+Ejp0gG9/O+hK1MClqyQpALNnz+arX/0qBw4caDJimpOTQ1VVFcXFxaSlpQEwbNgwRo0axYoVK5g2bRoAVVVV3H777WRmZrJ69WoAbrjhBmpra8nOzubGG2/kxBNPjO2FSXGsrg7uuw+uuQZCoaCrUQNHViUpxgoKCli7di2LFy+mrq6uycjq2rVryczMDAdVgJEjR5Kenh4OpQDPPPMMFRUV3HTTTY3eP2PGDPbs2cO6deuieyFSG/Pii/DKKz5Y1doYViUphg4ePMjNN9/MtGnTOOecc5q8Xlpayu7duxkyZEiT14YOHUpxcXH464Y/H942IyODDh06sHXr1ghXL7Vtublw6qnwta8FXYkO5TQASYqhZcuW8eabb/L73/++2dfLysoASElJafJaSkoKFRUV7N+/n8TERMrKyujYsSO9evVq1K5Tp06EQiHefvvtyF+A1EZ9/DE8/DDcemv9nFW1Hv5zSFKMvPfee8ybN4958+YROsKEuKqqKgCSkpKavNa5c+dGbaqqqujUqVOz50lKSgq3k/TZ1qyBPXtg8uSgK9HhHFmVpBi544476NWrFzfffPMR2yQnJwOwb9++Jq9VV1c3apOcnExNTU2z56murg63O5JbbrmF7t27Nzo2ceJEJk6c+Knvk9qi3FwYORJOOy3oSuLLqlWrWLVqVaNjH374YUT7MKxKUgzs3LmTe++9l8WLF1NSUhI+Xl1dTU1NDW+88QbdunUL//q/YTrAocrKygiFQiQmJgL10wIOHjxIeXl5o6kANTU1VFRUkJqa+qk1LVq0iIyMjEhcnhTX/vxneP55OCxzqQWa+wF3y5YtDI7gjgpOA5CkGCgtLaW2tpasrCzOOOOM8EdRURGvvvoqX/ziF8nOzuaUU06hd+/ebNq0qck5ioqKGDhwYPjrQYMGATRpu3nzZmpraxu1lXRk990HPXrUL1ml1seRVUmKgf79+/P44483Wqaqrq6OO+64g48//pif//znnHnmmQCMGzeOBx54gJKSkvDyVRs2bGDnzp3ceuut4fdfeuml9OzZk6VLl3LFFVeEjy9dupQuXbowZsyYGF2dFL/274cHHoDrr4dPpoWrlTGsSlIMhEIhrr766ibHFy1aBMBVV10VPjZ37lzWrFnDiBEjmDlzJpWVlSxYsIABAwYw+ZCnPzp37kx2djYzZsxgwoQJXHbZZRQWFrJy5UpycnLcEEBqgSefhF27XFu1NTOsSlKAEhISmmwKkJaWxsaNG5k1axZz5swhKSmJzMxMFi5cGJ6v2mD69OkkJiaycOFCnnjiCU499VQWL15MVlZWLC9Dilu5uZCRAeeeG3QlOhLDqiQF6Jlnnmn2eL9+/Vi/fn2LzjF16lSmTp0aybKkdqGsrH5k9T/+I+hK9Gl8wEqSJLVLDz4IiYnwrW8FXYk+jWFVkiS1O3V19asAjBsHTu9u3QyrkiSp3XnuOXj1VR+sigeGVUmS1O7k5sIXvwj/8A9BV6LPYliVJEntykcfwZo1MGUKdDAJtXr+E0mSpHbl4Yehuhq++92gK1FLGFYlSVK7ct99cPnl8MkGcWrlXGdVkiS1G3/6E7z4Ijz6aNCVqKUcWZUkSe1Gbi706gVjxwZdiVrKsCpJktqFmhr45S/hH/8ROnUKuhq1lGFVkiS1C088AeXlrq0abwyrkiSpXcjNhfPOg3POCboSHQ3DqiRJavPeegt++1tHVeORYVWSJLV5DzwAyclw3XVBV6KjZViVJEltWm1t/dqq48dDt25BV6Oj5TqrkiSpTXv2WfjrX+tHVxV/HFmVJEltWm4upKfDRRcFXYmOhWFVkiS1We+/D2vXwpQpkJAQdDU6FlEPq3fffTcdOnSgf//+TV7bvn07o0ePpmvXroRCISZNmkR5eXm0S5IkSe3EqlVw4ABMmhR0JTpWUZ2zWlJSQk5ODl26dCHhsB9nSkpKGD58OD169GD+/PlUVlZyzz33sG3bNoqKikhMTIxmaZIkqR3IzYUrr4SUlKAr0bGKalidPXs2X/3qVzlw4ECTEdOcnByqqqooLi4mLS0NgGHDhjFq1ChWrFjBtGnTolmaJElq4zZvhi1bYN68oCvR5xG1aQAFBQWsXbuWxYsXU1dX12Rkde3atWRmZoaDKsDIkSNJT09n9erV0SpLkiS1Ez/+MXzpSzBmTNCV6POISlg9ePAgN998M9OmTeOcZvY0Ky0tZffu3QwZMqTJa0OHDqW4uDgaZUmSpHbixRchP78+sB7nQp1xLSr/fMuWLePNN9/k97//fbOvl5WVAZDSzASSlJQUKioq2L9/v/NWJUnSMfnRj6BfP3esagsiHlbfe+895s2bx7x58wiFQs22qaqqAiApKanJa507dw63MaxKkqSjVVAATz0Fjz4KHTsGXY0+r4iH1TvuuINevXpx8803H7FNcnIyAPv27WvyWnV1daM2zVsA/OqwYxM/+ZCkllr1ycehSoIoRFKE1NXVj6oOHAhf/3rQ1SgSIhpWd+7cyb333svixYspKfn7Db+6upqamhreeOMNunXrFv71f8N0gEOVlZURCoU+Y1T1B8A3I1m6pHapuR9yVwLXB1CLpEjYsKF+ZDUvDzq49VGbENGwWlpaSm1tLVlZWWRlZTV5/Ytf/CLf//73+dnPfkbv3r3ZtGlTkzZFRUUMHDgwkmVJkqR2oK4O7rgDzjvPFQDakoiG1f79+/P44483Wqaqrq6OO+64g48//pif//znnHnmmQCMGzeOBx54gJKSkvDyVRs2bGDnzp3ceuutkSxLkiS1A08+Wb8KwO9+59aqbUlEw2ooFOLqq69ucnzRokUAXHXVVeFjc+fOZc2aNYwYMYKZM2dSWVnJggULGDBgAJMnT45kWZIkqY1rmKt68cXwta8FXY0iKSYrjyUkJDTZFCAtLY2NGzcya9Ys5syZQ1JSEpmZmSxcuNBVACRJ0lF5/HEoLoaNGx1VbWtiElafeeaZZo/369eP9evXx6IESZLURh08WL+l6te+BsOHB12NIs09HSRJUlxbvRr+9Cf4xS+CrkTR4KIOkiQpbh04AHfeWf/0//nnB12NosGRVUmSFLceegh27oSHHw66EkWLI6uSJCku1dTAj38M3/gGZGQEXY2ixZFVSZIUl+6/H954o363KrVdjqxKkqS4U10N2dnwzW/CV74SdDWKJsOqJEmKO//931BWVv9wldo2w6okSYore/dCTg5MmgRnnRV0NYo2w6okSYor//Vf8N579RsBqO0zrEqSpLhRWQk/+QnccAN88YtBV6NYMKxKkqS48fOf1wfW228PuhLFimFVkiTFhfffh3vugX/+Z/jCF4KuRrFiWJUkSXHhZz+r3wjgX/4l6EoUS4ZVSZLU6pWXw+LF8L3vQZ8+QVejWDKsSpKkVu+nP63/fNttwdah2DOsSpKkVu2dd2DJEvj+96FXr6CrUawZViVJUqs2fz506gSzZgVdiYJgWJUkSa3WW2/BsmUwezb06BF0NQqCYVWSJLVad98NXbvCzJlBV6KgGFYlSVKr9PrrkJsLP/xhfWBV+2RYlSRJrVJ2NoRCMGNG0JUoSMcFXYAkSdLh/vxnePBBWLQIjj8+6GoUJEdWJUlSq/PjH0NqKtx4Y9CVKGiOrEqSpFbl//4PHn4Yli6Fzp2DrkZBc2RVkiS1KnfeCaedBpMnB12JWgNHViVJUquxZQs89hjcf3/9RgCSI6uSJKnVmDcP0tPh+uuDrkSthSOrkiSpVXjhBVi3Dn71KzjOhKJPOLIqSZJahXnz4Jxz4Lrrgq5ErYk/t0iSpMBt3AhPPw1r10IHh9J0CL8dJElSoOrq4Ec/gkGD4OtfD7oatTaOrEqSpEA99RQUFkJ+PiQkBF2NWhtHViVJUmAaRlXPOw+uvDLoatQaObIqSZICk58PRUX1o6uOqqo5jqxKkqRA1NbWrwAwfDiMHBl0NWqtHFmVJEmBeOwx2Lq1fiUAR1V1JI6sSpKkmDt4EO68E0aNqh9ZlY7EkVVJkhRzDz8Mr7wC990XdCVq7RxZlSRJMXXgAPzrv0JmZv0qANKncWRVkiTF1IMPwmuvwerVQVeieODIqiRJipmaGrjrLhg3rn7HKumzOLIqSZJiJjcX3nwT1q0LuhLFC0dWJUlSTFRVwb/9G0ycCOecE3Q1iheGVUmSFBPLl8OuXfVLVkktZViVJElRt2cPzJ8PkyZBenrQ1SieGFYlSVLULVkC779fv72qdDQMq5IkKao++gh++lO44QY4/fSgq1G8MaxKkqSoWry4fhrA7bcHXYnikWFVkiRFTUUFLFwI//zPkJYWdDWKR4ZVSZIUNf/2b/Xbq86ZE3QlileGVUmKkU2bNvG9732Pc845hxNOOIHTTjuN6667jp07dzZpu337dkaPHk3Xrl0JhUJMmjSJ8vLyZs+bm5tL3759SU5OJj09nSVLlkT7UqQWefppWLQI/vVfoU+foKtRvHIHK0mKkZ/85Ce88MILjB8/ngEDBlBWVsaSJUvIyMjgj3/8I+d8skp6SUkJw4cPp0ePHsyfP5/Kykruuecetm3bRlFREYmJieFzLl++nOnTp3Pttdcye/ZsCgoKyMrKYu/evdx2221BXapEeXn9MlUjR8KttwZdjeKZYVWSYuTWW29l6NChHHfc32+91113Hf379+ff//3f+eUvfwlATk4OVVVVFBcXk/bJJL9hw4YxatQoVqxYwbRp0wCoqqri9ttvJzMzk9WrVwNwww03UFtbS3Z2NjfeeCMnnnhijK9Sgro6mDoVamrgwQehg7/H1efgt48kxcgFF1zQKKgCfOlLX6Jfv37s2LEjfGzt2rVkZmaGgyrAyJEjSU9PD4dSgGeeeYaKigpuuummRuecMWMGe/bsYZ2brysgy5fDr38NubmQmhp0NYp3hlVJClBdXR27du2iV69eAJSWlrJ7926GDBnSpO3QoUMpLi4Of93w58PbZmRk0KFDB7Zu3RrFyqXmvfIKzJpV//T/1VcHXY3aAsOqJAVo5cqVvP3221x33XUAlJWVAZCSktKkbUpKChUVFezfvz/ctmPHjuGg26BTp06EQiHefvvtKFcvNbZvH3zrW/UL/y9cGHQ1aiucsypJAdmxYwczZszgq1/9Kt/5zneA+nmoAElJSU3ad+7cOdwmMTGRqqoqOnXq1Oy5k5KSwueSYuVf/gW2b4eiIjj++KCrUVthWJWkALzzzjuMGTOGHj168Oijj5KQkABAcnIyAPv27Wvynurq6kZtkpOTqampafb81dXV4XZHcsstt9C9e/dGxyZOnMjEiROP7mIkYP36+mWqFi2Cc88NuhrFyqpVq1i1alWjYx9++GFE+zCsSlKMffjhh1xxxRV89NFHFBYW0ueQBSgbfv3fMB3gUGVlZYRCofDSVSkpKRw8eJDy8vJGUwFqamqoqKgg9TOebFm0aBEZGRmRuCS1c+++C9/9Llx+OWRlBV2NYqm5H3C3bNnC4MGDI9aHc1YlKYaqq6sZO3Ysr732Gvn5+Zx99tmNXj/llFPo3bs3mzZtavLeoqIiBg4cGP560KBBAE3abt68mdra2kZtpWipq4PJk6G2FlascJkqRZ7fUpIUIwcPHuS6667jxRdfZM2aNZx33nnNths3bhz5+fmUlJSEj23YsIGdO3cyfvz48LFLL72Unj17snTp0kbvX7p0KV26dGHMmDHRuRDpEP/1X/Dkk3D//e5SpehwGoAkxcitt95KXl4eY8eOpby8nIceeqjR69dffz0Ac+fOZc2aNYwYMYKZM2dSWVnJggULGDBgAJMnTw6379y5M9nZ2cyYMYMJEyZw2WWXUVhYyMqVK8nJyXFDAEXdtm0wezbcfDP4s5GixbAqSTHy8ssvk5CQQF5eHnl5eY1eS0hICIfVtLQ0Nm7cyKxZs5gzZw5JSUlkZmb+//buPL6mM/8D+Odc2VeRkIVWDBOGWmtLqC1UhFhqSbVqSzBq74KmRocETUurVItojR/S1jLDVIs2FbVUYzdGpVKjRBJCkSbNnnx/f9wmFQmS3HvuuVc+79frvKrPvcf3+2R57tc5z3keLFu2rMxWqwAwefJkWFtbY9myZfj3v/+Nxx9/HMuXL8d0ThwkleXk6Jep+vOfgbfe0jobepSxWCUiMpH4+PhKv7d58+bYs2dPpd4bHh6O8PDw6qZFVC2zZwNJScDx48Dvq6oRqYLFKhEREVXJF18A778PrFwJPPGE1tnQo44PWBEREVGlXbumX6aqf39gyhSts6GawOjF6rFjxzB16lS0aNECTk5OaNiwIUJDQ5GUlJ1+kp8AACAASURBVFTuvefPn0dQUBCcnZ3h7u6O0aNH4+bNm8ZOiYiIiIyguBgYMwaoVQv4+GPg970siFRl9GkA0dHROHLkCIYPH45WrVohLS0N77//Ptq1a4fvv/8eLVq0AABcvXoV3bp1g5ubG5YsWYLMzEwsXboUZ8+exdGjR8s9REBERETaeu894Kuv9LtV1aundTZUUxi9WH355ZfRoUMHWFn98VeHhoaiZcuWePPNN7Fx40YAwOLFi5GTk4NTp06hQYMGAICOHTuiT58++Mc//oEJEyYYOzUiIiKqptOngblzgZde0u9URWQqRp8G4O/vX6ZQBYAmTZqgefPmSExMLG3bvn07BgwYUFqoAkBgYCD8/PywZcsWY6dFRERE1ZSdDYwcCTRvDixerHU2VNOY5AErEcH169dL965OSUnBjRs30L59+3Lv7dChA06dOmWKtIiIiKgSXn4ZuHwZiI0FbG21zoZqGpMUq5s3b0ZqaipCQ0MBAGlpaQAAb2/vcu/19vbGrVu3UFBQYIrUiIiI6AF27ABWrwbefRf4y1+0zoZqItWL1cTEREyZMgUBAQEYM2YMACAnJwcAYFvBP8/sfl9ZuOQ9REREpI2UFCAsDBg8GJg4UetsqKZSdVOAa9euoX///nBzc8O2bdug/L7Ghb29PQAgLy+v3Dm5ubll3lOxtwHE3tM28veDiKiyPvn9uNtVLRIhMjvFxcDo0frdqdat4zJVpB3VitWMjAz069cPv/76Kw4ePAgvL6/S10pu/5dMB7hbWloa3N3dH7J01asAnjVyxkRU81T0j9zNAEZpkAuReVm6FIiPB77+GnB31zobqslUKVZzc3MREhKCn376CXFxcWjWrFmZ1+vXr4+6devi2LFj5c49evQo2rRpo0ZaREREVAnHjwOvvw68+ioQGKh1NlTTGX3OalFREUJDQ5GQkICtW7eiU6dOFb5v6NCh2LVrF65e/eOW2zfffIOkpCQMHz7c2GkRERFRJWRlAc89B7RuDURGap0NkUqbAnz++ecICQnBzZs3sWnTpjKvjxqlv70WERGBrVu3omfPnpgxYwYyMzPx9ttvo1WrVhg3bpyx0yIiIqJKmDlT/2DVrl2AjY3W2RCpUKyeOXMGiqLg888/x+eff17mNUVRSovVBg0a4Ntvv8VLL72EuXPnwtbWFgMGDMCyZcu41SoREZEGtm0DPvpIf/j5aZ0NkZ7Ri9X4+PhKv7d58+bYs2ePsVMgIiKiKkpOBiZMAIYNA3iDk8yJSTYFICIiIvNVVASMGgU4OwNr13KZKjIvqq6zSkREROYvOho4eFC/VJWbm9bZEJXFK6tEREQ1WEICMH8+EBEBdO+udTZE5bFYJSIiqqEyM/XLVLVvD7zxhtbZEFWM0wCIiIhqqKlTgfR04KuvAC7EQ+aKxSoREVEN9MknwP/9H7BhA9C4sdbZEN0fpwEQERHVMD//DPz1r8DIkcALL2idDdGDsVglIiKqQQoL9ctUubkBH37IZarI/HEaABERUQ2yaBFw5Ahw4ADg6qp1NkQPxyurRERENcThw8DChcDf/gZ06aJ1NkSVw2KViIioBsjIAJ5/HujcGZg3T+tsiCqP0wCIiIgecSLA5MnA7dvA/v2AFT/9yYLwx5WIiOgRt2mTfqmq2FjA11frbIiqhtMAiIiIHmGffw5MmKBfomrkSK2zIao6FqtERESPqNhYYMgQIDgYiInROhui6mGxSkRE9Aj68EP9eqqjRgFbtgC2tlpnRFQ9LFaJiIgeISLAkiXAiy8C06cDH3/MB6rIsrFYJSIiekSIAHPmABERwN//Drz7LqDjJz1ZOP5bi4iI6BFQVKRfniomBli+HJgxQ+uMiIyDxSoREZGFy8/XP+2/bRuwfj0wdqzWGREZD4tVIiIiC5adDQwbBnzzDbB1K/DMM1pnRGRcLFaJiIgsVEYGMGAAcOoU8MUXQO/eWmdEZHwsVomIiCxQejoQFARcugR8/TXg7691RkTqYLFKRERkYZKT9VdRMzKAb78FWrXSOiMi9bBYJSIisiAXLgB9+gCKAhw6BDRponVGROri6mtEREQW4vRp4KmnAEdH4PBhFqpUM7BYJSIisgCHDwM9egCPPQYcOADUr691RkSmwWKViIjIzO3Zo7/136YNsG8f4OGhdUZEpsNilYiIyIxt3QoMHAj06gXs3g24uGidEZFpsVglIiIyUx99BDz7LDB8OPCvfwH29lpnRGR6LFaJiIjM0LJlQHg4MGkSsHEjYG2tdUZE2mCxSkREZEZEgHnzgFdeAV57DVi1CtDx05pqMK6zSkREZCaKi4Hp0/UFanQ0MHu21hkRaY/FKhERkRkoKADGjwc2bwbWrAEmTtQ6IyLzwGKViIhIY7m5QGgo8OWXwCef6P9MRHosVomIiDSUmQkMGgR8/z3w738D/fppnRGReWGxSkREpJFfftEXpz/+COzdq99KlYjKYrFKRESkgdRU/a5U6elAfDzQrp3WGRGZJxarREREJva//wG9e+sfqjp4EGjWTOuMiMwXV24jIiIyof/+F+jaFbCyAg4dYqFK9DAsVomIiEwkIQHo1g2oV09/RbVhQ60zIjJ/LFaJiIhM4JtvgMBAoHlzYP9+wNNT64yILAOLVSIiIhVlZQHz5wPBwUCXLvqn/mvX1jorIsvBYpWIiEgFxcXAP/4B+PkBb70FvPyyfh1VR0etMyOyLCxWiYiIjOzAAaBDB2DcOP0c1cREYPFiwNZW68yILA+LVSIiIiO5eBEYOhTo3h2oVUv/tP+nnwK+vlpnRmS5WKwSEREZKCMDmD1b//BUQgKwcaN++9QuXbTOjMjycVMAIiKiaiosBNat0z9A9dtvwOuvA6+8Ajg4aJ0Z0aODV1aJiIiq4auvgLZtgcmTgX79gAsX9EUrC1Ui42KxSkREVAWJicCAAUDfvvolqI4dAzZsAOrX1zozokcTi1UiIqJK+OUXYPp0oGVL4Nw5YOtW/VP/7dtrnRnRo41zVomIiB6goAD44ANgwQL9HNWoKGDGDMDOTuvMiGoGFqtEREQVEAF27dI/MPXTT0BYGBAZyW1SiUyN0wCIiIju8Z//AH36AAMHAo89Bpw6Baxdy0KVSAssVomIiH53/TowcaL+Kf/kZP32qF9/DbRqpXVmRDUXpwEQEVGNl5sLvPcesGiRfuepZcuAF18EbGy0zoyIWKwSEVGNJQJs2wbMmQNcuaIvUN94A3B31zozIirBYpWIiGqk48eBWbOAQ4eA/v2BL78EmjXTOisiuhfnrBIRUY2SkgKMGQN06ADcvg3s3at/6p+FKpF54pVVIiKqEe7cAVasAKKj9VuifvghEB4OWPGTkMis8VeUiIgeSSLADz8AX3yhv8V/6BCg0wEzZwKvvw64umqdIRFVBotVIiJ6ZGRnA/HxfxSoly8D9vZAYCCwcqV+3dT69bXOkoiqgsUqERFZtEuX/ihO4+P1y1A1agSEhOgfnOreXV+wEpFlYrFKREQWJT8fOHxYX6B+8QWQmKifd9qtGxAVpS9QmzYFFEXrTInIGFisEhGR2bt2Ddi9W1+cfvUVkJkJeHkBwcH6hfx79wZcXLTOkojUwGKViIjMTlGRfh3Uktv7J07or5R26gTMnq0vUtu00T8wRUSPNk1/zfPy8jBnzhz4+PjAwcEBnTt3RlxcnJYpERFZnEdlLL19G/j0U2D0aP1V086dgfffB/z8gI0bgfR04MgRYN48oF07FqpENYWmv+pjx47Fu+++ixdeeAErVqxArVq1EBwcjMOHD2uZFhGRRbG0sfSTTz4BoF9a6uxZ4M039fNN69YFRo4EzpwBJkzQLzWVng7ExgKjRgEeHsaLrRUt4zN2zYuvdd+NRbNi9ejRo/jss8/w5ptvIjo6GuHh4di3bx8aNmyI2bNna5UWEZFFsbSx9M4dYPnyT/DXvwINGwKtWukfiqpTB/jgAyA5WV+sLl4MdOli/AX7tf7wrqmFS02NrXV8rftuLJrNWd22bRusrKwwceLE0jZbW1uEhYUhIiICKSkpqM/F8IiIHshcxtLiYuDGDeDqVf12pikpf/z57v9mZenff/s28Mwz+if3u3UDbG1VT5GILJRmxeqpU6fg5+cHJyenMu0dOnQAAJw+fZrFKhHRQ5hiLM3PB1JT71+ApqToXy8o+OMcKyvAx0e/AH/9+kDLln/8OSYG2LfPoJSIqAbRrFhNS0uDt7d3ufaSttTUVFOnRERkcQwdSzMz71+Alvw3Pb3sOY6OQIMG+sKzcWP9ovv16//R1qABUK/e/R+AekTuTBKRiWhWrObk5MC2gvs+dnZ2pa9XdI5eHIBfVcyuRN5df/4SwHkTxCx5IILxGM9cY9aMeBWNQebIkLG0S5fzyM0t+1rt2voHnTw99btAdeqkLzzvPpycHrzgfmqq/rifjIwMnDx58uGdU4GWsbWOz9jaqIl9P39eP1YbbRwVjbRo0UJ69+5drv3cuXOiKIqsXbu23GubNm0SADx48OCh+rFp0yZTDIUG41jKgwcPcz2MNY5qdmXV29u7wttTaWlpAAAfH59yr/Xt2xebNm2Cr68v7LnRMxGpICcnBz///DP69u2rdSqVwrGUiMyNscdRzYrVtm3bYv/+/cjMzISzs3Npe0JCAgCgTZs25c7x8PDA888/b7Iciahm6tKli9YpVBrHUiIyR8YcRzVbZ3XYsGEoKirC2rVrS9vy8vKwfv16dO7cmSsBEBFVAsdSInrUaXZltWPHjhg+fDhee+01pKeno3HjxtiwYQOuXLmC9evXa5UWEZFF4VhKRI86RUREq+B5eXn429/+hk2bNuH27dto3bo1IiMj0adPH61SIiKyOBxLiehRpmmxSkRERET0IJrNWSUiIiIiehizKFbz8vIwZ84c+Pj4wMHBAZ07d0ZcXFylzr1z5w4mTpyIunXrwsnJCb169cKpU6dUzrjqqtvHb775BuPHj4efnx8cHR3RuHFjTJgwAdeuXTNB1pVnyPfwbhMmTIBOp0NISIgKWVafof2Li4tDr169ULt2bbi4uKB9+/bYsmWLihlXnSF9jIuLQ2BgIOrVqwdnZ2e0bt0aK1euRHFxscpZV85vv/2GN954A0FBQahTpw50Oh02bNhQ6fMtZZx5EEO/BoY4duwYpk6dihYtWsDJyQkNGzZEaGgokpKSVI997tw5DB8+HI0bN4ajoyPc3d0REBCAzZs3qx67IosWLYJOp0PLli1Vj7V//37odLoKj6NHj6oeHwBOnjyJgQMHwt3dHY6OjmjZsiVWrlypetyxY8fet+86na50aTe1HD9+HIMGDYKPjw8cHR3xl7/8BZGRkSbZbOTEiRMICgqCq6srXFxc0LdvX5w5c8aoMaoynpw/fx5BQUFwdnaGu7s7Ro8ejZs3b1YtoFFWazXQs88+K9bW1jJ79myJiYmRgIAAsba2lkOHDj3wvKKiIgkICBAnJydZuHChrFq1Slq0aCEuLi6SlJRkouwrp7p9fPLJJ6Vx48Yyd+5c+eijjyQiIkJcXFzEy8tLrl27ZqLsH666/bvbsWPHxNraWuzt7SUkJETFbKvOkP59/PHHotPpJCgoSD744ANZs2aNzJo1S5YtW2aCzCuvun3cvXu3KIoiLVu2lOXLl8vatWtl8ODBoiiKzJgxw0TZP9ilS5dEURTx9fWVnj17iqIosmHDhkqda0njzIMY8jUw1NChQ8XHx0dmzJghH330kURFRYmXl5c4OTnJf//7X1Vjf/nllxIUFCQLFy6UdevWyYoVK6Rbt26iKIpERUWpGvteycnJ4uDgIE5OTtKyZUvV48XHx4uiKDJz5kzZvHlzmePmzZuqx9+7d6/Y2NiIv7+/LF++XNatWydz586VOXPmqB77yJEj5fq8ceNGcXR0lCeeeELV2P/5z3/E1tZWGjVqJNHR0RITEyPjxo0TRVFk0KBBqsY+ceKE2NnZSdOmTeWdd96Rt99+Wxo1aiSurq7y448/Gi1OZceT5ORk8fDwkD//+c+ycuVKWbx4sdSpU0fatGkj+fn5lY6nebGakJAgiqKU+eDOzc2VJk2aSEBAwAPP/eyzz0RRFNm+fXtp240bN8TNzU2ee+451XKuKkP6ePDgwXJtBw4cEEVRZN68eUbPtToM6V+J4uJi8ff3l/DwcPH19TWrYtWQ/l26dEns7e1l5syZaqdpEEP6+Nxzz4mdnZ3cvn27THv37t3F1dVVlXyrKi8vT65fvy4iIsePH69SoWYp48zDGPI1MNR3330nBQUFZdqSkpLEzs5ORo0aZZIc7lZUVCRt2rSRxx9/3KRxQ0NDpXfv3tKjRw/VCyaRP4rVu392TSUjI0M8PT1l6NChJo99PwcPHhRFUWTJkiWqxomIiBBFUeSHH34o0z5mzBhRFEXu3LmjWuzg4GBxd3eXW7dulbalpaWJs7OzUb8XlR1PJk+eLI6OjpKcnFzaFhcXd9/d9e5H82kA27Ztg5WVFSZOnFjaZmtri7CwMBw5cgQpKSkPPNfLywvPPPNMaZuHhwdGjBiBnTt3oqCgQNXcK8uQPnbt2rVc21NPPYU6deogMTFRlXyrypD+ldi4cSN++OEHREVFQczsmT9D+rd69WqICBYuXAgAyMrKMrv+AYb10d7eHra2tnB1dS3T7uXlBQcHB9VyrgobGxvUq1cPAKr89beUceZhDPkaGMrf3x9WVmVXSmzSpAmaN2+uyTim0+nQoEEDWFtbmyzmgQMHsH37dixfvhwiAkVRTBZbRJCZmYnCwkKTxYyNjUV6ejoWLVoEQH/bWOtpQbGxsVAUBc8995yqcUp2hSv5fSvh5eWFWrVqwcbGRrXYBw8eRO/eveHm5lYmbrdu3bBr1y5kZ2cbJU5lx5Pt27djwIABaNCgQWlbYGAg/Pz8qjQVTvNi9dSpU/Dz84OTk1OZ9g4dOgAATp8+/cBz27VrV669Q4cOyM7OxoULF4ybbDUZ0seKZGVlITMzEx4eHkbL0RCG9i8zMxNz5sxBREQEPD09VcuzugzpX1xcHJo1a4Zdu3ahQYMGcHFxgYeHB+bPn29WRashfZw2bRqKi4sxadIkJCYm4vLly1i9ejX+9a9/4bXXXlM1b1OwlHHG0ogIrl+/brJxLDs7Gzdv3sTFixfx7rvvYu/evZg9e7ZJYhcVFWHatGmYMGECWrRoYZKYdxs3bhxcXV1hb2+PXr164cSJE6rHjIuLg4uLC5KTk9G0aVM4OzvD1dUVL774IvLy8lSPf6+CggJs2bIFXbp0weOPP65qrPHjx8PT0xNhYWE4c+YMkpOT8dlnn2H16tWYPn26qlsc5+fnV/j3Ozg4ID8/H2fPnlUt9r1SUlJw48YNtG/fvtxrHTp0qNK8f802BSiRlpYGb2/vcu0lbRXteX33uT169HjguVoMDPcypI8VWb58OQoKChAaGmqU/AxlaP8WLlwIR0dHzJo1S5X8DGVI/5KSkmBlZYXx48djzpw5aN26NbZv346oqCgUFhZi8eLFquVdFYb0sXXr1ti3bx9CQkKwbt06AECtWrWwatWqMldqLZWljDOWZvPmzUhNTUVUVJRJ4r300kulu3xZWVlhxYoVJvv5XL16Na5cuYJ9+/aZJF4JW1tbDBs2DMHBwfDw8MC5c+ewdOlSPPXUU/juu+8q3IrXWJKSklBYWIjBgwcjPDwc0dHRiI+Px8qVK3Hnzh3ExsaqFrsie/fuxa1bt0yyzbCPjw8OHz6M4OBgtG3btrR93rx5pXfZ1NK0aVMcOXIExcXF0On01yPz8/NLt1+uar1hiJKH2O732XLr1i0UFBRU6g6H5sVqTk4ObG1ty7Xb2dmVvn4/ubm51T7XlAzp470OHDiABQsWIDQ0tMIPUC0Y0r8LFy5gxYoV+PTTT016S64qDOlfyW3/6OhovPrqqwCAIUOG4NatW3jvvfcQERFR7mqmFgzpY2JiIvr374+GDRvi7bffhp2dHWJjYzF16lR4enpi0KBBquVtCpYyzliSxMRETJkyBQEBARgzZoxJYs6aNQsjRoxAamoqNm/ejKlTp8Le3l71+L/88gvmz5+P+fPnw93dXdVY9/L394e/v3/p/w8YMADDhg1Dq1at8Nprr2H37t2qxc7KykJ2djYmT56M5cuXAwAGDx6M/Px8rFmzBgsXLkSTJk1Ui3+v2NhY2NjYYMSIEarHun79Ovr16wcAiImJgbu7O3bt2oVFixbB09MTU6ZMUS32iy++iMmTJyMsLAyzZ89GUVERoqKiSlcQMuV4VRLrYeNnZT77NZ8GYG9vX+Etgdzc3NLX1TjXlIyVZ2JiIoYMGYJWrVqVXsEyB4b0b8aMGejSpQuGDBmiWn6GMvRnVFEUjBw5skz7s88+i5ycnCpPAVGLIX185ZVXYGVlhf3792PUqFEYNmwY/vnPf6Jr166YMmUKioqKVMvbFCxlnLEU165dQ//+/eHm5oZt27aZbO5m06ZN0atXL4waNQq7d+9GYGAgZs6cqfqH97x58+Dh4YFp06apGqeyGjdujEGDBiE+Pl7VqUglvxf3jn0l///999+rFvteWVlZ2LlzJ/r27VtmLqdaIiMjkZKSgvj4eISFhWHw4MFYt24dxowZgzlz5uDWrVuqxZ40aRIiIiIQGxuLFi1aoFWrVrh06VLplBdTXhwp+RkwxvipebHq7e1d4WXpksvHPj4+qpxrSsbIMzk5GU8//TTc3Nzw5ZdfwtHR0eh5Vld1+7dv3z7s3bsX06dPx88//1x6FBYWIjs7G5cvX0ZmZqaquVeGId+/ktfunYtbMjH99u3bxkrTIIb08dChQ+jVq1e5h6lCQkKQmpqKy5cvGzdZE7OUccYSZGRkoF+/fvj111+xZ88eeHl5aZbL0KFDkZGRgR9//FG1GElJSYiJicG0adNw9erV0jEuNzcX+fn5uHz5siZjQIMGDZCfn4/ffvtNtRjmNPbt2LEDOTk5JpkCAOjHxLZt25YbG0JCQpCdna36RYqoqChcv34dhw4dwtmzZ5GQkFB60cDPz0/V2Hcruf1f0Zq2aWlpcHd3r/QdVc2L1bZt2+LChQvlipKS+RUPmlPTpk0bnDx5sty/DhMSEuDo6GjSb8qDGNJHQH8b6emnn0ZBQQH27t1rdg8hVbd/V65cAQA888wz+NOf/lR6pKamYt++fWjUqBHWr1+vbvKVYMj3r3379hARXL16tUx7SfFTt25dI2dbPYb0sbCwsMKrpyVPyZvyCWQ1WMo4Y+5yc3MREhKCn376Cbt27UKzZs00zafkimrJvD41pKSkoLi4GNOnTy8zxh09ehQXLlxAo0aNEBkZqVr8+/nf//4He3t7Va+ylTxUYw5j3+bNm+Hs7IyBAweaJF5BQYHmY2Lt2rUREBBQOp8+Li4Ojz32mEl/7+rXr4+6devi2LFj5V47evRo1eZMV2N5LaMqWd9x6dKlpW0l6zv6+/uXtqWlpcn58+fLrNVXsv7htm3bSttu3LghtWvXlpEjR5qmA5VgSB+zsrKkY8eO4urqKidPnjRp3pVV3f5duXJFdu7cWebYsWOH1KtXTzp27Cg7d+6Uixcvmrw/9zLk+7djxw5RFEVef/310raioiLp2rWreHh4VGlRZDUZ0seuXbuKu7u7/PLLL6VthYWF8uSTT4qrq6sUFhaaphOVdOzYsfuuCWjJ40xVPOhroIbCwkIZOHCg2NjYyO7du00Ss0R6enq5tvz8fGnXrp14eHio+vN58+ZN2bFjR7kx7oknnhBfX1/ZuXOnqpsiVNT306dPi7W1tQwePFi1uCIip06dEkVR5Pnnny/TPnLkSLGxsZG0tDRV45dIT08XKysrGTNmjEniiYiMGjVKbG1t5cKFC2XaBw8eLFZWVibre4lPP/1UFEWRd955R5W//0HjyeTJk8XBwaHCdVbXrFlT6RiaF6siIiNGjCjdOWfNmjUSEBAgNjY2ZRbEL1lM9/Lly6VtRUVF4u/vL87OzmV2lnF1dS33Q6K16vZx0KBBoiiKhIWFycaNG8scO3bs0KIrFapu/yrSsGFDs9oUQMSw/vXu3Vt0Op1MmjRJVq1aJX369BFFUSQmJsbU3Xig6vZx9+7dotPppEmTJvLWW2/JihUrxN/fXxRFkcWLF2vRlQqtXLlSIiMjZfLkyaIoigwdOlQiIyMlMjJSMjIyRMTyx5mHqczXQA0zZswQRVFk4MCB5caxjRs3qhZXRF8gBAYGyoIFCyQmJkYiIyOlWbNmotPpTFas36t79+4m2RSgZ8+e0r9/f4mKipK1a9fKzJkzxcHBQdzc3CQxMVH1+GFhYaIoioSGhsqqVatk+PDh5f7xrraVK1eKoijy1VdfmSzmmTNnxN7eXjw9PSUyMlJWrVol/fr1E0VRZOLEiarG/vbbbyUwMFDeeustWbdunYSHh4uVlZUEBwdLUVGRUWNVZjwp2cGqSZMmpTtYubm5SevWrS1rBysR/RWcV199Vby9vcXOzk46depU7gdr7NixotPpyhUCt2/flvDwcPHw8BBHR0fp2bOnnDhxwpTpV0p1++jr6ys6nU4URSl3NGrUyNTduC9Dvof3MrcdrEQM619WVpbMnDlTvL29xdbWVlq3bi2xsbGmTL9SDOnjnj175KmnnhJHR8fSPlZldxJT8PX1Lf3d0el0pb9Xd/fH0seZh6nM10ANPXr0uO84ptPpVIsror+q1KdPH/Hy8hJra2txd3eX4OBgiYuLUzXug/To0cMk262uWLFCOnXqJO7u7mJtbS3169eX0aNHm+yOVUFBgSxYsEB8fX3FxsZG/Pz85L333jNJ7BL+/v7i5eUlxcXFJo2bkJAgQUFB4uLiIjY2NtKsWTNZsmSJ0QvGe128eFH69u0rdevWFTs7O2nevLlER0eX20HOGCo7npw7d0769u0rjo6OUqdOHXnhhRcq+LkdMgAAAHtJREFUvOr/IIqIGa1MTkRERER0F80fsCIiIiIiuh8Wq0RERERktlisEhEREZHZYrFKRERERGaLxSoRERERmS0Wq0RERERktlisEhEREZHZYrFKRERERGaLxSoRERERmS0Wq0RERERktlisEhEREZHZYrFKRERERGbr/wGfpeCZERtmTQAAAABJRU5ErkJggg==", "text/plain": [ "Figure(PyObject )" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "1-element Array{Any,1}:\n", " PyObject " ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "subplot(121)\n", "plt.hist(dist)\n", "subplot(122)\n", "plot(x, x.^3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Gadfly" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There is also a plotting package built specifically for Julia called Gadfly. This can be added using Pkg.add(\"Gadfly\")" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " 0.0\n", " 2.5\n", " 5.0\n", " 7.5\n", " 10.0\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " 0\n", " 500\n", " 1000\n", " \n", " \n", " f(x)\n", " \n", " \n", " Our Plot\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " -12.5\n", " -10.0\n", " -7.5\n", " -5.0\n", " -2.5\n", " 0.0\n", " 2.5\n", " 5.0\n", " 7.5\n", " 10.0\n", " 12.5\n", " 15.0\n", " 17.5\n", " 20.0\n", " 22.5\n", " -10.0\n", " -9.5\n", " -9.0\n", " -8.5\n", " -8.0\n", " -7.5\n", " -7.0\n", " -6.5\n", " -6.0\n", " -5.5\n", " -5.0\n", " -4.5\n", " -4.0\n", " -3.5\n", " -3.0\n", " -2.5\n", " -2.0\n", " -1.5\n", " -1.0\n", " -0.5\n", " 0.0\n", " 0.5\n", " 1.0\n", " 1.5\n", " 2.0\n", " 2.5\n", " 3.0\n", " 3.5\n", " 4.0\n", " 4.5\n", " 5.0\n", " 5.5\n", " 6.0\n", " 6.5\n", " 7.0\n", " 7.5\n", " 8.0\n", " 8.5\n", " 9.0\n", " 9.5\n", " 10.0\n", " 10.5\n", " 11.0\n", " 11.5\n", " 12.0\n", " 12.5\n", " 13.0\n", " 13.5\n", " 14.0\n", " 14.5\n", " 15.0\n", " 15.5\n", " 16.0\n", " 16.5\n", " 17.0\n", " 17.5\n", " 18.0\n", " 18.5\n", " 19.0\n", " 19.5\n", " 20.0\n", " -10\n", " 0\n", " 10\n", " 20\n", " -10\n", " -9\n", " -8\n", " -7\n", " -6\n", " -5\n", " -4\n", " -3\n", " -2\n", " -1\n", " 0\n", " 1\n", " 2\n", " 3\n", " 4\n", " 5\n", " 6\n", " 7\n", " 8\n", " 9\n", " 10\n", " 11\n", " 12\n", " 13\n", " 14\n", " 15\n", " 16\n", " 17\n", " 18\n", " 19\n", " 20\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " -1500\n", " -1000\n", " -500\n", " 0\n", " 500\n", " 1000\n", " 1500\n", " 2000\n", " 2500\n", " -1000\n", " -950\n", " -900\n", " -850\n", " -800\n", " -750\n", " -700\n", " -650\n", " -600\n", " -550\n", " -500\n", " -450\n", " -400\n", " -350\n", " -300\n", " -250\n", " -200\n", " -150\n", " -100\n", " -50\n", " 0\n", " 50\n", " 100\n", " 150\n", " 200\n", " 250\n", " 300\n", " 350\n", " 400\n", " 450\n", " 500\n", " 550\n", " 600\n", " 650\n", " 700\n", " 750\n", " 800\n", " 850\n", " 900\n", " 950\n", " 1000\n", " 1050\n", " 1100\n", " 1150\n", " 1200\n", " 1250\n", " 1300\n", " 1350\n", " 1400\n", " 1450\n", " 1500\n", " 1550\n", " 1600\n", " 1650\n", " 1700\n", " 1750\n", " 1800\n", " 1850\n", " 1900\n", " 1950\n", " 2000\n", " -1000\n", " 0\n", " 1000\n", " 2000\n", " -1000\n", " -900\n", " -800\n", " -700\n", " -600\n", " -500\n", " -400\n", " -300\n", " -200\n", " -100\n", " 0\n", " 100\n", " 200\n", " 300\n", " 400\n", " 500\n", " 600\n", " 700\n", " 800\n", " 900\n", " 1000\n", " 1100\n", " 1200\n", " 1300\n", " 1400\n", " 1500\n", " 1600\n", " 1700\n", " 1800\n", " 1900\n", " 2000\n", " \n", " \n", " f(x)\n", " \n", " \n", " Our Plot\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n", "\n", "\n" ], "text/plain": [ "Plot(...)" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using Gadfly\n", "\n", "plot2 = plot(\n", " x=1:10,\n", " y=x.^3,\n", " Guide.ylabel(\"f(x)\"), # label for y-axis\n", " Guide.xlabel(\"x\"), # label for x-axis\n", " Guide.title(\"Our Plot\") # a title\n", " )" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "We can use a line rather than points if we so wish using the Geom parameter" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " 0.0\n", " 2.5\n", " 5.0\n", " 7.5\n", " 10.0\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " 0\n", " 500\n", " 1000\n", " \n", " \n", " f(x)\n", " \n", " \n", " Our Plot\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " -12.5\n", " -10.0\n", " -7.5\n", " -5.0\n", " -2.5\n", " 0.0\n", " 2.5\n", " 5.0\n", " 7.5\n", " 10.0\n", " 12.5\n", " 15.0\n", " 17.5\n", " 20.0\n", " 22.5\n", " -10.0\n", " -9.5\n", " -9.0\n", " -8.5\n", " -8.0\n", " -7.5\n", " -7.0\n", " -6.5\n", " -6.0\n", " -5.5\n", " -5.0\n", " -4.5\n", " -4.0\n", " -3.5\n", " -3.0\n", " -2.5\n", " -2.0\n", " -1.5\n", " -1.0\n", " -0.5\n", " 0.0\n", " 0.5\n", " 1.0\n", " 1.5\n", " 2.0\n", " 2.5\n", " 3.0\n", " 3.5\n", " 4.0\n", " 4.5\n", " 5.0\n", " 5.5\n", " 6.0\n", " 6.5\n", " 7.0\n", " 7.5\n", " 8.0\n", " 8.5\n", " 9.0\n", " 9.5\n", " 10.0\n", " 10.5\n", " 11.0\n", " 11.5\n", " 12.0\n", " 12.5\n", " 13.0\n", " 13.5\n", " 14.0\n", " 14.5\n", " 15.0\n", " 15.5\n", " 16.0\n", " 16.5\n", " 17.0\n", " 17.5\n", " 18.0\n", " 18.5\n", " 19.0\n", " 19.5\n", " 20.0\n", " -10\n", " 0\n", " 10\n", " 20\n", " -10\n", " -9\n", " -8\n", " -7\n", " -6\n", " -5\n", " -4\n", " -3\n", " -2\n", " -1\n", " 0\n", " 1\n", " 2\n", " 3\n", " 4\n", " 5\n", " 6\n", " 7\n", " 8\n", " 9\n", " 10\n", " 11\n", " 12\n", " 13\n", " 14\n", " 15\n", " 16\n", " 17\n", " 18\n", " 19\n", " 20\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " -1500\n", " -1000\n", " -500\n", " 0\n", " 500\n", " 1000\n", " 1500\n", " 2000\n", " 2500\n", " -1000\n", " -950\n", " -900\n", " -850\n", " -800\n", " -750\n", " -700\n", " -650\n", " -600\n", " -550\n", " -500\n", " -450\n", " -400\n", " -350\n", " -300\n", " -250\n", " -200\n", " -150\n", " -100\n", " -50\n", " 0\n", " 50\n", " 100\n", " 150\n", " 200\n", " 250\n", " 300\n", " 350\n", " 400\n", " 450\n", " 500\n", " 550\n", " 600\n", " 650\n", " 700\n", " 750\n", " 800\n", " 850\n", " 900\n", " 950\n", " 1000\n", " 1050\n", " 1100\n", " 1150\n", " 1200\n", " 1250\n", " 1300\n", " 1350\n", " 1400\n", " 1450\n", " 1500\n", " 1550\n", " 1600\n", " 1650\n", " 1700\n", " 1750\n", " 1800\n", " 1850\n", " 1900\n", " 1950\n", " 2000\n", " -1000\n", " 0\n", " 1000\n", " 2000\n", " -1000\n", " -900\n", " -800\n", " -700\n", " -600\n", " -500\n", " -400\n", " -300\n", " -200\n", " -100\n", " 0\n", " 100\n", " 200\n", " 300\n", " 400\n", " 500\n", " 600\n", " 700\n", " 800\n", " 900\n", " 1000\n", " 1100\n", " 1200\n", " 1300\n", " 1400\n", " 1500\n", " 1600\n", " 1700\n", " 1800\n", " 1900\n", " 2000\n", " \n", " \n", " f(x)\n", " \n", " \n", " Our Plot\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n", "\n", "\n" ], "text/plain": [ "Plot(...)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "plot2 = plot(\n", " x=1:10,\n", " y=x.^3,\n", " Guide.ylabel(\"f(x)\"), # label for y-axis\n", " Guide.xlabel(\"x\"), # label for x-axis\n", " Guide.title(\"Our Plot\"), # a title\n", " Geom.line\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also plot histograms using the Geom argument" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " 0.0\n", " 0.5\n", " 1.0\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " 0\n", " 5\n", " 10\n", " 15\n", " \n", " \n", " #\n", " \n", " \n", " Our Histogram\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " -1.5\n", " -1.0\n", " -0.5\n", " 0.0\n", " 0.5\n", " 1.0\n", " 1.5\n", " 2.0\n", " 2.5\n", " -1.00\n", " -0.95\n", " -0.90\n", " -0.85\n", " -0.80\n", " -0.75\n", " -0.70\n", " -0.65\n", " -0.60\n", " -0.55\n", " -0.50\n", " -0.45\n", " -0.40\n", " -0.35\n", " -0.30\n", " -0.25\n", " -0.20\n", " -0.15\n", " -0.10\n", " -0.05\n", " 0.00\n", " 0.05\n", " 0.10\n", " 0.15\n", " 0.20\n", " 0.25\n", " 0.30\n", " 0.35\n", " 0.40\n", " 0.45\n", " 0.50\n", " 0.55\n", " 0.60\n", " 0.65\n", " 0.70\n", " 0.75\n", " 0.80\n", " 0.85\n", " 0.90\n", " 0.95\n", " 1.00\n", " 1.05\n", " 1.10\n", " 1.15\n", " 1.20\n", " 1.25\n", " 1.30\n", " 1.35\n", " 1.40\n", " 1.45\n", " 1.50\n", " 1.55\n", " 1.60\n", " 1.65\n", " 1.70\n", " 1.75\n", " 1.80\n", " 1.85\n", " 1.90\n", " 1.95\n", " 2.00\n", " -1\n", " 0\n", " 1\n", " 2\n", " -1.0\n", " -0.9\n", " -0.8\n", " -0.7\n", " -0.6\n", " -0.5\n", " -0.4\n", " -0.3\n", " -0.2\n", " -0.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\n", " 1.1\n", " 1.2\n", " 1.3\n", " 1.4\n", " 1.5\n", " 1.6\n", " 1.7\n", " 1.8\n", " 1.9\n", " 2.0\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " -20\n", " -15\n", " -10\n", " -5\n", " 0\n", " 5\n", " 10\n", " 15\n", " 20\n", " 25\n", " 30\n", " 35\n", " -15.0\n", " -14.5\n", " -14.0\n", " -13.5\n", " -13.0\n", " -12.5\n", " -12.0\n", " -11.5\n", " -11.0\n", " -10.5\n", " -10.0\n", " -9.5\n", " -9.0\n", " -8.5\n", " -8.0\n", " -7.5\n", " -7.0\n", " -6.5\n", " -6.0\n", " -5.5\n", " -5.0\n", " -4.5\n", " -4.0\n", " -3.5\n", " -3.0\n", " -2.5\n", " -2.0\n", " -1.5\n", " -1.0\n", " -0.5\n", " 0.0\n", " 0.5\n", " 1.0\n", " 1.5\n", " 2.0\n", " 2.5\n", " 3.0\n", " 3.5\n", " 4.0\n", " 4.5\n", " 5.0\n", " 5.5\n", " 6.0\n", " 6.5\n", " 7.0\n", " 7.5\n", " 8.0\n", " 8.5\n", " 9.0\n", " 9.5\n", " 10.0\n", " 10.5\n", " 11.0\n", " 11.5\n", " 12.0\n", " 12.5\n", " 13.0\n", " 13.5\n", " 14.0\n", " 14.5\n", " 15.0\n", " 15.5\n", " 16.0\n", " 16.5\n", " 17.0\n", " 17.5\n", " 18.0\n", " 18.5\n", " 19.0\n", " 19.5\n", " 20.0\n", " 20.5\n", " 21.0\n", " 21.5\n", " 22.0\n", " 22.5\n", " 23.0\n", " 23.5\n", " 24.0\n", " 24.5\n", " 25.0\n", " 25.5\n", " 26.0\n", " 26.5\n", " 27.0\n", " 27.5\n", " 28.0\n", " 28.5\n", " 29.0\n", " 29.5\n", " 30.0\n", " -20\n", " 0\n", " 20\n", " 40\n", " -15\n", " -14\n", " -13\n", " -12\n", " -11\n", " -10\n", " -9\n", " -8\n", " -7\n", " -6\n", " -5\n", " -4\n", " -3\n", " -2\n", " -1\n", " 0\n", " 1\n", " 2\n", " 3\n", " 4\n", " 5\n", " 6\n", " 7\n", " 8\n", " 9\n", " 10\n", " 11\n", " 12\n", " 13\n", " 14\n", " 15\n", " 16\n", " 17\n", " 18\n", " 19\n", " 20\n", " 21\n", " 22\n", " 23\n", " 24\n", " 25\n", " 26\n", " 27\n", " 28\n", " 29\n", " 30\n", " \n", " \n", " #\n", " \n", " \n", " Our Histogram\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n", "\n", "\n" ], "text/plain": [ "Plot(...)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "plot2 = plot(\n", " x=rand(1000),\n", " Guide.ylabel(\"#\"), # label for y-axis\n", " Guide.xlabel(\"x\"), # label for x-axis\n", " Guide.title(\"Our Histogram\"), # a title\n", " Geom.histogram\n", " )" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " 0.0\n", " 0.5\n", " 1.0\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " 0\n", " 20\n", " 40\n", " 60\n", " 80\n", " 100\n", " 120\n", " \n", " \n", " #\n", " \n", " \n", " Our Histogram\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " -1.5\n", " -1.0\n", " -0.5\n", " 0.0\n", " 0.5\n", " 1.0\n", " 1.5\n", " 2.0\n", " 2.5\n", " -1.00\n", " -0.95\n", " -0.90\n", " -0.85\n", " -0.80\n", " -0.75\n", " -0.70\n", " -0.65\n", " -0.60\n", " -0.55\n", " -0.50\n", " -0.45\n", " -0.40\n", " -0.35\n", " -0.30\n", " -0.25\n", " -0.20\n", " -0.15\n", " -0.10\n", " -0.05\n", " 0.00\n", " 0.05\n", " 0.10\n", " 0.15\n", " 0.20\n", " 0.25\n", " 0.30\n", " 0.35\n", " 0.40\n", " 0.45\n", " 0.50\n", " 0.55\n", " 0.60\n", " 0.65\n", " 0.70\n", " 0.75\n", " 0.80\n", " 0.85\n", " 0.90\n", " 0.95\n", " 1.00\n", " 1.05\n", " 1.10\n", " 1.15\n", " 1.20\n", " 1.25\n", " 1.30\n", " 1.35\n", " 1.40\n", " 1.45\n", " 1.50\n", " 1.55\n", " 1.60\n", " 1.65\n", " 1.70\n", " 1.75\n", " 1.80\n", " 1.85\n", " 1.90\n", " 1.95\n", " 2.00\n", " -1\n", " 0\n", " 1\n", " 2\n", " -1.0\n", " -0.9\n", " -0.8\n", " -0.7\n", " -0.6\n", " -0.5\n", " -0.4\n", " -0.3\n", " -0.2\n", " -0.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\n", " 1.1\n", " 1.2\n", " 1.3\n", " 1.4\n", " 1.5\n", " 1.6\n", " 1.7\n", " 1.8\n", " 1.9\n", " 2.0\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " 0\n", " 20\n", " 40\n", " 60\n", " 80\n", " 100\n", " 120\n", " \n", " \n", " #\n", " \n", " \n", " Our Histogram\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n", "\n", "\n" ], "text/plain": [ "Plot(...)" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "plot2 = plot(\n", " x=rand(1000),\n", " Guide.ylabel(\"#\"), # label for y-axis\n", " Guide.xlabel(\"x\"), # label for x-axis\n", " Guide.title(\"Our Histogram\"), # a title\n", " Guide.yticks(ticks=[0:20:120]),\n", " Geom.histogram(bincount=10)\n", " )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also plot using a function rather than going through all of that" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "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", "image/svg+xml": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " 0\n", " 5\n", " 10\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " 0\n", " 500\n", " 1000\n", " \n", " \n", " f(x)\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n" ], "text/html": [ "\n", "\n", "\n", " \n", " x\n", " \n", " \n", " -15\n", " -10\n", " -5\n", " 0\n", " 5\n", " 10\n", " 15\n", " 20\n", " 25\n", " -10.0\n", " -9.5\n", " -9.0\n", " -8.5\n", " -8.0\n", " -7.5\n", " -7.0\n", " -6.5\n", " -6.0\n", " -5.5\n", " -5.0\n", " -4.5\n", " -4.0\n", " -3.5\n", " -3.0\n", " -2.5\n", " -2.0\n", " -1.5\n", " -1.0\n", " -0.5\n", " 0.0\n", " 0.5\n", " 1.0\n", " 1.5\n", " 2.0\n", " 2.5\n", " 3.0\n", " 3.5\n", " 4.0\n", " 4.5\n", " 5.0\n", " 5.5\n", " 6.0\n", " 6.5\n", " 7.0\n", " 7.5\n", " 8.0\n", " 8.5\n", " 9.0\n", " 9.5\n", " 10.0\n", " 10.5\n", " 11.0\n", " 11.5\n", " 12.0\n", " 12.5\n", " 13.0\n", " 13.5\n", " 14.0\n", " 14.5\n", " 15.0\n", " 15.5\n", " 16.0\n", " 16.5\n", " 17.0\n", " 17.5\n", " 18.0\n", " 18.5\n", " 19.0\n", " 19.5\n", " 20.0\n", " -10\n", " 0\n", " 10\n", " 20\n", " -10\n", " -9\n", " -8\n", " -7\n", " -6\n", " -5\n", " -4\n", " -3\n", " -2\n", " -1\n", " 0\n", " 1\n", " 2\n", " 3\n", " 4\n", " 5\n", " 6\n", " 7\n", " 8\n", " 9\n", " 10\n", " 11\n", " 12\n", " 13\n", " 14\n", " 15\n", " 16\n", " 17\n", " 18\n", " 19\n", " 20\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " -1500\n", " -1000\n", " -500\n", " 0\n", " 500\n", " 1000\n", " 1500\n", " 2000\n", " 2500\n", " -1000\n", " -950\n", " -900\n", " -850\n", " -800\n", " -750\n", " -700\n", " -650\n", " -600\n", " -550\n", " -500\n", " -450\n", " -400\n", " -350\n", " -300\n", " -250\n", " -200\n", " -150\n", " -100\n", " -50\n", " 0\n", " 50\n", " 100\n", " 150\n", " 200\n", " 250\n", " 300\n", " 350\n", " 400\n", " 450\n", " 500\n", " 550\n", " 600\n", " 650\n", " 700\n", " 750\n", " 800\n", " 850\n", " 900\n", " 950\n", " 1000\n", " 1050\n", " 1100\n", " 1150\n", " 1200\n", " 1250\n", " 1300\n", " 1350\n", " 1400\n", " 1450\n", " 1500\n", " 1550\n", " 1600\n", " 1650\n", " 1700\n", " 1750\n", " 1800\n", " 1850\n", " 1900\n", " 1950\n", " 2000\n", " -1000\n", " 0\n", " 1000\n", " 2000\n", " -1000\n", " -900\n", " -800\n", " -700\n", " -600\n", " -500\n", " -400\n", " -300\n", " -200\n", " -100\n", " 0\n", " 100\n", " 200\n", " 300\n", " 400\n", " 500\n", " 600\n", " 700\n", " 800\n", " 900\n", " 1000\n", " 1100\n", " 1200\n", " 1300\n", " 1400\n", " 1500\n", " 1600\n", " 1700\n", " 1800\n", " 1900\n", " 2000\n", " \n", " \n", " f(x)\n", " \n", "\n", "\n", "\n", " \n", "\n", "\n", "\n", "\n" ], "text/plain": [ "Plot(...)" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f(x) = x.^3\n", "\n", "plot2 = plot(f, 0, 10)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If we want more than one plot on a figure we use layers" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [], "source": [ "plot2 = plot(\n", "layer(\n", " x=1:10,\n", " y=x.^3,\n", " Geom.line),\n", "layer(\n", " x=1:10,\n", " y=(x-0.5).^3,\n", "Geom.point),\n", "\n", " Guide.ylabel(\"f(x)\"), # label for y-axis\n", " Guide.xlabel(\"x\"), # label for x-axis\n", " Guide.title(\"Our Plot\")\n", " )\n", "\n", "draw(PNG(\"plt.png\", 16cm, 12cm),plot2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#Calling Python" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As julia is a young language, it may not contain all the functionality that you are looking for. We can solve this by importing from Python" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": true }, "outputs": [], "source": [ "using PyCall" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can call basic inline functions" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pyeval(\"2+4\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But more usefully we can import Python modules into julia" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "50-element Array{Float64,1}:\n", " 1.0 \n", " 3.02041\n", " 5.04082\n", " 7.06122\n", " 9.08163\n", " 11.102 \n", " 13.1224 \n", " 15.1429 \n", " 17.1633 \n", " 19.1837 \n", " 21.2041 \n", " 23.2245 \n", " 25.2449 \n", " ⋮ \n", " 77.7755 \n", " 79.7959 \n", " 81.8163 \n", " 83.8367 \n", " 85.8571 \n", " 87.8776 \n", " 89.898 \n", " 91.9184 \n", " 93.9388 \n", " 95.9592 \n", " 97.9796 \n", " 100.0 " ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "@pyimport numpy as np\n", "\n", "np.linspace(1,100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#Calling C" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can call C functions as well, from all shared libraries. This capability is inbuilt into Julia and is accessed with ccall" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "112251247" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t1 = ccall( (:clock, \"libc\"), Int32, ())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can nicely wrap this into a julia function for ease" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "112256120" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function ctime()\n", " t1 = ccall( (:clock, \"libc\"), Int32, ())\n", "end\n", "\n", "ctime()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If you run the code below you will download another notebook that can then be opened via the link..." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [ "run(`wget https://raw.githubusercontent.com/josh-gree/juliafiles/master/Fractal-timing-Julia-vs-Python.ipynb`)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Link to [Benchmarks - julia sets](Fractal-timing-Julia-vs-Python.ipynb)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Julia 0.3.7", "language": "julia", "name": "julia 0.3" }, "language_info": { "name": "julia", "version": "0.3.7" } }, "nbformat": 4, "nbformat_minor": 0 }