{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n"
     ]
    }
   ],
   "source": [
    "greeting = \"Hello world\"\n",
    "println(greeting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9800665778412416, 2.302585092994046, 1.22)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b,c = cos(0.2), log(10), abs(-1.22)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9800665778412416"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22m \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22mh \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22md \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22mc \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22mpi a\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22m a\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22mh a\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22md sin\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22m \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22mn\u001b[0m\u001b[1ms\u001b[22mt \u001b[0m\u001b[1mc\u001b[22ml\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ms\u001b[22me is\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22mn\u001b[0m\u001b[1ms\u001b[22mt\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "cos(x)\n",
       "\\end{verbatim}\n",
       "Compute cosine of \\texttt{x}, where \\texttt{x} is in radians.\n",
       "\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "cos(A::AbstractMatrix)\n",
       "\\end{verbatim}\n",
       "Compute the matrix cosine of a square matrix \\texttt{A}.\n",
       "\n",
       "If \\texttt{A} is symmetric or Hermitian, its eigendecomposition (\\href{@ref}{\\texttt{eigen}}) is used to compute the cosine. Otherwise, the cosine is determined by calling \\href{@ref}{\\texttt{exp}}.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> cos(fill(1.0, (2,2)))\n",
       "2×2 Array{Float64,2}:\n",
       "  0.291927  -0.708073\n",
       " -0.708073   0.291927\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "```\n",
       "cos(x)\n",
       "```\n",
       "\n",
       "Compute cosine of `x`, where `x` is in radians.\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "cos(A::AbstractMatrix)\n",
       "```\n",
       "\n",
       "Compute the matrix cosine of a square matrix `A`.\n",
       "\n",
       "If `A` is symmetric or Hermitian, its eigendecomposition ([`eigen`](@ref)) is used to compute the cosine. Otherwise, the cosine is determined by calling [`exp`](@ref).\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> cos(fill(1.0, (2,2)))\n",
       "2×2 Array{Float64,2}:\n",
       "  0.291927  -0.708073\n",
       " -0.708073   0.291927\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  cos(x)\u001b[39m\n",
       "\n",
       "  Compute cosine of \u001b[36mx\u001b[39m, where \u001b[36mx\u001b[39m is in radians.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  cos(A::AbstractMatrix)\u001b[39m\n",
       "\n",
       "  Compute the matrix cosine of a square matrix \u001b[36mA\u001b[39m.\n",
       "\n",
       "  If \u001b[36mA\u001b[39m is symmetric or Hermitian, its eigendecomposition (\u001b[36meigen\u001b[39m) is used to\n",
       "  compute the cosine. Otherwise, the cosine is determined by calling \u001b[36mexp\u001b[39m.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> cos(fill(1.0, (2,2)))\u001b[39m\n",
       "\u001b[36m  2×2 Array{Float64,2}:\u001b[39m\n",
       "\u001b[36m    0.291927  -0.708073\u001b[39m\n",
       "\u001b[36m   -0.708073   0.291927\u001b[39m"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? cos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cos(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cos(π)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.123233995736766e-17"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cos(π/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Irrational{:π}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(π)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "12 methods for generic function <b>muladd</b>:<ul><li> muladd(a::<b>Float16</b>, b::<b>Float16</b>, c::<b>Float16</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/float.jl#L406\" target=\"_blank\">float.jl:406</a></li> <li> muladd(x::<b>Float64</b>, y::<b>Float64</b>, z::<b>Float64</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/float.jl#L404\" target=\"_blank\">float.jl:404</a></li> <li> muladd(x::<b>Float32</b>, y::<b>Float32</b>, z::<b>Float32</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/float.jl#L403\" target=\"_blank\">float.jl:403</a></li> <li> muladd(z::<b>Complex</b>, w::<b>Complex</b>, x::<b>Complex</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/complex.jl#L272\" target=\"_blank\">complex.jl:272</a></li> <li> muladd(x::<b>Real</b>, z::<b>Complex</b>, y::<b>Number</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/complex.jl#L315\" target=\"_blank\">complex.jl:315</a></li> <li> muladd(z::<b>Complex</b>, x::<b>Real</b>, y::<b>Real</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/complex.jl#L316\" target=\"_blank\">complex.jl:316</a></li> <li> muladd(z::<b>Complex</b>, x::<b>Real</b>, w::<b>Complex</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/complex.jl#L317\" target=\"_blank\">complex.jl:317</a></li> <li> muladd(x::<b>Real</b>, y::<b>Real</b>, z::<b>Complex</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/complex.jl#L319\" target=\"_blank\">complex.jl:319</a></li> <li> muladd(z::<b>Complex</b>, w::<b>Complex</b>, x::<b>Real</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/complex.jl#L320\" target=\"_blank\">complex.jl:320</a></li> <li> muladd(x::<b>T</b>, y::<b>T</b>, z::<b>T</b>)<i> where T<:Number</i> in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/promotion.jl#L397\" target=\"_blank\">promotion.jl:397</a></li> <li> muladd(x::<b>Number</b>, y::<b>Number</b>, z::<b>Number</b>) in Base at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/promotion.jl#L348\" target=\"_blank\">promotion.jl:348</a></li> <li> muladd(x, y, z) in Base.Math at <a href=\"https://github.com/JuliaLang/julia/tree/c6da87ff4bc7a855e217856757ad3413cf6d1f79/base/math.jl#L1012\" target=\"_blank\">math.jl:1012</a></li> </ul>"
      ],
      "text/plain": [
       "# 12 methods for generic function \"muladd\":\n",
       "[1] muladd(a::Float16, b::Float16, c::Float16) in Base at float.jl:406\n",
       "[2] muladd(x::Float64, y::Float64, z::Float64) in Base at float.jl:404\n",
       "[3] muladd(x::Float32, y::Float32, z::Float32) in Base at float.jl:403\n",
       "[4] muladd(z::Complex, w::Complex, x::Complex) in Base at complex.jl:272\n",
       "[5] muladd(x::Real, z::Complex, y::Number) in Base at complex.jl:315\n",
       "[6] muladd(z::Complex, x::Real, y::Real) in Base at complex.jl:316\n",
       "[7] muladd(z::Complex, x::Real, w::Complex) in Base at complex.jl:317\n",
       "[8] muladd(x::Real, y::Real, z::Complex) in Base at complex.jl:319\n",
       "[9] muladd(z::Complex, w::Complex, x::Real) in Base at complex.jl:320\n",
       "[10] muladd(x::T, y::T, z::T) where T<:Number in Base at promotion.jl:397\n",
       "[11] muladd(x::Number, y::Number, z::Number) in Base at promotion.jl:348\n",
       "[12] muladd(x, y, z) in Base.Math at math.jl:1012"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(muladd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "myfunc (generic function with 1 method)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunc(firstvar) = 20* firstvar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6664.4439999999995"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunc(333.2222)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "addxtoy (generic function with 1 method)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addxtoy(x,y) = x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18.8"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addxtoy(22,-3.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nextfunc (generic function with 1 method)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function nextfunc(x,y,z)\n",
    "     x+y*z\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "showdebugprintln (generic function with 1 method)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function showdebugprintln(testvar)\n",
    "    println(\"Show inside the showdebugprintln() now\")\n",
    "    println(\"The type of testvar is $(typeof(testvar)) and the value of testvar is $testvar\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{Any,1}:\n",
       "  '1'\n",
       " 2.0 "
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = ['1',2.]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Show inside the showdebugprintln() now\n",
      "The type of testvar is Array{Any,1} and the value of testvar is Any['1', 2.0]\n"
     ]
    }
   ],
   "source": [
    "showdebugprintln(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mycos (generic function with 1 method)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycos(x) = cos(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.955336489125606"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycos(.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mycos (generic function with 2 methods)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycos(adj,hyp) = adj/hyp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9230769230769231"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycos(12,13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "2 methods for generic function <b>mycos</b>:<ul><li> mycos(x) in Main at In[28]:1</li> <li> mycos(adj, hyp) in Main at In[30]:1</li> </ul>"
      ],
      "text/plain": [
       "# 2 methods for generic function \"mycos\":\n",
       "[1] mycos(x) in Main at In[28]:1\n",
       "[2] mycos(adj, hyp) in Main at In[30]:1"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(mycos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mycos (generic function with 3 methods)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mycos(thet::Float64) = cos(thet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "84.0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "60 \\ 5040"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1m\\\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "\\(x, y)\n",
       "\\end{verbatim}\n",
       "Left division operator: multiplication of \\texttt{y} by the inverse of \\texttt{x} on the left. Gives floating-point results for integer arguments.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> 3 \\ 6\n",
       "2.0\n",
       "\n",
       "julia> inv(3) * 6\n",
       "2.0\n",
       "\n",
       "julia> A = [4 3; 2 1]; x = [5, 6];\n",
       "\n",
       "julia> A \\ x\n",
       "2-element Array{Float64,1}:\n",
       "  6.5\n",
       " -7.0\n",
       "\n",
       "julia> inv(A) * x\n",
       "2-element Array{Float64,1}:\n",
       "  6.5\n",
       " -7.0\n",
       "\\end{verbatim}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "\\(A, B)\n",
       "\\end{verbatim}\n",
       "Matrix division using a polyalgorithm. For input matrices \\texttt{A} and \\texttt{B}, the result \\texttt{X} is such that \\texttt{A*X == B} when \\texttt{A} is square. The solver that is used depends upon the structure of \\texttt{A}.  If \\texttt{A} is upper or lower triangular (or diagonal), no factorization of \\texttt{A} is required and the system is solved with either forward or backward substitution. For non-triangular square matrices, an LU factorization is used.\n",
       "\n",
       "For rectangular \\texttt{A} the result is the minimum-norm least squares solution computed by a pivoted QR factorization of \\texttt{A} and a rank estimate of \\texttt{A} based on the R factor.\n",
       "\n",
       "When \\texttt{A} is sparse, a similar polyalgorithm is used. For indefinite matrices, the \\texttt{LDLt} factorization does not use pivoting during the numerical factorization and therefore the procedure can fail even for invertible matrices.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> A = [1 0; 1 -2]; B = [32; -4];\n",
       "\n",
       "julia> X = A \\ B\n",
       "2-element Array{Float64,1}:\n",
       " 32.0\n",
       " 18.0\n",
       "\n",
       "julia> A * X == B\n",
       "true\n",
       "\\end{verbatim}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "(\\)(F::QRSparse, B::StridedVecOrMat)\n",
       "\\end{verbatim}\n",
       "Solve the least squares problem $\\min\\|Ax - b\\|^2$ or the linear system of equations $Ax=b$ when \\texttt{F} is the sparse QR factorization of $A$. A basic solution is returned when the problem is underdetermined.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> A = sparse([1,2,4], [1,1,1], [1.0,1.0,1.0], 4, 2)\n",
       "4×2 SparseMatrixCSC{Float64,Int64} with 3 stored entries:\n",
       "  [1, 1]  =  1.0\n",
       "  [2, 1]  =  1.0\n",
       "  [4, 1]  =  1.0\n",
       "\n",
       "julia> qr(A)\\fill(1.0, 4)\n",
       "2-element Array{Float64,1}:\n",
       " 1.0\n",
       " 0.0\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "```\n",
       "\\(x, y)\n",
       "```\n",
       "\n",
       "Left division operator: multiplication of `y` by the inverse of `x` on the left. Gives floating-point results for integer arguments.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> 3 \\ 6\n",
       "2.0\n",
       "\n",
       "julia> inv(3) * 6\n",
       "2.0\n",
       "\n",
       "julia> A = [4 3; 2 1]; x = [5, 6];\n",
       "\n",
       "julia> A \\ x\n",
       "2-element Array{Float64,1}:\n",
       "  6.5\n",
       " -7.0\n",
       "\n",
       "julia> inv(A) * x\n",
       "2-element Array{Float64,1}:\n",
       "  6.5\n",
       " -7.0\n",
       "```\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "\\(A, B)\n",
       "```\n",
       "\n",
       "Matrix division using a polyalgorithm. For input matrices `A` and `B`, the result `X` is such that `A*X == B` when `A` is square. The solver that is used depends upon the structure of `A`.  If `A` is upper or lower triangular (or diagonal), no factorization of `A` is required and the system is solved with either forward or backward substitution. For non-triangular square matrices, an LU factorization is used.\n",
       "\n",
       "For rectangular `A` the result is the minimum-norm least squares solution computed by a pivoted QR factorization of `A` and a rank estimate of `A` based on the R factor.\n",
       "\n",
       "When `A` is sparse, a similar polyalgorithm is used. For indefinite matrices, the `LDLt` factorization does not use pivoting during the numerical factorization and therefore the procedure can fail even for invertible matrices.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> A = [1 0; 1 -2]; B = [32; -4];\n",
       "\n",
       "julia> X = A \\ B\n",
       "2-element Array{Float64,1}:\n",
       " 32.0\n",
       " 18.0\n",
       "\n",
       "julia> A * X == B\n",
       "true\n",
       "```\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "(\\)(F::QRSparse, B::StridedVecOrMat)\n",
       "```\n",
       "\n",
       "Solve the least squares problem $\\min\\|Ax - b\\|^2$ or the linear system of equations $Ax=b$ when `F` is the sparse QR factorization of $A$. A basic solution is returned when the problem is underdetermined.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> A = sparse([1,2,4], [1,1,1], [1.0,1.0,1.0], 4, 2)\n",
       "4×2 SparseMatrixCSC{Float64,Int64} with 3 stored entries:\n",
       "  [1, 1]  =  1.0\n",
       "  [2, 1]  =  1.0\n",
       "  [4, 1]  =  1.0\n",
       "\n",
       "julia> qr(A)\\fill(1.0, 4)\n",
       "2-element Array{Float64,1}:\n",
       " 1.0\n",
       " 0.0\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  \\(x, y)\u001b[39m\n",
       "\n",
       "  Left division operator: multiplication of \u001b[36my\u001b[39m by the inverse of \u001b[36mx\u001b[39m on the left.\n",
       "  Gives floating-point results for integer arguments.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> 3 \\ 6\u001b[39m\n",
       "\u001b[36m  2.0\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> inv(3) * 6\u001b[39m\n",
       "\u001b[36m  2.0\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> A = [4 3; 2 1]; x = [5, 6];\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> A \\ x\u001b[39m\n",
       "\u001b[36m  2-element Array{Float64,1}:\u001b[39m\n",
       "\u001b[36m    6.5\u001b[39m\n",
       "\u001b[36m   -7.0\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> inv(A) * x\u001b[39m\n",
       "\u001b[36m  2-element Array{Float64,1}:\u001b[39m\n",
       "\u001b[36m    6.5\u001b[39m\n",
       "\u001b[36m   -7.0\u001b[39m\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  \\(A, B)\u001b[39m\n",
       "\n",
       "  Matrix division using a polyalgorithm. For input matrices \u001b[36mA\u001b[39m and \u001b[36mB\u001b[39m, the\n",
       "  result \u001b[36mX\u001b[39m is such that \u001b[36mA*X == B\u001b[39m when \u001b[36mA\u001b[39m is square. The solver that is used\n",
       "  depends upon the structure of \u001b[36mA\u001b[39m. If \u001b[36mA\u001b[39m is upper or lower triangular (or\n",
       "  diagonal), no factorization of \u001b[36mA\u001b[39m is required and the system is solved with\n",
       "  either forward or backward substitution. For non-triangular square matrices,\n",
       "  an LU factorization is used.\n",
       "\n",
       "  For rectangular \u001b[36mA\u001b[39m the result is the minimum-norm least squares solution\n",
       "  computed by a pivoted QR factorization of \u001b[36mA\u001b[39m and a rank estimate of \u001b[36mA\u001b[39m based\n",
       "  on the R factor.\n",
       "\n",
       "  When \u001b[36mA\u001b[39m is sparse, a similar polyalgorithm is used. For indefinite matrices,\n",
       "  the \u001b[36mLDLt\u001b[39m factorization does not use pivoting during the numerical\n",
       "  factorization and therefore the procedure can fail even for invertible\n",
       "  matrices.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> A = [1 0; 1 -2]; B = [32; -4];\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> X = A \\ B\u001b[39m\n",
       "\u001b[36m  2-element Array{Float64,1}:\u001b[39m\n",
       "\u001b[36m   32.0\u001b[39m\n",
       "\u001b[36m   18.0\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> A * X == B\u001b[39m\n",
       "\u001b[36m  true\u001b[39m\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  (\\)(F::QRSparse, B::StridedVecOrMat)\u001b[39m\n",
       "\n",
       "  Solve the least squares problem \u001b[35m\\min\\|Ax - b\\|^2\u001b[39m or the linear system of\n",
       "  equations \u001b[35mAx=b\u001b[39m when \u001b[36mF\u001b[39m is the sparse QR factorization of \u001b[35mA\u001b[39m. A basic solution\n",
       "  is returned when the problem is underdetermined.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> A = sparse([1,2,4], [1,1,1], [1.0,1.0,1.0], 4, 2)\u001b[39m\n",
       "\u001b[36m  4×2 SparseMatrixCSC{Float64,Int64} with 3 stored entries:\u001b[39m\n",
       "\u001b[36m    [1, 1]  =  1.0\u001b[39m\n",
       "\u001b[36m    [2, 1]  =  1.0\u001b[39m\n",
       "\u001b[36m    [4, 1]  =  1.0\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> qr(A)\\fill(1.0, 4)\u001b[39m\n",
       "\u001b[36m  2-element Array{Float64,1}:\u001b[39m\n",
       "\u001b[36m   1.0\u001b[39m\n",
       "\u001b[36m   0.0\u001b[39m"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? \\"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "84.0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5040/60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "addone (generic function with 1 method)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "addone(x::Int64) = x+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "MethodError",
     "evalue": "MethodError: no method matching addone(::Float64)\nClosest candidates are:\n  addone(!Matched::Int64) at In[38]:1",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching addone(::Float64)\nClosest candidates are:\n  addone(!Matched::Int64) at In[38]:1",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[42]:1"
     ]
    }
   ],
   "source": [
    "addone(ceil(1.2)*10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b=1,2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a,b=b,a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    }
   ],
   "source": [
    "function test(input)\n",
    "  println(\"$input\"^2)\n",
    "end\n",
    "\n",
    "test(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Nothing"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(test(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "add2 (generic function with 1 method)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add2(x,y) = return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "println(add2(5, 7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "coordinates (generic function with 3 methods)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function coordinates(x, y=0, z=0)\n",
    "  println(\"($x, $y, $z)\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 0, 2)\n"
     ]
    }
   ],
   "source": [
    "coordinates(1,0,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.2.0",
   "language": "julia",
   "name": "julia-1.2"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
