0 - Getting started.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting started\n",
    "\n",
    "Topics:\n",
    "1.  How to print\n",
    "2. How to assign variables\n",
    "3. How to comment\n",
    "4. Syntax for basic math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to print\n",
    "\n",
    "In Julia we usually use `println()` to print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm excited to learn Julia!\n"
     ]
    }
   ],
   "source": [
    "println(\"I'm excited to learn Julia!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to assign variables\n",
    "\n",
    "All we need is a variable name, value, and an equal's sign!<br>\n",
    "Julia will figure out types for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_answer = 42\n",
    "typeof(my_answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Float64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_pi = 3.14159\n",
    "typeof(my_pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "String"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "😺 = \"smiley cat!\"\n",
    "typeof(😺)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To type a smiley cat, use tab completion to select the emoji name and then tab again"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \\:smi + <tab> --> select with down arrow + <enter> ---> <tab> + <enter> to complete"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After assigning a value to a variable, we can reassign a value of a different type to that variable without any issue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "😺 = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(😺)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Julia allows us to write super generic code, and 😺 is an example of this. \n",
    "\n",
    "This allows us to write code like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "😀 = 0\n",
    "😞 = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "😺 + 😞 == 😀"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can leave comments on a single line using the pound/hash key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#=\n",
    "\n",
    "For multi-line comments, \n",
    "use the '#= =#' sequence.\n",
    "\n",
    "=#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Syntax for basic math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum = 3 + 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "difference = 10 - 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product = 20 * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quotient = 100 / 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power = 10 ^ 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "modulus = 101 % 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercises\n",
    "\n",
    "#### 1.1 \n",
    "Look up docs for the `convert` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mv\u001b[22m\u001b[0m\u001b[1me\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1mt\u001b[22m \u001b[0m\u001b[1mC\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1mn\u001b[22mcurrency\u001b[0m\u001b[1mV\u001b[22miolation\u001b[0m\u001b[1mE\u001b[22m\u001b[0m\u001b[1mr\u001b[22mror \u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22mde_\u001b[0m\u001b[1mn\u001b[22mati\u001b[0m\u001b[1mv\u001b[22m\u001b[0m\u001b[1me\u001b[22m @\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mo\u001b[22mde_\u001b[0m\u001b[1mn\u001b[22mati\u001b[0m\u001b[1mv\u001b[22m\u001b[0m\u001b[1me\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "convert(T, x)\n",
       "\\end{verbatim}\n",
       "Convert \\texttt{x} to a value of type \\texttt{T}.\n",
       "\n",
       "If \\texttt{T} is an \\href{@ref}{\\texttt{Integer}} type, an \\href{@ref}{\\texttt{InexactError}} will be raised if \\texttt{x} is not representable by \\texttt{T}, for example if \\texttt{x} is not integer-valued, or is outside the range supported by \\texttt{T}.\n",
       "\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> convert(Int, 3.0)\n",
       "3\n",
       "\n",
       "julia> convert(Int, 3.5)\n",
       "ERROR: InexactError: Int64(3.5)\n",
       "Stacktrace:\n",
       "[...]\n",
       "\\end{verbatim}\n",
       "If \\texttt{T} is a \\href{@ref}{\\texttt{AbstractFloat}} type, then it will return the closest value to \\texttt{x} representable by \\texttt{T}.\n",
       "\n",
       "\\begin{verbatim}\n",
       "julia> x = 1/3\n",
       "0.3333333333333333\n",
       "\n",
       "julia> convert(Float32, x)\n",
       "0.33333334f0\n",
       "\n",
       "julia> convert(BigFloat, x)\n",
       "0.333333333333333314829616256247390992939472198486328125\n",
       "\\end{verbatim}\n",
       "If \\texttt{T} is a collection type and \\texttt{x} a collection, the result of \\texttt{convert(T, x)} may alias all or part of \\texttt{x}.\n",
       "\n",
       "\\begin{verbatim}\n",
       "julia> x = Int[1, 2, 3];\n",
       "\n",
       "julia> y = convert(Vector{Int}, x);\n",
       "\n",
       "julia> y === x\n",
       "true\n",
       "\\end{verbatim}\n",
       "See also: \\href{@ref}{\\texttt{round}}, \\href{@ref}{\\texttt{trunc}}, \\href{@ref}{\\texttt{oftype}}, \\href{@ref}{\\texttt{reinterpret}}.\n",
       "\n"
      ],
      "text/markdown": [
       "```\n",
       "convert(T, x)\n",
       "```\n",
       "\n",
       "Convert `x` to a value of type `T`.\n",
       "\n",
       "If `T` is an [`Integer`](@ref) type, an [`InexactError`](@ref) will be raised if `x` is not representable by `T`, for example if `x` is not integer-valued, or is outside the range supported by `T`.\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> convert(Int, 3.0)\n",
       "3\n",
       "\n",
       "julia> convert(Int, 3.5)\n",
       "ERROR: InexactError: Int64(3.5)\n",
       "Stacktrace:\n",
       "[...]\n",
       "```\n",
       "\n",
       "If `T` is a [`AbstractFloat`](@ref) type, then it will return the closest value to `x` representable by `T`.\n",
       "\n",
       "```jldoctest\n",
       "julia> x = 1/3\n",
       "0.3333333333333333\n",
       "\n",
       "julia> convert(Float32, x)\n",
       "0.33333334f0\n",
       "\n",
       "julia> convert(BigFloat, x)\n",
       "0.333333333333333314829616256247390992939472198486328125\n",
       "```\n",
       "\n",
       "If `T` is a collection type and `x` a collection, the result of `convert(T, x)` may alias all or part of `x`.\n",
       "\n",
       "```jldoctest\n",
       "julia> x = Int[1, 2, 3];\n",
       "\n",
       "julia> y = convert(Vector{Int}, x);\n",
       "\n",
       "julia> y === x\n",
       "true\n",
       "```\n",
       "\n",
       "See also: [`round`](@ref), [`trunc`](@ref), [`oftype`](@ref), [`reinterpret`](@ref).\n"
      ],
      "text/plain": [
       "\u001b[36m  convert(T, x)\u001b[39m\n",
       "\n",
       "  Convert \u001b[36mx\u001b[39m to a value of type \u001b[36mT\u001b[39m.\n",
       "\n",
       "  If \u001b[36mT\u001b[39m is an \u001b[36mInteger\u001b[39m type, an \u001b[36mInexactError\u001b[39m will be raised if \u001b[36mx\u001b[39m is not\n",
       "  representable by \u001b[36mT\u001b[39m, for example if \u001b[36mx\u001b[39m is not integer-valued, or is outside\n",
       "  the range supported by \u001b[36mT\u001b[39m.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> convert(Int, 3.0)\u001b[39m\n",
       "\u001b[36m  3\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> convert(Int, 3.5)\u001b[39m\n",
       "\u001b[36m  ERROR: InexactError: Int64(3.5)\u001b[39m\n",
       "\u001b[36m  Stacktrace:\u001b[39m\n",
       "\u001b[36m  [...]\u001b[39m\n",
       "\n",
       "  If \u001b[36mT\u001b[39m is a \u001b[36mAbstractFloat\u001b[39m type, then it will return the closest value to \u001b[36mx\u001b[39m\n",
       "  representable by \u001b[36mT\u001b[39m.\n",
       "\n",
       "\u001b[36m  julia> x = 1/3\u001b[39m\n",
       "\u001b[36m  0.3333333333333333\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> convert(Float32, x)\u001b[39m\n",
       "\u001b[36m  0.33333334f0\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> convert(BigFloat, x)\u001b[39m\n",
       "\u001b[36m  0.333333333333333314829616256247390992939472198486328125\u001b[39m\n",
       "\n",
       "  If \u001b[36mT\u001b[39m is a collection type and \u001b[36mx\u001b[39m a collection, the result of \u001b[36mconvert(T, x)\u001b[39m\n",
       "  may alias all or part of \u001b[36mx\u001b[39m.\n",
       "\n",
       "\u001b[36m  julia> x = Int[1, 2, 3];\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> y = convert(Vector{Int}, x);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> y === x\u001b[39m\n",
       "\u001b[36m  true\u001b[39m\n",
       "\n",
       "  See also: \u001b[36mround\u001b[39m, \u001b[36mtrunc\u001b[39m, \u001b[36moftype\u001b[39m, \u001b[36mreinterpret\u001b[39m."
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? convert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.2 \n",
    "Assign `365` to a variable named `days`. Convert `days` to a float and assign it to variable `days_float`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "days = 365\n",
    "days_float = convert(Float64,days)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "deletable": false,
    "editable": false,
    "hide_input": true,
    "nbgrader": {
     "checksum": "a2dc243275e0310c3b29a745b952f321",
     "grade": true,
     "grade_id": "cell-715f78016beb0489",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "@assert days == 365\n",
    "@assert days_float == 365.0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.3 \n",
    "See what happens when you execute\n",
    "\n",
    "```julia\n",
    "convert(Int64, \"1\")\n",
    "```\n",
    "and\n",
    "\n",
    "```julia\n",
    "parse(Int64, \"1\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: \u001b[0mCannot `convert` an object of type \u001b[92mString\u001b[39m\u001b[0m to an object of type \u001b[91mInt64\u001b[39m\n\n\u001b[0mClosest candidates are:\n\u001b[0m  convert(::Type{T}, \u001b[91m::Ptr\u001b[39m) where T<:Integer\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mpointer.jl:23\u001b[24m\u001b[39m\n\u001b[0m  convert(::Type{T}, \u001b[91m::T\u001b[39m) where T<:Number\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mnumber.jl:6\u001b[24m\u001b[39m\n\u001b[0m  convert(::Type{T}, \u001b[91m::Number\u001b[39m) where T<:Number\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mnumber.jl:7\u001b[24m\u001b[39m\n\u001b[0m  ...\n",
     "output_type": "error",
     "traceback": [
      "MethodError: \u001b[0mCannot `convert` an object of type \u001b[92mString\u001b[39m\u001b[0m to an object of type \u001b[91mInt64\u001b[39m\n\n\u001b[0mClosest candidates are:\n\u001b[0m  convert(::Type{T}, \u001b[91m::Ptr\u001b[39m) where T<:Integer\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mpointer.jl:23\u001b[24m\u001b[39m\n\u001b[0m  convert(::Type{T}, \u001b[91m::T\u001b[39m) where T<:Number\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mnumber.jl:6\u001b[24m\u001b[39m\n\u001b[0m  convert(::Type{T}, \u001b[91m::Number\u001b[39m) where T<:Number\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mnumber.jl:7\u001b[24m\u001b[39m\n\u001b[0m  ...\n",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[13]:1"
     ]
    }
   ],
   "source": [
    "convert(Int64, \"1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parse(Int64, \"1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1me\u001b[22m try\u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1me\u001b[22m \u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22mtial\u001b[0m\u001b[1ms\u001b[22mortp\u001b[0m\u001b[1me\u001b[22mrm \u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22mtial\u001b[0m\u001b[1ms\u001b[22mortp\u001b[0m\u001b[1me\u001b[22mrm! \u001b[0m\u001b[1mp\u001b[22m\u001b[0m\u001b[1ma\u001b[22mi\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ms\u001b[22m ski\u001b[0m\u001b[1mp\u001b[22mch\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "parse(type, str; base)\n",
       "\\end{verbatim}\n",
       "Parse a string as a number. For \\texttt{Integer} types, a base can be specified (the default is 10). For floating-point types, the string is parsed as a decimal floating-point number.  \\texttt{Complex} types are parsed from decimal strings of the form \\texttt{\"R±Iim\"} as a \\texttt{Complex(R,I)} of the requested type; \\texttt{\"i\"} or \\texttt{\"j\"} can also be used instead of \\texttt{\"im\"}, and \\texttt{\"R\"} or \\texttt{\"Iim\"} are also permitted. If the string does not contain a valid number, an error is raised.\n",
       "\n",
       "\\begin{quote}\n",
       "\\textbf{compat}\n",
       "\n",
       "Julia 1.1\n",
       "\n",
       "\\texttt{parse(Bool, str)} requires at least Julia 1.1.\n",
       "\n",
       "\\end{quote}\n",
       "\\section{Examples}\n",
       "\\begin{verbatim}\n",
       "julia> parse(Int, \"1234\")\n",
       "1234\n",
       "\n",
       "julia> parse(Int, \"1234\", base = 5)\n",
       "194\n",
       "\n",
       "julia> parse(Int, \"afc\", base = 16)\n",
       "2812\n",
       "\n",
       "julia> parse(Float64, \"1.2e-3\")\n",
       "0.0012\n",
       "\n",
       "julia> parse(Complex{Float64}, \"3.2e-1 + 4.5im\")\n",
       "0.32 + 4.5im\n",
       "\\end{verbatim}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\begin{verbatim}\n",
       "parse(::Type{Platform}, triplet::AbstractString)\n",
       "\\end{verbatim}\n",
       "Parses a string platform triplet back into a \\texttt{Platform} object.\n",
       "\n"
      ],
      "text/markdown": [
       "```\n",
       "parse(type, str; base)\n",
       "```\n",
       "\n",
       "Parse a string as a number. For `Integer` types, a base can be specified (the default is 10). For floating-point types, the string is parsed as a decimal floating-point number.  `Complex` types are parsed from decimal strings of the form `\"R±Iim\"` as a `Complex(R,I)` of the requested type; `\"i\"` or `\"j\"` can also be used instead of `\"im\"`, and `\"R\"` or `\"Iim\"` are also permitted. If the string does not contain a valid number, an error is raised.\n",
       "\n",
       "!!! compat \"Julia 1.1\"\n",
       "    `parse(Bool, str)` requires at least Julia 1.1.\n",
       "\n",
       "\n",
       "# Examples\n",
       "\n",
       "```jldoctest\n",
       "julia> parse(Int, \"1234\")\n",
       "1234\n",
       "\n",
       "julia> parse(Int, \"1234\", base = 5)\n",
       "194\n",
       "\n",
       "julia> parse(Int, \"afc\", base = 16)\n",
       "2812\n",
       "\n",
       "julia> parse(Float64, \"1.2e-3\")\n",
       "0.0012\n",
       "\n",
       "julia> parse(Complex{Float64}, \"3.2e-1 + 4.5im\")\n",
       "0.32 + 4.5im\n",
       "```\n",
       "\n",
       "---\n",
       "\n",
       "```\n",
       "parse(::Type{Platform}, triplet::AbstractString)\n",
       "```\n",
       "\n",
       "Parses a string platform triplet back into a `Platform` object.\n"
      ],
      "text/plain": [
       "\u001b[36m  parse(type, str; base)\u001b[39m\n",
       "\n",
       "  Parse a string as a number. For \u001b[36mInteger\u001b[39m types, a base can be specified (the\n",
       "  default is 10). For floating-point types, the string is parsed as a decimal\n",
       "  floating-point number. \u001b[36mComplex\u001b[39m types are parsed from decimal strings of the\n",
       "  form \u001b[36m\"R±Iim\"\u001b[39m as a \u001b[36mComplex(R,I)\u001b[39m of the requested type; \u001b[36m\"i\"\u001b[39m or \u001b[36m\"j\"\u001b[39m can also be\n",
       "  used instead of \u001b[36m\"im\"\u001b[39m, and \u001b[36m\"R\"\u001b[39m or \u001b[36m\"Iim\"\u001b[39m are also permitted. If the string\n",
       "  does not contain a valid number, an error is raised.\n",
       "\n",
       "\u001b[39m\u001b[1m  │ \u001b[22m\u001b[39m\u001b[1mJulia 1.1\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m\n",
       "\u001b[39m\u001b[1m  │\u001b[22m  \u001b[36mparse(Bool, str)\u001b[39m requires at least Julia 1.1.\n",
       "\n",
       "\u001b[1m  Examples\u001b[22m\n",
       "\u001b[1m  ≡≡≡≡≡≡≡≡≡≡\u001b[22m\n",
       "\n",
       "\u001b[36m  julia> parse(Int, \"1234\")\u001b[39m\n",
       "\u001b[36m  1234\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> parse(Int, \"1234\", base = 5)\u001b[39m\n",
       "\u001b[36m  194\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> parse(Int, \"afc\", base = 16)\u001b[39m\n",
       "\u001b[36m  2812\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> parse(Float64, \"1.2e-3\")\u001b[39m\n",
       "\u001b[36m  0.0012\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> parse(Complex{Float64}, \"3.2e-1 + 4.5im\")\u001b[39m\n",
       "\u001b[36m  0.32 + 4.5im\u001b[39m\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[36m  parse(::Type{Platform}, triplet::AbstractString)\u001b[39m\n",
       "\n",
       "  Parses a string platform triplet back into a \u001b[36mPlatform\u001b[39m object."
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? parse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.9.3",
   "language": "julia",
   "name": "julia-1.9"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.9.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}