chapters/4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aplicações em Cálculo Diferencial e Integral\n",
    "\n",
    "De modo geral, o principal objetivo do curso é garantir que seus alunos estejam proeficientes no uso de `SymPy` no Cálculo. Na minha opinião, esse é o capítulo mais importante do curso. Dê seu máximo para absorver o conteúdo aqui apresentado.\n",
    "\n",
    "Antes de comerçarmos, certifique-se que fez as devidas importações e atribuições:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "x, y, z = symbols('x y z')\n",
    "init_printing(use_unicode=True, use_latex='mathjax')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intervalos\n",
    "\n",
    "Nós sabemos que o Cálculo é, genericamente, o estudo das mudanças. E nós costumamos definir intervalos para trabalhar com nossas funções e expressões. É bem simples de criá-los e utilizá-los no `SymPy`.\n",
    "\n",
    "Para criar um intervalo, criamos um objeto a partir da classe `Interval` e/ou um método seu para definir se está aberto em algum dos lados. Veja os exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[0, 10\\right]$"
      ],
      "text/plain": [
       "[0, 10]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Intervalo Fechado\n",
    "Interval(0,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-10, 20\\right)$"
      ],
      "text/plain": [
       "(-10, 20)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Intervalo Aberto\n",
    "Interval.open(-10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[10, 30\\right)$"
      ],
      "text/plain": [
       "[10, 30)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Intervalo Aberto em um dos lados\n",
    "Interval.Ropen(10,30) # R - Direita"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(10, 30\\right]$"
      ],
      "text/plain": [
       "(10, 30]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Interval.Lopen(10,30) # L - Direita"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[0, \\infty\\right)$"
      ],
      "text/plain": [
       "[0, ∞)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Interval(0,oo) # oo representa o infinito em sympy. Note que onde oo estiver será aberto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Análises de Domínio/Intervalo\n",
    "\n",
    "Existem diversas funções embutidas no `SymPy` para avaliar o comportamento das funções/expressões ao longo de seu domínio ou de um intervalo específico. Normalmente elas retornarão um booleano.\n",
    "\n",
    "### Verificar se é crescente ou decrescente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## x² em seu domínio não é crescente\n",
    "is_increasing(x**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## x² em (0, oo) é crescente\n",
    "is_increasing(x**2, Interval.open(0, oo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## O contrário vale para decreasing\n",
    "is_decreasing(x**2, Interval.open(-oo, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos verificar também se ela é estritamente crescente ou decrescente, ou seja, se ela é injetiva. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## x³ é crescente em todo seu domínio. (d/dx = 3x² >= 0)\n",
    "is_increasing(x**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "## x³ não é estritamente crescente em seu domínio (3*0² = 0)\n",
    "is_strictly_increasing(x**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## 1/(e^x) é estritamente decrescente em seu domínio\n",
    "is_strictly_decreasing(1/(exp(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também verificar se ela é monótona com `is_monotonic()`. Para finalizar, podemos verificar se há pontos (e quais são) com singularidades. Ou seja, que requerem certa atenção. Normalmente, são pontos que não têm limite. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{0\\right\\}$"
      ],
      "text/plain": [
       "{0}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "singularities(1/x,x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Limites\n",
    "\n",
    "Assim como veremos posteriormente nas derivadas e nas integrais, há duas formas de criar e calcular limites no `SymPy`. A primeria forma é através da classe `Limit`, que criará um limite e não calculará seu valor. Ou seja, utilize ela para armazenar a expressão do limite. Caso queira somente calcular o limite. Utilizamos a função `limit()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\lim_{x \\to 0^+}\\left(\\frac{\\sin{\\left(x \\right)}}{x}\\right)$"
      ],
      "text/plain": [
       "     ⎛sin(x)⎞\n",
       " lim ⎜──────⎟\n",
       "x─→0⁺⎝  x   ⎠"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Limit(sin(x)/x, x, 0, '+') ## sin(x)/x, x -> 0+"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\lim_{x \\to 0^-} \\frac{1}{x}$"
      ],
      "text/plain": [
       "     1\n",
       " lim ─\n",
       "x─→0⁻x"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Limit(1/x, x, 0, '-') ## sin(x)/x, x -> 0-"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit(sin(x)/x, x, 0, '+')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\infty$"
      ],
      "text/plain": [
       "∞"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit(1/x, x, 0) # '+' por padrão"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -\\infty$"
      ],
      "text/plain": [
       "-∞"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit(1/x, x, 0, '-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\tilde{\\infty}$"
      ],
      "text/plain": [
       "zoo"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit(1/x, x, 0, '+-') # Dois lados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_sin = Limit(sin(x)/x, x, 0, '+')\n",
    "my_sin.doit() # Método doit() calcula uma expressão."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Derivadas\n",
    "\n",
    "Assim com os limites, podemos criar a derivada (sem calculá-la) através da classe `Derivative()`. E calcular diretamente através da `diff()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{d}{d x} e^{2 x^{3}}$"
      ],
      "text/plain": [
       "  ⎛    3⎞\n",
       "d ⎜ 2⋅x ⎟\n",
       "──⎝ℯ    ⎠\n",
       "dx       "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Derivative(exp(2*x**3),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x \\cos{\\left(x^{2} \\right)}$"
      ],
      "text/plain": [
       "       ⎛ 2⎞\n",
       "2⋅x⋅cos⎝x ⎠"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(sin(x**2),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\left(- 2 x^{2} \\sin{\\left(x^{2} \\right)} + \\cos{\\left(x^{2} \\right)}\\right)$"
      ],
      "text/plain": [
       "  ⎛     2    ⎛ 2⎞      ⎛ 2⎞⎞\n",
       "2⋅⎝- 2⋅x ⋅sin⎝x ⎠ + cos⎝x ⎠⎠"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(sin(x**2),x, x) ## Calcular a segunda derivada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 4 x \\left(2 x^{2} \\cos{\\left(x^{2} \\right)} + 3 \\sin{\\left(x^{2} \\right)}\\right)$"
      ],
      "text/plain": [
       "     ⎛   2    ⎛ 2⎞        ⎛ 2⎞⎞\n",
       "-4⋅x⋅⎝2⋅x ⋅cos⎝x ⎠ + 3⋅sin⎝x ⎠⎠"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(sin(x**2),x, x, x) ## Calcular a terceira derivada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 4 x \\left(2 x^{2} \\cos{\\left(x^{2} \\right)} + 3 \\sin{\\left(x^{2} \\right)}\\right)$"
      ],
      "text/plain": [
       "     ⎛   2    ⎛ 2⎞        ⎛ 2⎞⎞\n",
       "-4⋅x⋅⎝2⋅x ⋅cos⎝x ⎠ + 3⋅sin⎝x ⎠⎠"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(sin(x**2),x, 3) ## Calcular a terceira derivada de outra forma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 32 \\left(- 32 x^{10} \\sin{\\left(x^{2} \\right)} + 720 x^{8} \\cos{\\left(x^{2} \\right)} + 5040 x^{6} \\sin{\\left(x^{2} \\right)} - 12600 x^{4} \\cos{\\left(x^{2} \\right)} - 9450 x^{2} \\sin{\\left(x^{2} \\right)} + 945 \\cos{\\left(x^{2} \\right)}\\right)$"
      ],
      "text/plain": [
       "   ⎛      10    ⎛ 2⎞        8    ⎛ 2⎞         6    ⎛ 2⎞          4    ⎛ 2⎞    \n",
       "32⋅⎝- 32⋅x  ⋅sin⎝x ⎠ + 720⋅x ⋅cos⎝x ⎠ + 5040⋅x ⋅sin⎝x ⎠ - 12600⋅x ⋅cos⎝x ⎠ - 9\n",
       "\n",
       "     2    ⎛ 2⎞          ⎛ 2⎞⎞\n",
       "450⋅x ⋅sin⎝x ⎠ + 945⋅cos⎝x ⎠⎠"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(sin(x**2),x, 10) ## Calcular a décima derivada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6 x^{2} e^{2 x^{3}}$"
      ],
      "text/plain": [
       "         3\n",
       "   2  2⋅x \n",
       "6⋅x ⋅ℯ    "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_deriv = Derivative(exp(2*x**3),x)\n",
    "my_deriv.doit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6 x^{2} e^{2 x^{3}}$"
      ],
      "text/plain": [
       "         3\n",
       "   2  2⋅x \n",
       "6⋅x ⋅ℯ    "
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Podemos, com o método diff()\n",
    "expr = exp(2*x**3)\n",
    "expr.diff(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 12 \\left(18 x^{6} + 18 x^{3} + 1\\right) e^{2 x^{3}}$"
      ],
      "text/plain": [
       "                           3\n",
       "   ⎛    6       3    ⎞  2⋅x \n",
       "12⋅⎝18⋅x  + 18⋅x  + 1⎠⋅ℯ    "
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.diff(x,3) # Terceira derivada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Integrais\n",
    "\n",
    "Assim como os Limites e as Derivadas que vimos acima, podemos criar uma Integral através da classe `Integral()` caso queiramos ter somente a expressão, e caso queiramos o resultado de uma Integral, basta utilizar a função `integrate()`.\n",
    "\n",
    "O `Sympy` não acresce a constante de integração nas Integrais Indefinidas, então é importante se lembrar delaa quando for resolver algum exercício."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\int \\frac{1}{x}\\, dx$"
      ],
      "text/plain": [
       "⌠     \n",
       "⎮ 1   \n",
       "⎮ ─ dx\n",
       "⎮ x   \n",
       "⌡     "
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Integral(1/x, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\int\\limits_{1}^{10} \\frac{1}{x}\\, dx$"
      ],
      "text/plain": [
       "10     \n",
       "⌠      \n",
       "⎮  1   \n",
       "⎮  ─ dx\n",
       "⎮  x   \n",
       "⌡      \n",
       "1      "
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Integral(1/x, (x, 1, 10)) # Note que passamos (simbolo, inf, sup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\log{\\left(10 \\right)}$"
      ],
      "text/plain": [
       "log(10)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integrate(1/x, (x,1,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\int\\limits_{1}^{10}\\int\\limits_{1}^{10} \\left(\\frac{1}{y} + \\frac{1}{x}\\right)\\, dx\\, dy$"
      ],
      "text/plain": [
       "10 10              \n",
       "⌠  ⌠               \n",
       "⎮  ⎮  ⎛1   1⎞      \n",
       "⎮  ⎮  ⎜─ + ─⎟ dx dy\n",
       "⎮  ⎮  ⎝y   x⎠      \n",
       "⌡  ⌡               \n",
       "1  1               "
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_integral = Integral(1/x + 1/y, (x, 1, 10), (y, 1, 10)) # Integral dupla, duas variáveis.\n",
    "my_integral"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 18 \\log{\\left(10 \\right)}$"
      ],
      "text/plain": [
       "18⋅log(10)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_integral.doit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\iint e^{x^{2} - 10}\\, dx\\, dx$"
      ],
      "text/plain": [
       "⌠ ⌠               \n",
       "⎮ ⎮   2           \n",
       "⎮ ⎮  x  - 10      \n",
       "⎮ ⎮ ℯ        dx dx\n",
       "⌡ ⌡               "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Integral(exp(x**2 - 10), x,x) # Integral dupla indefinida, mesma variável"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outras funções\n",
    "\n",
    "### Séries\n",
    "\n",
    "Você pode utilizar o método `series()` em uma expressão para fazer sua expansão em série."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x + \\frac{x^{3}}{6} + \\frac{3 x^{5}}{40} + \\frac{5 x^{7}}{112} + \\frac{35 x^{9}}{1152} + O\\left(x^{10}\\right)$"
      ],
      "text/plain": [
       "     3      5      7       9         \n",
       "    x    3⋅x    5⋅x    35⋅x     ⎛ 10⎞\n",
       "x + ── + ──── + ──── + ───── + O⎝x  ⎠\n",
       "    6     40    112     1152         "
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "asin(x).series(x,0, 10) # (x, x_0, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Equações Diferenciais\n",
    "\n",
    "Ao criar uma função simbólica, você pode utilizar derivadas e a função `dsolve()` para encontrar a solução de uma expressão e ou equação diferencial. Nesse caso, o `SymPy` insere as constantes quando necessário."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{d^{2}}{d x^{2}} f{\\left(x \\right)} = f{\\left(x \\right)}$"
      ],
      "text/plain": [
       "  2             \n",
       " d              \n",
       "───(f(x)) = f(x)\n",
       "  2             \n",
       "dx              "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = Function('f')\n",
    "my_deq = Eq(Derivative(f(x),x,2),f(x))\n",
    "my_deq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle f{\\left(x \\right)} = C_{1} e^{- x} + C_{2} e^{x}$"
      ],
      "text/plain": [
       "           -x       x\n",
       "f(x) = C₁⋅ℯ   + C₂⋅ℯ "
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dsolve(my_deq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercícios\n",
    "\n",
    "Como nos últimos capítulos, resolva os seguintes exercícios com o que aprendeu ao longo do curso.\n",
    "\n",
    "1. Para cada uma das funções abaixo, encontre:\n",
    "\n",
    "a) O domínio da função;\n",
    "\n",
    "b) As assíntotas horizontais e verticais, caso existam;\n",
    "\n",
    "c) Sua derivada, os intervalos de crescimento e decrescimento de f,os pontos de máximo e mínimo, caso existam; \n",
    "\n",
    "d) Os intervalos onde o gráfico da f é côncavo para cima e onde é côncavo para baixo.\n",
    "\n",
    "$$f(x) = \\dfrac{x^3}{x + 4}$$\n",
    "\n",
    "$$g(x) = \\dfrac{x^3 - 4x^2 + 5}{x^2 - x}$$\n",
    "\n",
    "$$h(x) = x^2 - 4x + \\dfrac{x}{x-10}$$\n",
    "\n",
    "2. Calcule:\n",
    "\n",
    "$$\\int x^3 - 2x^2 + 3x + 10 \\,\\ dx$$\n",
    "\n",
    "$$\\int x^3\\cdot\\sin(2x) \\,\\ dx$$\n",
    "\n",
    "$$\\int_0^{10} \\tan^3(x)\\sec^3(x) \\,\\ dx $$\n",
    "\n",
    "$$\\int_1^{\\infty} -\\dfrac{1}{x^2} \\,\\ dx $$\n",
    "\n",
    "3. Qual a menor distância vertical entre as funções $f(x) = 32x^2$ e $g(x) = -\\dfrac{8}{x^2}$?"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}