Graficos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"homesweethome\"></div>\n",
    "\n",
    "<div style=\"width: 100%; text-align: center; color: white; background-color: #222; font-size: 3em; font-weight: 700; padding: .5em .5em .6em .5em; line-height: 1.4em;\">Representação gráfica de funções</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importando módulos\n",
    "\n",
    "Vamos começar importando alguns módulos (ou bibliotecas de funções) do Python que vão nos ajudar a fazer os gráficos. \n",
    "\n",
    "Começamos importando a biblioteca &nbsp;`matplotlib.pyplot`&nbsp; que tem diversas funções prontas para fazer gráficos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Na linha acima, estamos importanto o módulo &nbsp;`matplotlib.pyplot`&nbsp; com o \"apelido\" de &nbsp;`plt`. Assim, não temos que digitar &nbsp;`matplotlib.pyplot`&nbsp; toda vez que usarmos uma função dessa biblioteca. \n",
    "\n",
    "A linha &nbsp;`%matplotlib notebook`&nbsp; define como o gráfico vai aparecer. É importante colocar essa linha para que o Jupyter possa exibir os gráficos.\n",
    "\n",
    "Agora, vamos importar o módulo &nbsp;`numpy`, que tem diversas funções matemáticas prontas. Por conveniência, vamos dar o \"apelido\" de &nbsp;`np`&nbsp; a essa biblioteca:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "# Fazendo um gráfico\n",
    "\n",
    "No LibreOffice Calc, criamos uma lista de números de -4 a 4 (aumentando de 0.1 em 0.1) na primeira coluna. \n",
    "\n",
    "Aqui, vamos usar a função &nbsp;`arange()`&nbsp; da biblioteca &nbsp;`numpy`&nbsp; para fazer a mesma coisa e vamos colocar essa lista de valores em uma variável &nbsp;`a`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(-4,4.1,0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver como ficou &nbsp;`a`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então, note que em &nbsp;`arange`, -4 é o número inicial, 4.1 é o número limite (assim como em &nbsp;`range()`, o limite não entra na lista), e 0.1 é o quanto acrescentamos em cada passo.\n",
    "\n",
    "E para calcular o seno de cada número em &nbsp;`a`? \n",
    "\n",
    "Usamos a função &nbsp;`sin`&nbsp; da biblioteca &nbsp;`numpy`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.sin(a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos ver como ficou &nbsp;`b`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que &nbsp;`b`&nbsp; é uma lista de valores que contém o mesmo número de elementos que &nbsp;`a`. Além disso, o $i$-ésimo valor em &nbsp;`b`&nbsp; é o seno do $i$-ésimo valor em &nbsp;`a`.\n",
    "\n",
    "Fazendo a analogia com o LibreOffice, é como se &nbsp;`a`&nbsp; fosse a primeira coluna e  &nbsp;`b`, a segunda.\n",
    "\n",
    "Agora só falta fazer o gráfico! Vamos chamar a função &nbsp;`plot`&nbsp; do módulo &nbsp;`matplotlib.pyplot`&nbsp; que importamos com o apelido de &nbsp;`plt`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como você pode ver, quando chamamos &nbsp;`plot(a,b)`&nbsp; o primeiro parâmetro fica no eixo x e o segundo, no  eixo y. É parecido com o LibreOffice em que uma coluna de valores tem as abscissas e a outra coluna, as ordenadas.\n",
    "<hr>\n",
    "\n",
    "# Personalizando o gráfico\n",
    "\n",
    "Suponha que esse gráfico representa um sinal, onde o eixo x representa o tempo em segundos e o eixo y o valor do sinal medido em cada instante de tempo. \n",
    "\n",
    "Então vamos chamar o eixo x de \"tempo (s)\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.xlabel(\"tempo (s)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que nenhum novo gráfico foi criado, mas se você olhar o gráfico acima, perceberá que ele foi atualizado com o rótulo \"tempo (s)\" no eixo x.\n",
    "\n",
    "Vamos também colocar \"valor do sinal\" como o nome do eixo y:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.ylabel(\"valor do sinal\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos colocar um título no gráfico? \n",
    "\n",
    "Vamos chamá-lo de \"Gráfico\" (criatividade pura, não?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title(\"Gráfico\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Às vezes, é muito útil ter uma grade no gráfico. Isso é bem fácil de se fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se você quiser tirar a grade, você pode colocar &nbsp;`plt.grid(False)`\n",
    "\n",
    "Talvez você esteja estranhando este gráfico do seno. O gráfico ficou meio \"esticado\", não?\n",
    "\n",
    "Bom, isso é porque o nosso eixo x varia de -4 a 4 enquanto o eixo y varia de -1 a 1. Então, o &nbsp;`matplotlib`&nbsp; escolheu escalas diferentes para os dois eixos de modo a maximizar a área ocupada pela curva do gráfico.\n",
    "\n",
    "Se você quiser que os eixos fiquem na mesma escala, basta executar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore um pouco o gráfico! O botão com um quadradinho branco é uma ferramenta de zoom. \n",
    "\n",
    "Você pode salvar o gráfico em uma figura clicando no símbolo do disquete/salvar.\n",
    "\n",
    "<hr>\n",
    "\n",
    "# Sobrepondo gráficos\n",
    "\n",
    "Note que, se chamarmos a função &nbsp;`plot`&nbsp; para fazer o gráfico de uma nova função, o gráfico desta nova função será colocado em cima do nosso gráfico original. \n",
    "\n",
    "Isso é muito útil se queremos colocar vários gráficos juntos. Por exemplo, execute a linha abaixo e veja como fica o gráfico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a/2\n",
    "plt.plot(a,c,'g') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A letra `'g'` indica que este gráfico deve ser feito em verde (_green_). Você pode usar `'r'` para vermelho e `'b'` para azul.\n",
    "\n",
    "Veja que o grafico da reta ficou sobre o gráfico do seno, e que as escalas dos eixos vão mudando para acomodar os gráficos.\n",
    "<hr>\n",
    "\n",
    "# Começando um novo gráfico\n",
    "\n",
    "E se você quisesse começar um gráfico novo? \n",
    "\n",
    "Você pode fazer isso clicando no símbolo de 'desligar' no topo do gráfico.\n",
    "\n",
    "![Desligar o gráfico](http://tidia4.ufabc.edu.br/access/content/group/3f8c7fbe-cae4-4874-9329-11021062257f/Unidade%206/shutdown_graph.png)\n",
    "\n",
    "Faça isso! \n",
    "\n",
    "Vamos começar um novo gráfico:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(a,c,'r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outro jeito de 'desligar' o gráfico é usando a função &nbsp;`close()` antes de chamar a função &nbsp;`plot()`&nbsp; novamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.close(\"all\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Arrays \n",
    "\n",
    "Se você ainda não entendeu direito o que faz a função &nbsp;`arange`&nbsp;, não faz mal. Vamos tentar explicá-la em mais detalhes.\n",
    "\n",
    "A função &nbsp;`arange`&nbsp; do &nbsp;`numpy`&nbsp; cria um tipo de dado chamado _array_, que funciona como se fosse uma lista de valores. \n",
    "\n",
    "A diferença está no modo como as operações com arrays funcionam. Observe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = np.arange(0,1,0.1)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que você acha que deveria ser `(c + c)`? \n",
    "\n",
    "Faça o teste abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c+c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# outra alternativa seria fazer\n",
    "2*c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entendeu?\n",
    "\n",
    "As operações com _arrays_ do `numpy` são sempre feitas ponto-a-ponto. \n",
    "\n",
    "Se somamos dois _arrays_ `a` e `b`, o objeto resultante é um _array_ `c` cuja $i$-ésima cordenada é a soma da $i$-ésima coordenada de `a` com a $i$-ésima cordenada de `b`.\n",
    "\n",
    "Se multiplicamos um número $z$ (`float` ou `int`) pelo array `a`, o resultado é um array cuja $i$-ésima coordenada é $z$ vezes a $i$-ésima coordenada de `a`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E o que será `(c * c)`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c*c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# outra alternativa seria fazer\n",
    "c**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Novamente: com os _arrays_ do `numpy`, as operações são sempre realizadas ponto-a-ponto. \n",
    "\n",
    "E como faríamos a raiz quadrada de cada entrada de c?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sqrt(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# outra alternativa seria fazer\n",
    "c**(1/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Possíveis problemas com arrays\n",
    "\n",
    "Não é possível somar (ou multiplicar, dividir, etc.) dois _arrays_ de comprimentos diferentes. \n",
    "\n",
    "Veja o exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(0, 5, 0.1)\n",
    "b = np.arange(-4, 4, 0.01)\n",
    "print('O comprimento de a é', len(a))\n",
    "print('O comprimento de b é', len(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Execute a linha abaixo e veja a mensagem de erro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outro erro semelhante acontece se você tentar fazer um _plot_ desses vetores. Veja:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(a, b, 'r')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Portanto, se você estiver trabalhando com arrays e receber mensagem de erro que fala de **shapes** diferentes, provavelmente isso significa que você tentou realizar uma operação ponto-a-ponto ou fazer plot de dois arrays de tamanho diferente. \n",
    "\n",
    "Volte no seu programa e descubra porque isso aconteceu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mais gráficos\n",
    "\n",
    "Vamos fazer mais dois gráficos: a parábola $f(x) = x^2 + 3$ em vermelho, e a reta $g(x) = 4 - x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook \n",
    "\n",
    "# Parábola\n",
    "x = np.arange(-1, 1, 0.1)\n",
    "f = x*x + 3\n",
    "plt.plot(x, f, 'r', label='f(x) = x² + 3')\n",
    "\n",
    "# Reta\n",
    "g = 4 - x\n",
    "plt.plot(x, g, 'b', label='g(x) = 4 - x')\n",
    "\n",
    "# Coloca as legendas e ajusta a escala\n",
    "plt.legend()\n",
    "plt.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Repare que variáveis foram chamadas de `x`, `f` e `g` apenas por conveniência. Você pode usar outros nomes se achar conveniente. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: polinômio I\n",
    "\n",
    "Faça o gráfico do polinômio $x^3+2x$ para $x$ variando de -4 até 6. Coloque a grade.\n",
    "\n",
    "Para criar uma nova célula de código logo abaixo desta faça o seguinte: selecione esta célula e tecle <kbd>ESC+B</kbd> ou vá até o menu _**Insert &raquo; Insert Cell Below**_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Como fazer um círculo?\n",
    "\n",
    "Vamos ver como fazer um círculo de raio $5$ e centro $(1,2)$.\n",
    "\n",
    "Você se lembra da equação para um círculo? \n",
    "\n",
    "Para raio $r$ e centro $(a,b)$\n",
    "\n",
    "$(x-a)^2 + (y-b)^2 = r^2$\n",
    "\n",
    "No nosso exemplo, a equação seria\n",
    "\n",
    "$(x-1)^2 + (y-2)^2 = 25$\n",
    "\n",
    "Mas como isso nos ajuda a fazer o gráfico. Vamos tentar isolar o $y$:\n",
    "\n",
    "$(y-2)^2 = 25-(x-1)^2$\n",
    "\n",
    "Tirando a raiz quadrada temos duas opções para $y$\n",
    "\n",
    "$y-2 = \\sqrt{25-(x-1)^2}$ ou $y-2 = -\\sqrt{25-(x-1)^2}$ \n",
    "\n",
    "Passando o $2$ para o outro lado:\n",
    "\n",
    "$y = 2+\\sqrt{25-(x-1)^2}$ ou $y = 2-\\sqrt{25-(x-1)^2}$ \n",
    "\n",
    "Portanto temos que plotar duas funções: \n",
    "\n",
    "1. a função &nbsp; $y_1 = 2+\\sqrt{25-(x-1)^2}$  &nbsp; que representa a _calota_ de cima e\n",
    "2. a função &nbsp; $y_2 = 2-\\sqrt{25-(x-1)^2}$  &nbsp; que representa a _calota_ de baixo do círculo.\n",
    "\n",
    "Mas e qual é o domínio dessas funções? Ou seja, quais os possíveis valores de $x$?\n",
    "\n",
    "O centro está em $x=1$ e o raio é $5$, então $x$ varia de $(1 - 5)$ a $(1 + 5)$. Portanto, o domínio é o intervalo de $-4$ a $6$.\n",
    "\n",
    "Vamos plotar!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook\n",
    "\n",
    "# fechando os gráficos anteriores\n",
    "plt.close('all')\n",
    "\n",
    "# definindo o domínio\n",
    "x = np.arange(-4,6.001,0.01)\n",
    "\n",
    "# a função \"calota de cima\"\n",
    "y1 = 2 + np.sqrt(np.abs(25-(x-1)*(x-1)))\n",
    "plt.plot(x, y1, 'b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O grafico acima não se parece com a calota de um circulo: é preciso ajustar a escala do gráfico!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ajustando a escala\n",
    "plt.axis('equal')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Agora falta fazer o gráfico da calota de baixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a função \"calota de baixo\"\n",
    "y2 = 2 - np.sqrt(np.abs(25-(x-1)*(x-1)))\n",
    "plt.plot(x,y2,'b')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: círculo I\n",
    "\n",
    "Insira uma nova célula de código logo abaixo. Você pode fazer isso selecionando esta célula de texto e teclando <kbd>ESC+B</kbd> ou indo até o menu _**Insert &raquo; Insert Cell Below**_.\n",
    "\n",
    "Copie e cole o código das células de código acima, juntando-os na nova célula que você criou.\n",
    "\n",
    "Altere o código para criar um gráfico com dois círculos concêntricos de raios $2$ e $4$. O centro dos círculos pode ser qualquer ponto do plano que você queira."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O que pode dar errado?\n",
    "\n",
    "Várias coisas podem dar errado neste exercício. Veja os exemplos a seguir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook\n",
    "\n",
    "plt.close('all')\n",
    "x = np.arange(-2,2,0.1)\n",
    "y = np.sqrt(np.abs(4 - x**2))\n",
    "plt.plot(x,y,'b')\n",
    "plt.plot(x,-y,'b')\n",
    "plt.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este exemplo ilustra alguns problemas que podem ocorrer.\n",
    "\n",
    "### 1. Circulo \"quadrado\"\n",
    "\n",
    "Em primeiro lugar, o lado esquerdo do círculo não está muito redondo. Isso se deve ao fato de que o intervalo [-2,2] foi subdividido de maneira grosseira (em pedaços de tamanho 0.1). Para resolver esse problema, basta subdividir mais o intervalo (0.01 é suficiente para a maioria das aplicações).\n",
    "\n",
    "### 2. Círculo \"aberto\"\n",
    "\n",
    "Outro problema é que o círculo está _aberto_. Isso ocorreu pois, na hora de definir `x`, fizemos\n",
    "\n",
    "    x = np.arange(-2,2,0.1)\n",
    "    \n",
    "e o limite superior (nesse caso o 2) não entra na lista. Então o último valor que `x` contém é 1.9 (ou algo próximo disso, considerando erros de aproximação). Para corrigir isso, basta aumentarmos um pouco o limite superior. \n",
    "\n",
    "Corrigindo ambos os erros, a linha que define `x` fica assim:\n",
    "\n",
    "    x = np.arange(-2,2.001,0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "Vejamos mais um exemplo de círculo com problema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.arange(-6,6.001,0.001)\n",
    "y = np.sqrt(36 - x**2)\n",
    "plt.plot(x,y,'r')\n",
    "plt.plot(x,-y,'r')\n",
    "plt.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. _RuntimeWarning_\n",
    "\n",
    "Neste exemplo, nós resolvemos subdividir o intervalo [-6,6] em pedacinhos de 0.001. Uma subdivisão bem fina! De fato, o círculo parece bem \"redondo\". \n",
    "\n",
    "Por outro lado, o circulo continua aberto, apesar de 6 estar incluído no domínio. Além disso, tivemos um _RuntimeWarning_ (veja faixa em rosa logo abaixo do programa) reclamando de um valor inválido dentro da raiz quadrada (_sqrt_). \n",
    "\n",
    "Como explicar essas coisas? Será que subdividimos demais o intervalo? Não! O problema ocorre por outro motivo...\n",
    "\n",
    "Lembre-se de que, para armazenar um número \"quebrado\" o Python usa o tipo _float_. Internamente o computador armazena um _float_ com 32 ou 64 bits (dependendo do processador). Portanto, só é possível armazenar uma quantidade finita de casas decimais desse \"número quebrado\". \n",
    "\n",
    "Por isso, o computador não tem como evitar pequenos erros numéricos devido a arredondamentos na hora de representar um _float_ como um número finito de bits e os erros se acumulam conforme vamos fazendo operações artiméticas. Apesar do último valor em x ser teoricamente 6, pode ser que o computador esteja aproximando esse 6 como 6.000000000001 (ou seja, um pouco mais que 6).\n",
    "\n",
    "Nesse caso, o Python irá reclamar na hora de tirar a raiz de $36-x^2$, pois este seria um número negativo. Isso explica o _RuntimeWarning_ e explica tabém a abertura no círculo, pois o último ponto não foi plotado (por causa do erro).\n",
    "\n",
    "Para corrigirmos isso, podemos usar a função _valor absoluto_ (`abs()`&nbsp; do &nbsp;`numpy`) para manter os números dentro da raiz quadrada sempre não-negativos e evitar erros:\n",
    "\n",
    "    y = np.sqrt(np.abs(36 - x**2))\n",
    "\n",
    "### 4. Domínio incorreto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib notebook\n",
    "\n",
    "plt.close('all')\n",
    "x = np.arange(-10,2.001,0.01)\n",
    "y = np.sqrt(np.abs(36 - x**2))\n",
    "plt.plot(x,y,'r')\n",
    "plt.plot(x,-y,'r')\n",
    "plt.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste exemplo acima, o domínio deveria ser o intervalo [-6,6], mas definimos `x` com a linha\n",
    "\n",
    "    x = np.arange(-10,2.001,0.01)\n",
    "    \n",
    "ou seja, `x` assume valores no intervalo [-10, 2]. Portanto é necessário mudar essa linha para refletir o real domínio das funções plotadas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: círculo II\n",
    "\n",
    "Crie uma nova célula de código abaixo. Depois, use o método descrito acima para fazer o gráfico de um círculo começando seu código do zero! Ou seja, não copie e cole nenhum código, mas digite tudo você mesmo (inclusive as linhas que importam as bibliotecas).\n",
    "\n",
    "Seu círculo deve ter centro $(3,1)$ e raio $4$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Outra maneira de se fazer círculos\n",
    "\n",
    "Vamos refazer o círculo de raio $5$ e centro $(1,2)$, mas dessa vez vamos usar uma curva parametrizada.\n",
    "\n",
    "Primeiramente, considere um círculo unitário (raio $1$ e centro $(0,0)$). \n",
    "\n",
    "Sabemos que as cordenadas de um ponto sobre esse círculo que corresponde a um ângulo $t$ será $(\\cos{t}, \\sin{t})$. \n",
    "\n",
    "<img src=\"http://tidia4.ufabc.edu.br/access/content/group/8398384e-4091-4504-9c21-eae9a6a24a61/Unidade%206/unitcircle.png\" width=\"300\"/>\n",
    "\n",
    "Portanto, se fizermos uma variável &nbsp;`t`&nbsp; (que representa o ângulo) variar de $0$ a $2\\pi$ (0 a 365 graus), podemos plotar o círculo unitário muito facilmente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as pp\n",
    "%matplotlib notebook\n",
    "\n",
    "from math import pi\n",
    "\n",
    "pp.close('all')\n",
    "t = np.arange(0, 2*pi, 0.01)\n",
    "x = np.cos(t)\n",
    "y = np.sin(t)\n",
    "pp.plot(x, y, 'r')\n",
    "pp.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para plotar um círculo de raio $5$, basta multiplicar as cordenadas de cada ponto por $5$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as pp\n",
    "%matplotlib notebook\n",
    "\n",
    "from math import pi\n",
    "\n",
    "pp.close('all')\n",
    "t = np.arange(0, 2*pi, 0.01)\n",
    "x = 5*np.sin(t)\n",
    "y = 5*np.cos(t)\n",
    "pp.plot(x,y,'r')\n",
    "pp.grid(True)\n",
    "pp.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ter o centro em $(1,2)$, basta somar 1 à cordenada x e 2 à cordenada y de cada ponto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as pp\n",
    "%matplotlib notebook\n",
    "\n",
    "from math import pi\n",
    "\n",
    "pp.close('all')\n",
    "t = np.arange(0, 2*pi, 0.01)\n",
    "x = 1 + 5*np.sin(t)\n",
    "y = 2 + 5*np.cos(t)\n",
    "pp.plot(x,y,'r')\n",
    "pp.grid(True)\n",
    "pp.axis('equal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: círculo III\n",
    "\n",
    "Crie uma nova célula de código abaixo. Depois, use o método descrito acima para fazer o gráfico de um círculo começando seu código do zero! Ou seja, não copie e cole nenhum código, mas digite tudo você mesmo (inclusive as linhas que importam as bibliotecas).\n",
    "\n",
    "Seu círculo deve ter centro $(3,1)$ e raio $4$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: círculo IV\n",
    "\n",
    "Crie uma nova célula de código abaixo. Depois faça o gráfico de 50 círculos, todos com centro na origem, de raios inteiros variando de 1 a 50."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span> (desafio): espiral\n",
    "\n",
    "Faça um programa para gerar uma espiral como na figura abaixo.\n",
    "\n",
    "<img src=\"http://tidia4.ufabc.edu.br/access/content/group/8398384e-4091-4504-9c21-eae9a6a24a61/Unidade%206/espiral.png\"/>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mais exercícios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: polinômio II\n",
    "\n",
    "Faça um gráfico da função $f(x) = x^4-16x^2+16$ para x de -5 a 5.\n",
    "Coloque a grade. \n",
    "\n",
    "Olhando para o gráfico, para quais valores de x temos f(x) = 0?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: parábolas\n",
    "\n",
    "Faça um programa que **pede ao usuário** para:\n",
    "1. digitar um número a,\n",
    "2. digitar um número b,\n",
    "3. digitar um número c.\n",
    "\n",
    "Em seguida, seu programa deve mostrar ao usuário o gráfico da função $f(x) = ax^2 + bx+ c$.\n",
    "\n",
    "A dificuldade deste exercício é escolher um domínio para plotar $f$. Seu programa deve fazer essa escolha automaticamente de modo que a parábola fique centralizada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: 2 circulos \n",
    "\n",
    "Faça um gráfico com dois círculos: \n",
    "\n",
    "um com raio 1 e centro (0,0) \n",
    "\n",
    "e outro em com raio 1 e centro (1,1).\n",
    "\n",
    "Em quais pontos eles se cruzam? (Coloque a grade no gráfico para ajudar.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr> \n",
    "\n",
    "### Exercício <span class=\"exec\"></span>: 25 círculos\n",
    "\n",
    "Faça um programa que gere o gráfico abaixo (25 círculos concêntricos de raios $1, 1.5, 2, 2.5, \\dots, 13$).\n",
    "<img src=\"http://tidia4.ufabc.edu.br/access/content/group/8398384e-4091-4504-9c21-eae9a6a24a61/Unidade%206/circles.png\">\n",
    "\n",
    "**Dica:** use o comando &nbsp;`for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "init_cell": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       ".rendered_html h1 {\n",
       "    background-color: #555;\n",
       "    color: white;\n",
       "    padding: .5em;\n",
       "    // border-bottom: 2px solid #000;\n",
       "    // padding-bottom: .6em;\n",
       "    margin-bottom: 1em;\n",
       "}\n",
       "\n",
       ".rendered_html h1 code {\n",
       "    color: #EBB7C5;\n",
       "    background-color: rgba(0,0,0,0);\n",
       "}\n",
       "\n",
       ".rendered_html h2 {\n",
       "    border-bottom: 1px solid #333;\n",
       "    padding-bottom: .6em;\n",
       "}\n",
       "                                      \n",
       ".rendered_html h3 {\n",
       "    color: #034f84;\n",
       "}\n",
       "\n",
       ".rendered_html code  {\n",
       "    padding: 2px 4px;\n",
       "    font-size: 90%;\n",
       "    color: #c7254e;\n",
       "    background-color: #f9f2f4;\n",
       "    border-radius: 4px;\n",
       "}\n",
       "\n",
       ".rendered_html pre code {\n",
       "    padding: 0px;\n",
       "    font-size: 90%;\n",
       "    color: #c7254e;\n",
       "    background-color: rgba(0, 0, 0, 0);\n",
       "}\n",
       "\n",
       "kbd {\n",
       "    border-radius: 3px;  \n",
       "    padding: 2px, 3px;\n",
       "}\n",
       "\n",
       "body {\n",
       "    counter-reset: h1counter excounter;\n",
       "}\n",
       "h1:before {\n",
       "    content: counter(h1counter) \".\\0000a0\\0000a0\";\n",
       "    counter-increment: h1counter;\n",
       "}\n",
       "span.exec:before {\n",
       "    content: counter(excounter);\n",
       "    counter-increment: excounter;\n",
       "}\n",
       "\n",
       "\n",
       "</style>  \n",
       "<script>\n",
       "location.hash = \"#homesweethome\";\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<style>\n",
    ".rendered_html h1 {\n",
    "    background-color: #555;\n",
    "    color: white;\n",
    "    padding: .5em;\n",
    "    // border-bottom: 2px solid #000;\n",
    "    // padding-bottom: .6em;\n",
    "    margin-bottom: 1em;\n",
    "}\n",
    "\n",
    ".rendered_html h1 code {\n",
    "    color: #EBB7C5;\n",
    "    background-color: rgba(0,0,0,0);\n",
    "}\n",
    "\n",
    ".rendered_html h2 {\n",
    "    border-bottom: 1px solid #333;\n",
    "    padding-bottom: .6em;\n",
    "}\n",
    "                                      \n",
    ".rendered_html h3 {\n",
    "    color: #034f84;\n",
    "}\n",
    "\n",
    ".rendered_html code  {\n",
    "    padding: 2px 4px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: #f9f2f4;\n",
    "    border-radius: 4px;\n",
    "}\n",
    "\n",
    ".rendered_html pre code {\n",
    "    padding: 0px;\n",
    "    font-size: 90%;\n",
    "    color: #c7254e;\n",
    "    background-color: rgba(0, 0, 0, 0);\n",
    "}\n",
    "\n",
    "kbd {\n",
    "    border-radius: 3px;  \n",
    "    padding: 2px, 3px;\n",
    "}\n",
    "\n",
    "body {\n",
    "    counter-reset: h1counter excounter;\n",
    "}\n",
    "h1:before {\n",
    "    content: counter(h1counter) \".\\0000a0\\0000a0\";\n",
    "    counter-increment: h1counter;\n",
    "}\n",
    "span.exec:before {\n",
    "    content: counter(excounter);\n",
    "    counter-increment: excounter;\n",
    "}\n",
    "\n",
    "\n",
    "</style>  \n",
    "<script>\n",
    "location.hash = \"#homesweethome\";\n",
    "</script>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}