18. Extras.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Iteradores-e-Geradores\" data-toc-modified-id=\"Iteradores-e-Geradores-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Iteradores e Geradores</a></span><ul class=\"toc-item\"><li><span><a href=\"#Geradores\" data-toc-modified-id=\"Geradores-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Geradores</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exemplo:-Fibonacci\" data-toc-modified-id=\"Exemplo:-Fibonacci-1.1.1\"><span class=\"toc-item-num\">1.1.1&nbsp;&nbsp;</span>Exemplo: Fibonacci</a></span></li></ul></li><li><span><a href=\"#Iteradores\" data-toc-modified-id=\"Iteradores-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Iteradores</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exemplo:-A-classe-Range\" data-toc-modified-id=\"Exemplo:-A-classe-Range-1.2.1\"><span class=\"toc-item-num\">1.2.1&nbsp;&nbsp;</span>Exemplo: A classe Range</a></span></li></ul></li></ul></li><li><span><a href=\"#Polinômios-como-dicionários\" data-toc-modified-id=\"Polinômios-como-dicionários-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Polinômios como dicionários</a></span><ul class=\"toc-item\"><li><span><a href=\"#Avaliação-de-Polinômios\" data-toc-modified-id=\"Avaliação-de-Polinômios-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Avaliação de Polinômios</a></span></li></ul></li><li><span><a href=\"#Plotando-funções\" data-toc-modified-id=\"Plotando-funções-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Plotando funções</a></span><ul class=\"toc-item\"><li><span><a href=\"#Matplotlib\" data-toc-modified-id=\"Matplotlib-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Matplotlib</a></span></li><li><span><a href=\"#Decorando-o-gráfico\" data-toc-modified-id=\"Decorando-o-gráfico-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Decorando o gráfico</a></span></li><li><span><a href=\"#Plotando-múltiplas-curvas\" data-toc-modified-id=\"Plotando-múltiplas-curvas-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Plotando múltiplas curvas</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Iteradores e Geradores\n",
    "\n",
    "Quando introduzimos a sintaxe for-loop começando como:\n",
    "```\n",
    "for elemento in iterável:\n",
    "```\n",
    "notamos que existem muitos tipos de objetos no Python que se qualificam como sendo iteráveis. Os tipos básicos de contêiner, como list, tuple e set, são qualificados como iteráveis. Além disso, uma string pode produzir uma iteração de seus caracteres, um dicionário pode produzir uma iteração de suas chaves e um arquivo pode produzir uma iteração de suas linhas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Tipos definidos pelo usuário também podem suportar iteração. No Python, o mecanismo de iteração é baseado nas seguintes convenções:\n",
    "\n",
    "1. Um iterador é um objeto que gerencia uma iteração por meio de uma série de valores. Se uma variável ```i```, identifica um objeto iterador, então cada chamada para a função interna, ```next(i)```, produz um elemento subsequente da série subjacente, com uma exceção **StopIteration** levantada para indicar que não há elementos adicionais.\n",
    "\n",
    "2. Um iterável é um objeto, obj, que produz um iterador através da sintaxe ```iter(obj)```.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Por essas definições, uma instância de uma lista é iterável, mas não é um iterador. Com ```data = [1, 2, 4, 8]```, não é legal chamar next(data). No entanto, um objeto iterador pode ser produzido com a sintaxe, ```i = iter(data)``` e, em seguida, cada chamada subseqüente para o ```next(i)``` retornará um elemento dessa lista. A sintaxe for-loop no Python simplesmente automatiza esse processo, criando um iterador para o iterável e, em seguida, chamando repetidamente o próximo elemento até capturar a exceção **StopIteration**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Em geral, é possível criar vários iteradores com base no mesmo objeto iterável, com cada iterador mantendo seu próprio estado de progresso. No entanto, os iteradores normalmente mantêm seu estado com referência indireta à coleção original de elementos. Por exemplo, chamar ```iter(data)``` em uma instância da lista produz uma instância da classe iterator da lista. Esse iterador não armazena sua própria cópia da lista de elementos. Em vez disso, ele mantém um índice atual na lista original, representando o próximo elemento a ser relatado. Portanto, se o conteúdo da lista original for modificado depois que o iterador for construído, mas antes que a iteração seja concluída, o iterador relatará o conteúdo atualizado da lista."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O Python também suporta funções e classes que produzem uma série implícita de valores iteráveis, ou seja, sem construir uma estrutura de dados para armazenar todos os seus valores de uma só vez. Por exemplo, a chamda ```range(1000000)``` não retorna uma lista de números; ele retorna um objeto de intervalo que é iterável. Esse objeto gera um milhão de valores um de cada vez e somente conforme necessário. Esta técnica, chamda de avaliação preguiçosa tem uma grande vantagem. No caso de range, esta técnica permite que um loop na forma ```for j in range(1000000):```, execute sem necessitar de alocar memória para armazenar um milhão de valores. Além disso, se tal loop fosse interrompido de alguma forma, nenhum tempo teria sido gasto computando os valores não usados do intervalo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Vemos a avaliação preguiçosa sendo usada em muitas das bibliotecas do Python. Por exemplo, a classe dicionário ```(dic)``` suporta os métodos ```keys()```, ```values()``` e ```items()```, que respectivamente produzem uma “visão” de todas as chaves, valores ou pares (chave, valor) dentro de um dicionário. Nenhum desses métodos produz uma lista explícita de resultados. Em vez disso, as visualizações que são produzidas são objetos iteráveis com base no conteúdo real do dicionário. Uma lista explícita de valores de tal iteração pode ser construída imediatamente chamando o construtor de classe de lista ```(list)``` com a iteração como um parâmetro. Por exemplo, a sintaxe ```list(range(1000))``` produz uma instância de lista com valores de 0 a 999, enquanto a sintaxe ```list(d.values())``` produz uma lista que possui elementos baseados nos valores atuais do dicionário ```d```. Podemos, da mesma forma, construir uma tupla ou definir uma instância com base em um dado iterável."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Geradores\n",
    "\n",
    "Na próxima seção, explicarei como definir uma classe cujas instâncias sirvam como iteradores. No entanto, a técnica mais conveniente para criar iteradores em Python é através do uso de geradores. Um gerador é implementado com uma sintaxe muito semelhante a uma função, mas em vez de retornar valores, uma instrução ```yield``` é executada para indicar cada elemento da série. Como exemplo, considere o objetivo de determinar todos os fatores de um inteiro positivo. Por exemplo, o número 100 possui os fatores 1, 2, 4, 5, 10, 20, 25, 50, 100. Uma função tradicional pode produzir e retornar uma lista contendo todos os fatores, implementados como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def factors(n):\n",
    "    results = []\n",
    "    for k in range(1, n+1):\n",
    "        if n % k == 0:\n",
    "            results.append(k)\n",
    "    return results\n",
    "\n",
    "factors(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Em contraste, uma implementação de um gerador para computar esses fatores poderia ser implementada da seguinte forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def factors(n):\n",
    "    for k in range(1, n+1):\n",
    "        if n % k == 0:\n",
    "            yield k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Se um programador escreve um loop como ```for fator in factors(100):```, uma instância de nosso gerador é criada. Para cada iteração do loop, o Python executa nosso procedimento até que uma instrução ```yield``` indique o próximo valor. Nesse ponto, o procedimento é temporariamente interrompido, apenas para ser retomado quando outro valor é solicitado. Quando o fluxo de controle atinge naturalmente o final de nosso procedimento uma exceção **StopIteration** é automaticamente levantada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exemplo: Fibonacci\n",
    "\n",
    "Neste exemplo vamos enfatizar os benefícios da avaliação lenta ao usar um gerador em vez de uma função tradicional. Os resultados só são computados se solicitados, e toda a série não precisa residir na memória ao mesmo tempo. Na verdade, um gerador pode efetivamente produzir uma série infinita de valores. Como sabemos, os números de Fibonacci formam uma sequência matemática clássica, começando com o valor 0, depois com o valor 1 e, em seguida, cada valor subseqüente sendo a soma dos dois valores anteriores. Assim, a série de Fibonacci começa como: 0,1,1,2,3,5,8,13, .... O seguinte gerador produz esta série infinita:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def fibonacci():\n",
    "    a, b = 0, 1\n",
    "    while True:\n",
    "        yield a\n",
    "        a, b = b, a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "obj = fibonacci()\n",
    "n_fib = next(obj)\n",
    "while n_fib < 10000:\n",
    "    print(n_fib, end = \", \")\n",
    "    n_fib = next(obj)\n",
    "print(\"...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iteradores\n",
    "\n",
    "A iteração é um conceito importante no projeto de estruturas de dados. Por exemplo, um iterador para uma coleção fornece um comportamento-chave: ele suporta um método especial chamado ```__next__``` que retorna o próximo elemento da coleção, se houver, ou gera uma exceção **StopIteration** para indicar que não há elementos adicionais. Felizmente, é raro ter que implementar diretamente uma classe de iteradores. Nossa abordagem preferida é o uso da sintaxe de geradores, que produz automaticamente um iterador de valores produzidos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "O Python também ajuda fornecendo uma implementação do iterador automático para qualquer classe que defina ```__len__``` e ```__getitem__```. Para fornecer um exemplo instrutivo de um iterador de baixo nível, o código abaixo demonstra apenas uma classe de iterador que funciona em qualquer coleção que suporte tanto o ```__len__``` quanto o ```__getitem__```. Esta classe pode ser instanciada como ```SequenceIterator(data)```. Ele opera mantendo uma referência interna à seqüência de dados, bem como um índice atual na sequência. Cada vez que ```__next__``` é chamado, o índice é incrementado até atingir o final da sequência."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class SequenceIterator:\n",
    "    \"\"\"An iterator for any of Pythons sequence types.\"\"\"\n",
    "\n",
    "    def __init__(self, sequence):\n",
    "        \"\"\"Create an iterator for the given sequence.\"\"\"\n",
    "        self.seq = sequence # keep a reference to the underlying data\n",
    "        self.k = -1         # will increment to 0 on first call to next\n",
    "\n",
    "    def __next__(self):\n",
    "        \"\"\"Return the next element, or else raise StopIteration error.\"\"\"\n",
    "        self.k += 1                      # advance to next index\n",
    "        if self.k < len(self.seq):\n",
    "            return(self.seq[self.k])     # return the data element\n",
    "        else:\n",
    "            raise StopIteration()        # there are no more elements\n",
    "\n",
    "    def __iter__(self):\n",
    "        \"\"\"By convention, an iterator must return itself as an iterator.\"\"\"\n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "my_list = [2, 4, 6, 8, 10]\n",
    "my_iter = SequenceIterator(my_list)\n",
    "for el in my_iter:\n",
    "    print(el, end=\" \")\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exemplo: A classe Range\n",
    "\n",
    "Estamos prontos para desenvolver nossa própria classe que imita a classe ```range```do Python.\n",
    "```range``` é uma classe que pode representar efetivamente um intervalo desejado de elementos sem nunca armazená-los explicitamente na memória. A sintaxe ```len(r)``` informará o número de elementos que estão no intervalo determinado. Um intervalo também suporta o método ```__getitem__```, de modo que a sintaxe ```r[15]``` relata o décimo sexto elemento no intervalo (como ```r[0]``` é o primeiro elemento). Como a classe suporta ```__len__``` e ```__getitem__```, ela herda o suporte automático para iteração, e é por isso que é possível executar um loop ```for``` em um intervalo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Neste ponto, estamos prontos para demonstrar nossa própria versão de tal classe. O fragmento de código abaixo fornece uma classe que chamamos de ```my_range``` (para diferenciá-lo claramente do intervalo interno). O maior desafio na implementação é calcular corretamente o número de elementos que pertencem ao intervalo, dados os parâmetros enviados pelo chamador ao construir um intervalo. Calculando esse valor no construtor e armazenando-o como ```self```. ```len```, torna-se trivial devolvê-lo a partir do método ```__len__```. Para implementar adequadamente uma chamada para ```__getitem__(k)```, simplesmente pegamos o valor inicial do intervalo mais ```k``` vezes o tamanho do passo (ou seja, para ```k = 0```, retornamos o valor inicial). Existem algumas sutilezas que vale a pena examinar no código:\n",
    "\n",
    "• Calculamos o número de elementos no intervalo como:\n",
    "```\n",
    "max (0, (stop - start + step - 1) // step)\n",
    "```\n",
    "(Vale a pena testar esta fórmula para tamanhos de degraus positivos e negativos.)\n",
    "\n",
    "• O método ```__getitem__``` suporta corretamente índices negativos convertendo um índice ```-k``` em ```len(self) −k``` antes de calcular o resultado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "class my_range:\n",
    "    \"\"\"A class that mimic s the built-in range class.\"\"\"\n",
    "\n",
    "    def __init__(self, start, stop=None, step=1):\n",
    "        \"\"\"Initialize a my_range instance. Semantics is similar to built-in range class.\"\"\"\n",
    "        if step == 0:\n",
    "            raise ValueError('step cannot be 0')\n",
    "\n",
    "        if stop is None:              # special case of range(n)\n",
    "            start, stop = 0, start    # should be treated as if range(0,n)\n",
    "\n",
    "        # calculate the effective length once\n",
    "        self._length = max(0, (stop - start + step - 1) // step)\n",
    "        # need knowledge of start and step (but not stop) to support __getitem__\n",
    "        self._start = start\n",
    "        self._step = step\n",
    "\n",
    "    def __len__(self):\n",
    "        \"\"\"Return number of entries in the range.\"\"\"\n",
    "        return self._length\n",
    "\n",
    "    def __getitem__(self, k):\n",
    "        \"\"\"Return entry at index k (using standard interpretation if negative).\"\"\"\n",
    "        if k < 0:\n",
    "            k += len(self) # attempt to convert negative index\n",
    "\n",
    "        if not 0 <= k < self._length:\n",
    "            raise IndexError('index out of range')\n",
    "\n",
    "        return self._start + k * self._step\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "for i in my_range(0, 10, 2):\n",
    "    print(i, end=\" \")\n",
    "print()\n",
    "\n",
    "my_iter = iter(my_range(0, 10, 2))\n",
    "el_0 = next(my_iter)\n",
    "el_1 = next(my_iter)\n",
    "el_2 = next(my_iter)\n",
    "print(el_0, el_1, el_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Polinômios como dicionários\n",
    "\n",
    "Considere o polinômio: $p(x) = -1 + x^{2} + 3x^{7}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Os dados associados a este polinômio podem ser vistos como um conjunto de pares de coeficientes de potência, neste caso o coeficiente -1 pertence à potência 0, o coeficiente 1 pertence à potência 2 e o coeficiente 3 pertence à potência 7. Um dicionário pode ser usado para mapear uma potência para um coeficiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "p1 = {0: -1, 2: 1, 7: 3}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "É claro que uma lista também pode ser usada, mas, nesse caso, devemos preencher todos os coeficientes zero também, já que o índice deve corresponder à potência:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "p2 = [-1, 0, 1, 0, 0, 0, 0, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A vantagem de um dicionário é que precisamos armazenar apenas os coeficientes não nulos. Para o polinômio $1 + x^{100}$ o dicionário contém dois elementos enquanto a lista contém 101 elementos. Outra grande vantagem de usar um dicionário para representar um polinômio do que uma lista é que os potências negativas são facilmente permitidas, por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "p3 = {-3: 0.5, 4: 2}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "pode representar $\\frac{1}{2}x^{-3} + 2x^{4}$. Com uma representação em lista, as potências negativas exigiriam muito mais book-keeping."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Avaliação de Polinômios\n",
    "\n",
    "A seguinte função pode ser usada para avaliar um polinômio representado como um dicionário:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def eval_poly_dict(poly, x):\n",
    "    sum = 0.0\n",
    "    for power in poly:\n",
    "        sum += poly[power] * x ** power\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(eval_poly_dict(p1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Uma implementação mais compacta pode usar a função sum do Python para somar os elementos de uma lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    " def eval_poly_dict2(poly, x):\n",
    "    return sum([poly[power]* x ** power for power in poly])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(eval_poly_dict2(p1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Podemos, de fato, descartar os colchetes e armazenar todos os números de potência\n",
    "```\n",
    "poly[power] * x ** power \n",
    "```\n",
    "em uma lista, porque a soma pode adicionar diretamente elementos de um iterador, como\n",
    "``` \n",
    "for power in poly:\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    " def eval_poly_dict2(poly, x):\n",
    "    return sum(poly[power]* x ** power for power in poly)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(eval_poly_dict2(p1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Plotando funções\n",
    "\n",
    "A visualização de uma função f(x) é feita desenhando a curva y=f(x) em um sistema de coordenadas xy. Quando usamos um computador para fazer essa tarefa, dizemos que traçamos a curva. Tecnicamente, plotamos uma curva desenhando linhas retas entre n pontos na curva. Quanto mais pontos usamos, mais suave a curva aparece.\n",
    "Suponha que queremos plotar a função $f(x)$ para $a <= x <= b$. Primeiro nós selecionamos $n$ coordenadas $x$ no intervalo $[a, b]$, digamos que nomeamos estes $x_{0}, x_{1}, ... x_{n-1}$. Então nós calculamos $y_{i}=f(x_{i}$ para $i = 0, 1, ... n-1$. Os pontos\n",
    " $(x_{i}, y_{i}), i = 0, 1, ... n-1$, agora formam a curva $y=f(x)$. Normalmente, escolhemos as coordenadas $x_{i}$ para serem espaçadas igualmente, ou seja,\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "$x_{i} = a + ih$, $\\ \\  $ onde $\\ \\   h = \\frac{b - a}{n - 1}$\n",
    "\n",
    "Se armazenarmos os valores $x_{i}$ e $y_{i}$ em duas matrizes x e y, podemos traçar a curva por um comando como plot (x, y).\n",
    "Às vezes, os nomes da variável independente e da função diferem de x e f, mas o procedimento de plotagem é o mesmo. Nosso exemplo de plotagem de curvas demonstra esse fato envolvendo uma função de t."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Matplotlib\n",
    "\n",
    "O pacote padrão para plotagem de curvas em Python é o Matplotlib. Voce pode instalá-lo usando o comando pip:\n",
    "````\n",
    "pip install matplotlib\n",
    "````\n",
    "Vamos traçar a curva $y=t^{2} exp(-t^{2})$ para valores de $t$ entre 0 e 3 usando o matplotlib. Primeiro, geramos coordenadas igualmente espaçadas para $t$, digamos 51 valores (50 intervalos). Então calculamos os valores y correspondentes nesses pontos, antes de chamarmos o comando ```plot(t, y)``` para fazer o gráfico da curva. Aqui está o programa completo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from numpy import *\n",
    "from matplotlib.pyplot import *\n",
    "\n",
    "def f(t):\n",
    "    return t**2*exp(-t**2)\n",
    "\n",
    "t = linspace(0, 3, 51)\n",
    "y = zeros(len(t))\n",
    "for i in range(len(t)):\n",
    "    y[i] = f(t[i])\n",
    "plot(t, y)\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Para incluir a plotagem em documentos eletrônicos, precisamos de uma cópia impressa da figura em PDF, PNG ou outro formato de imagem. A função ```savefig``` salva o gráfico em arquivos em vários formatos de imagem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "savefig('tmp1.pdf') # produz arquivo no formato PDF\n",
    "savefig('tmp1.png') # produz arquivo no formato PNG"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Decorando o gráfico\n",
    "\n",
    "Os eixos x e y nos gráficos de curvas podem ter rótulos, no exemplo t e y, respectivamente. Além disso, a curva pode ser identificada com um rótulo ou legenda, como é frequentemente chamado. Um título acima do grafico também é comum. Além disso, podemos querer controlar a extensão dos eixos (embora a maioria dos programas de plotagem ajuste automaticamente os eixos para o intervalo dos dados). Todas essas coisas são facilmente adicionadas após o comando de plotagem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "plot(t, y)\n",
    "xlabel('t')\n",
    "ylabel('y')\n",
    "legend(['t^2*exp(-t^2)'])\n",
    "axis([0, 3, -0.05, 0.6])            # [tmin, tmax, ymin, ymax]\n",
    "title('Matplotlib Demo')\n",
    "savefig('tmp2.pdf')\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Plotando múltiplas curvas\n",
    "\n",
    "Uma tarefa comum de plotagem é comparar duas ou mais curvas, o que requer que várias curvas sejam desenhadas no mesmo gráfico. Suponha que queremos plotar as duas funções $f_{1}(t)=t^{2}exp(-t^{2})$ e $f_{2}(t)=t^{4}exp(-t^{2})$. Podemos, então, apenas emitir dois comandos de plotagem, um para cada função:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "from numpy import *\n",
    "from matplotlib.pyplot import *\n",
    "\n",
    "def f1(t):\n",
    "    return t**2*exp(-t**2)\n",
    "\n",
    "def f2(t):\n",
    "    return t**2*f1(t)\n",
    "\n",
    "t = linspace(0, 3, 51)\n",
    "y1 = f1(t)\n",
    "y2 = f2(t)\n",
    "plot(t, y1, 'r-')\n",
    "plot(t, y2, 'bo')\n",
    "xlabel('t')\n",
    "ylabel('y')\n",
    "legend(['t^2*exp(-t^2)', 't^4*exp(-t^2)'])\n",
    "title('Plotando duas curvas no mesmo gráfico')\n",
    "show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Nesses comandos de plotagem, também especificamos o tipo de linha: r- significa linha vermelha (r) e tracejado (-), enquanto bo significa um círculo azul (b) e tracejado (o) em cada ponto de dados. As legendas de cada curva são especificadas em uma lista onde a seqüência de strings corresponde à seqüência de comandos de plotagem. Este [link](https://matplotlib.org/tutorials/index.html) contém guias detalhados para usar o Matplotlib. Ele é dividido em seções iniciante, intermediária e avançada, além de seções que abordam tópicos específicos."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}