{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conhecendo a linguagem Julia\n",
    "\n",
    "Neste documento, apresentamos a sintaxe básica da linguagem Julia.\n",
    "Nosso objetivo é mostrar que essa linguagem é leve e fácil de usar.\n",
    "\n",
    "Vamos apresentar\n",
    "- Números\n",
    "- Strings\n",
    "- Estruturas de dados\n",
    "- Laços\n",
    "- Condicionais\n",
    "- Funções"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Números"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4.9"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2.6\n",
    "y = -7.5\n",
    "x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = sqrt(x^2 + y^2);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.937883848986454"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 1\n",
    "b = 0\n",
    "a == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Quantas vezes \""
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string1 = \"Quantas vezes \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"você leu a apostila?\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string2 = \"você leu a apostila?\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Quantas vezes você leu a apostila?\""
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string(string1, string2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Não me lembro bem, mas pelo menos umas 2 vezes.\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "println(\"Não me lembro bem, mas pelo menos umas $x vezes.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estruturas de dados"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uplas\n",
    "\n",
    "Podemos criar uma upla especificando uma sequência ordenada de elementos entre parêntesis `()`.\n",
    "```julia\n",
    "(item1, item2, ...)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(\"melão\", \"abacaxi\", \"manga\")"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frutas = (\"melão\", \"abacaxi\", \"manga\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"melão\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frutas[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, -3)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = (5, -3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dicionários\n",
    "\n",
    "Se temos conjuntos de dados relacionados um ao outro, podemos armazená-los em um dicionário.\n",
    "Para fazer isso, usamos a função `Dict()`.\n",
    "```julia\n",
    "Dict(chave1 => valor1, chave2 => valor2, ...)\n",
    "```\n",
    "Um bom exemplo de dicionário é uma lista de contatos, onde associamos telefones a nomes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Dict{String, String} with 2 entries:\n",
       "  \"Maria\" => \"11111-2222\"\n",
       "  \"João\"  => \"99999-0000\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agenda_de_telefones = Dict(\"João\" => \"99999-0000\", \"Maria\" => \"11111-2222\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"11111-2222\""
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "agenda_de_telefones[\"Maria\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas\n",
    "\n",
    "Diferentemente de uplas, listas podem ser modificadas.\n",
    "Diferentemente de dicionários, listas contêm sequências ordenadas de elementos.\n",
    "Podemos criar uma lista especificando uma sequência entre colchetes `[]`.\n",
    "```julia\n",
    "[item1, item2, ...]\n",
    "```\n",
    "Por exemplo, podemos criar uma lista com uma sequência de tarefas a fazer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{String}:\n",
       " \"caminhar\"\n",
       " \"estudar\"\n",
       " \"comer\"\n",
       " \"dormir\""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tarefas = [\"caminhar\", \"estudar\", \"comer\", \"dormir\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7-element Vector{Int64}:\n",
       "  1\n",
       "  1\n",
       "  2\n",
       "  3\n",
       "  5\n",
       "  8\n",
       " 13"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci = [1, 1, 2, 3, 5, 8, 13]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Vector{Any}:\n",
       " 1\n",
       " 3\n",
       " 7\n",
       "  \"verde\"\n",
       "  \"azul\""
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista_mista = [1, 3, 7, \"verde\", \"azul\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também criar listas de outras estruturas de dados ou listas multidimensionais."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Vector{Int64}}:\n",
       " [1, 2]\n",
       " [3, 4, 5]\n",
       " [6, 7, 8, 9]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "números = [[1, 2], [3, 4, 5], [6, 7, 8, 9]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4×3 Matrix{Float64}:\n",
       " 0.935469  0.946714  0.874511\n",
       " 0.498354  0.553129  0.798912\n",
       " 0.820358  0.415443  0.0983551\n",
       " 0.62491   0.778879  0.53726"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = rand(4, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Acima, o comando `rand(4, 3)` cria uma lista de quatro linhas e três colunas com números aleatórios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Laços"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Laço do tipo `for`\n",
    "\n",
    "A sintaxe para um laço do tipo `for` é\n",
    "```julia\n",
    "for *variável* in *loop iterable*\n",
    "    *comandos*\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for n in 1:10\n",
    "    println(n)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Laço do tipo `while`\n",
    "\n",
    "A sintaxe para um laço do tipo `while` é\n",
    "```julia\n",
    "while *condição*\n",
    "    *comandos*\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "n = 0\n",
    "while n < 10\n",
    "    n += 1\n",
    "    println(n)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Condicionais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Condicional do tipo `if`\n",
    "\n",
    "Em Julia, a sintaxe\n",
    "```julia\n",
    "if *condição 1*\n",
    "    *opção 1*\n",
    "elseif *condição 2*\n",
    "    *opção 2*\n",
    "else\n",
    "    *opção 3*\n",
    "end\n",
    "```\n",
    "permite executar, condicionalmente, uma das opções."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 7\n",
    "y = 3\n",
    "if x > y\n",
    "    x\n",
    "else\n",
    "    y\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Condicional com operador ternário\n",
    "\n",
    "O operador ternário a seguir nos fornece uma alternativa para representar uma condicional do tipo `if`.\n",
    "A sintaxe\n",
    "```julia\n",
    "a ? b : c\n",
    "```\n",
    "significa o mesmo que\n",
    "```julia\n",
    "if a\n",
    "    b\n",
    "else\n",
    "    c\n",
    "end\n",
    "```\n",
    "Portanto, podemos reescrever o código da célula anterior da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 7\n",
    "y = 3\n",
    "(x > y) ? x : y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funções\n",
    "\n",
    "Tópicos:\n",
    "- Como declarar uma função\n",
    "- Duck-typing em Julia\n",
    "- Funções mutantes versus funções não-mutantes\n",
    "- Algumas funções de ordem superior"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Como declarar uma função"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Primeira forma: Usando `function` e `end`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "f (generic function with 1 method)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function f(x)\n",
    "    x^2\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Segunda forma: Usando `=`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "g (generic function with 1 method)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(x) = x^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(-2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Terceira forma: Como uma função anônima"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#1 (generic function with 1 method)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = x -> x^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Duck-typing em Julia\n",
    "\n",
    "\"If it quacks like a duck, it's a duck.\"\n",
    "\n",
    "Duck-typing em Julia significa que as funções em Julia vão funcionar com qualquer argumento que faça sentido.\n",
    "Por exemplo, `f(x)=x^2` vai funcionar se o argumento for uma matriz quadrada, pois faz sentido multiplicar uma matriz quadrada por ela mesma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       " 0.258506  0.503305  0.865922\n",
       " 0.241912  0.420527  0.748512\n",
       " 0.688515  0.910238  0.0577069"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = rand(3, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       " 0.784782  1.12996   0.650546\n",
       " 0.679628  0.979923  0.567441\n",
       " 0.437915  0.78184   1.28085"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todavia, se o argumento passado a `f` for um vetor, ocorrerá um erro pois não é claro o que significa multiplicar um vetor por ele mesmo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Float64}:\n",
       " 0.5052215340330571\n",
       " 0.45450555631789546\n",
       " 0.9695914133033307"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = rand(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching ^(::Vector{Float64}, ::Int64)\n\u001b[0mClosest candidates are:\n\u001b[0m  ^(\u001b[91m::Union{AbstractChar, AbstractString}\u001b[39m, ::Integer) at strings/basic.jl:730\n\u001b[0m  ^(\u001b[91m::Complex{<:AbstractFloat}\u001b[39m, ::Integer) at complex.jl:860\n\u001b[0m  ^(\u001b[91m::Complex{<:Integer}\u001b[39m, ::Integer) at complex.jl:862\n\u001b[0m  ...",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching ^(::Vector{Float64}, ::Int64)\n\u001b[0mClosest candidates are:\n\u001b[0m  ^(\u001b[91m::Union{AbstractChar, AbstractString}\u001b[39m, ::Integer) at strings/basic.jl:730\n\u001b[0m  ^(\u001b[91m::Complex{<:AbstractFloat}\u001b[39m, ::Integer) at complex.jl:860\n\u001b[0m  ^(\u001b[91m::Complex{<:Integer}\u001b[39m, ::Integer) at complex.jl:862\n\u001b[0m  ...",
      "",
      "Stacktrace:",
      " [1] literal_pow",
      "   @ ./intfuncs.jl:340 [inlined]",
      " [2] f(x::Vector{Float64})",
      "   @ Main ./In[24]:2",
      " [3] top-level scope",
      "   @ In[33]:1",
      " [4] eval",
      "   @ ./boot.jl:368 [inlined]",
      " [5] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)",
      "   @ Base ./loading.jl:1428"
     ]
    }
   ],
   "source": [
    "f(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funções mutantes versus funções não-mutantes\n",
    "\n",
    "Por convenção, funções seguidas de `!` alteram seus conteúdos e funções não seguidas de `!` não alteram.\n",
    "Por exemplo, vamos ver a diferença entre `sort` e `sort!`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 5\n",
       " 9\n",
       " 1"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = [5, 9, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 1\n",
       " 5\n",
       " 9"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 5\n",
       " 9\n",
       " 1"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O comando `sort(v)` retorna uma lista que contém os elementos de `v` em ordem crescente, mas a lista `v` não é alterada.\n",
    "Por outro lado, quando executamos `sort!(v)`, a lista `v` é alterada e colocada em ordem crescente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 1\n",
       " 5\n",
       " 9"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort!(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 1\n",
       " 5\n",
       " 9"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algumas funções de ordem superior\n",
    "\n",
    "#### A função `map`\n",
    "\n",
    "A função `map` é uma função de ordem superior em Julia que *recebe uma função* como argumento.\n",
    "A função `map` então aplica a função em cada elemento de uma estrutura de dados que também é passada como argumento.\n",
    "Por exemplo, o comando\n",
    "```julia\n",
    "map(f, [1, 2, 3])\n",
    "```\n",
    "fornece uma lista cujos elementos são obtidos aplicando `f` a cada elemento de `[1, 2, 3]`:\n",
    "```julia\n",
    "[f(1), f(2), f(3)]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 1\n",
       " 4\n",
       " 9"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(f, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é possível passar para a função `map` uma função anônima:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       "  1\n",
       "  8\n",
       " 27"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(x -> x^3, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A função `broadcast`\n",
    "\n",
    "A função `broadcast` é outra função de order superior em Julia.\n",
    "A função `broadcast` é uma generalização da função `map`, ou seja, pode fazer tudo que a função `map` faz, e mais.\n",
    "A sintaxe usada para executar `broadcast` é semelhante à usada para executar `map`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 1\n",
       " 4\n",
       " 9"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "broadcast(f, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Novamente, aplicamos `f` a todos os elementos de `[1, 2, 3]`, desta vez usando `broadcast`.\n",
    "\n",
    "Uma forma equivalente de executar `broadcast` é inserir um  `.` entre o nome da função que você quer aplicar e os argumentos de entrada.\n",
    "Por exemplo,\n",
    "```julia\n",
    "broadcast(f, [1, 2, 3])\n",
    "```\n",
    "é equivalente a\n",
    "```julia\n",
    "f.([1, 2, 3])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Vector{Int64}:\n",
       " 1\n",
       " 4\n",
       " 9"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe a diferença entre executar o comando acima e executar o comando\n",
    "```julia\n",
    "f([1, 2, 3])\n",
    "```\n",
    "Nós podemos elevar cada elemento de um vetor ao quadrado, mas não podemos elevar o vetor ao quadrado.\n",
    "\n",
    "Mais uma vez, observamos a diferença entre\n",
    "```julia\n",
    "f(A)\n",
    "```\n",
    "e\n",
    "```julia\n",
    "f.(A)\n",
    "```\n",
    "para uma matrix `A`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       " 1  2  3\n",
       " 4  5  6\n",
       " 7  8  9"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [i + 3j for j in 0:2, i in 1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       "  30   36   42\n",
       "  66   81   96\n",
       " 102  126  150"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Novamente, vemos que\n",
    "```julia\n",
    "f(A) = A^2 = A*A\n",
    "```\n",
    "enquanto as entradas de\n",
    "```julia\n",
    "f.(A)\n",
    "```\n",
    "são os quadrados das entradas de `A`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Int64}:\n",
       "  1   4   9\n",
       " 16  25  36\n",
       " 49  64  81"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A sintaxe usando `.` permite expressar operações pontuais com uma notação elegante do ponto de vista matemático.\n",
    "Por exemplo, podemos escrever"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       "  3.0   6.0   9.0\n",
       " 12.0  15.0  18.0\n",
       " 21.0  24.0  27.0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = A .+ 2 .* f.(A) ./ A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "em vez de"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3×3 Matrix{Float64}:\n",
       "  3.0   6.0   9.0\n",
       " 12.0  15.0  18.0\n",
       " 21.0  24.0  27.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = broadcast(x -> x + 2*f(x) / x, A)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.8.2",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}