P3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Método de Euler \n",
    "\n",
    "Queremos achar a solução de:\n",
    "\n",
    "### $\\frac{dy}{dx} = f(x, y)$\n",
    "Consideramos que: $y_0 = y(x_0)$\n",
    "\n",
    "Definimos o intervalo\n",
    "### $I = [x_0, x_f]$\n",
    "Onde $y(x)$ é contínua\n",
    "\n",
    "E tomamos $n$ pontos $x_l$ igualmente espaçados por $h$:\n",
    "### $h = \\frac{x_f - x_0}{n}$\n",
    "\n",
    "Sendo que:\n",
    "### $x_l = x_0 + hl, l = 0, 1, 2, ..., n$\n",
    "\n",
    "E aí fazendo umas expansões de taylor loucas e tal a gente chega em:\n",
    "\n",
    "### $y_{l+1} = f(x_l, y_l)h$\n",
    "### $y_0 = y(x_0)$\n",
    "### $h=\\frac{x_f - x_0}{n}$\n",
    "### $l = 0, 1, 2, ..., n-1$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def metodo_de_euler(y0, n, I, f):\n",
    "    \"\"\"\n",
    "    y0: valor inicial de y\n",
    "    n: quantos pontos teremos no dominio I\n",
    "    I: lista do tipo [x0, xf]\n",
    "    f: função do tipo f(x,y) callback que com base em valor de x e y, retorna resultado \n",
    "    \"\"\"\n",
    "    x = []\n",
    "    y = [y0]\n",
    "    h = (I[1] - I[0])/n\n",
    "    for l in range(n+1):\n",
    "        x.append(I[0] + h * l)\n",
    "    for i in range(1, n+1):\n",
    "        y.append(y[i-1] + h*f(x[i-1], y[i-1]))\n",
    "    return np.array(y)       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         1.         0.99       0.9702     0.941094   0.90345024\n",
      " 0.85827773 0.80678106 0.75030639 0.69028188 0.62815651]\n"
     ]
    }
   ],
   "source": [
    "funcao = lambda x, y: -x*y\n",
    "I = [0, 1]\n",
    "n = 10\n",
    "y0 = 1\n",
    "print(metodo_de_euler(y0, n, I, funcao))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Método de Euler Modificado (ou Runge-Kutta de ordem 2)\n",
    "\n",
    "### $y_{l+1} = y_l + \\frac{h}{2} (K_1 + K_2)$\n",
    "\n",
    "### $K_1 = f(x_l, y_l)$\n",
    "### $K_2 = f(x_{l+1}, y_l + h \\times K_1)$\n",
    "\n",
    "## Prova \n",
    "![Confia](https://pt-static.z-dn.net/files/d9c/1929a38a25154c8991c29165efec84ca.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euler_modificado(y0, n, I, f):\n",
    "    \"\"\"\n",
    "    y0: valor inicial de y\n",
    "    n: quantos pontos teremos no dominio I\n",
    "    I: lista do tipo [x0, xf]\n",
    "    f: função do tipo f(x,y) callback que com base em valor de x e y, retorna resultado \n",
    "    \"\"\"\n",
    "    x = []\n",
    "    y = [y0]\n",
    "    h = (I[1] - I[0])/n\n",
    "    for l in range(n+1):\n",
    "        x.append(I[0] + h * l)\n",
    "    for l in range(1, n+1):\n",
    "        K1 = f(x[l-1], y[l-1])\n",
    "        K2 = f(x[l], y[l-1] + h*K1)\n",
    "        y.append(y[l-1] + (K1+K2)*h/2)\n",
    "    return np.array(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.         1.997      1.98205845 1.9437294  1.87209908 1.76033477\n",
      " 1.60639349 1.41432987 1.19455998 0.96260988 0.73634843]\n"
     ]
    }
   ],
   "source": [
    "funcao = lambda x, y: -3*x*x*y\n",
    "I = [0, 1]\n",
    "n = 10\n",
    "y0 = 2\n",
    "print(euler_modificado(y0, n, I, funcao))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Método de Euler para sistemas de EDO\n",
    "Tendo o sistema:\n",
    "### $ y' = f(x, y, z)\\\\z' = g(x, y, z)$\n",
    "\n",
    "Com condição inicial $y(x_0) = y_0, z(x_0) = z_0$\n",
    "\n",
    "A solução será do tipo\n",
    "### $Y(x_l) = \\begin{bmatrix} y(x_l) \\\\ z(x_l) \\end{bmatrix}$\n",
    "\n",
    "Sendo dado por:\n",
    "\n",
    "### $Y_{l+1} = Y_l + \\frac{h}{2} \\times (K_1 + K_2)$\n",
    "\n",
    "### $K_1 = \\begin{bmatrix} f(x_l, y_l, z_l) \\\\ g(x_l, y_l, z_l) \\end{bmatrix} =\n",
    "\\begin{bmatrix} K_{11} \\\\ K_{21} \\end{bmatrix}\n",
    "$\n",
    "\n",
    "### $K_2 = \\begin{bmatrix} \n",
    "f(x_{l+1}, y_l + h\\times K_{11}, z_l + h \\times K_{21} \\\\\n",
    "g(x_{l+1}, y_l + h\\times K_{11}, z_l + h \\times K_{21}\n",
    "\\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def euler_sistema(y0, z0, n, I, f, g):\n",
    "    \"\"\"\n",
    "    y0: valor inicial de y\n",
    "    z0: valor inicial de z\n",
    "    n: quantos pontos teremos no dominio I\n",
    "    I: lista do tipo [x0, xf]\n",
    "    f: função de callback do tipo f(x, y, z)\n",
    "    g: função de callback do tipo g(x, y, z)\n",
    "    \"\"\"\n",
    "    x = []\n",
    "    y = [y0]\n",
    "    z = [z0]\n",
    "    h = (I[1] - I[0])/n\n",
    "    for l in range(n+1):\n",
    "        x.append(I[0] + h * l)\n",
    "    for l in range(1, n+1):\n",
    "        K1y = f(x[l-1], y[l-1], z[l-1])\n",
    "        K1z = g(x[l-1], y[l-1], z[l-1])\n",
    "        \n",
    "        K2y = f(x[l-1]+h/2, y[l-1] + h/2 * K1y, z[l-1] + h/2 * K1z)\n",
    "        K2z = g(x[l-1]+h/2, y[l-1] + h/2 * K1y, z[l-1] + h/2 * K1z)\n",
    "        \n",
    "        y.append(y[l-1] + (K2y)/2)\n",
    "        z.append(z[l-1] + (K2z)/2)\n",
    "    Y = []\n",
    "    for i in range(len(y)):\n",
    "        tmp = [y[i], z[i]]\n",
    "        Y.append(tmp)\n",
    "        \n",
    "    return np.array(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4.         2.       ]\n",
      " [ 4.        -2.5      ]\n",
      " [ 1.90625   -4.3046875]]\n"
     ]
    }
   ],
   "source": [
    "y0 = 4\n",
    "z0 = 2\n",
    "I = [0, 1]\n",
    "n = 2\n",
    "f = lambda x, y, z: z\n",
    "g = lambda x, y, z: -x*z-2*y\n",
    "resultado = euler_sistema(y0, z0, n, I, f, g)\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Método de Range-Kutta de ordem 4\n",
    "\n",
    "### $y_{l+1} = y_l + \\frac{h}{6} \\times (K_1 + 2 K_2 + 2 K_3 + K_4)$\n",
    "\n",
    "### $K_1 = f(x_l, y_l)$\n",
    "### $K_2 = f(x_l + \\frac{h}{2}, y_l + \\frac{h}{2} \\times K_1)$\n",
    "### $K_3 = f(x_l + \\frac{h}{2}, y_l + \\frac{h}{2} \\times K_2)$\n",
    "### $K_4 = f(x_l + h, y_l + h \\times K_3)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def runge_kutta_4(y0, n, I, f):\n",
    "    \"\"\"\n",
    "    y0: valor inicial de y\n",
    "    n: quantos pontos teremos no dominio I\n",
    "    I: lista do tipo [x0, xf]\n",
    "    f: função do tipo f(x,y) callback que com base em valor de x e y, retorna resultado \n",
    "    \"\"\"\n",
    "    x = []\n",
    "    y = [y0]\n",
    "    h = (I[1] - I[0])/n\n",
    "    for l in range(n+1):\n",
    "        x.append(I[0] + h * l)\n",
    "    \n",
    "    for l in range(1, n+1):\n",
    "        K1 = f(x[l-1], y[l-1])\n",
    "        K2 = f(x[l-1] + h/2, y[l-1] + K1*h/2)  \n",
    "        K3 = f(x[l-1] + h/2, y[l-1] + K2*h/2)  \n",
    "        K4 = f(x[l-1] + h, y[l-1] + K3*h)  \n",
    "        y.append(y[l-1] + (K1+2*K2+2*K3+K4)*h/6)\n",
    "    return np.array(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         0.99501248]\n"
     ]
    }
   ],
   "source": [
    "y0 = 1\n",
    "I = [0, 0.1]\n",
    "n = 1\n",
    "f = lambda x, y: -x*y\n",
    "resultado = runge_kutta_4(y0, n, I, f)\n",
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Zero de Funções\n",
    "\n",
    "Cansei de fazer o markdown, então só vou falar o q vc precisa fazer\n",
    "\n",
    "Você vai ter uma função $f(x)$ e precisa determinar um intervalo $I = [a;b]$ em que a raiz seja isolada.\n",
    "\n",
    "Em outras palavras, neste intervalo só vai ter um $f(x)=0, x \\in I$ e então o algoritmo vai tentando achar qual é esse $x$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def metodo_bisseccao(I, f, iteracoes):\n",
    "    \"\"\"\n",
    "    Recebe intervalo I, funcao callback f e numero de iterações\n",
    "    OBS: Nos parametros chame uma cópia de I, pois o mesmo vai ser alterado\n",
    "    durante execução!\n",
    "    \"\"\"\n",
    "    a = I[0]\n",
    "    b = I[1]\n",
    "    if iteracoes == 0:\n",
    "        return [(a+b)/2]\n",
    "    else:\n",
    "        lista_de_x = metodo_bisseccao(I, f, iteracoes-1)\n",
    "        x_anterior = lista_de_x[-1]\n",
    "        f_anterior = f(x_anterior)\n",
    "        if f_anterior == 0:\n",
    "            return lista_de_x\n",
    "        f_a = f(a)\n",
    "        f_b = f(b)\n",
    "        if f_a * f_anterior < 0:\n",
    "            I[1] = x_anterior\n",
    "            return lista_de_x + [(I[0] + x_anterior)/2]\n",
    "        else:\n",
    "            I[0] = x_anterior\n",
    "            return lista_de_x + [(I[1] + x_anterior)/2]\n",
    "            \n",
    "iteracoes_para_erro = lambda I, f, erro: round(math.log((I[1]-I[0])/erro, 2)) - 1 # Acha iteracoes para erro menor que erro\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "I = [1, 2]\n",
    "f = lambda x: x*x*x - 2\n",
    "a = (metodo_bisseccao(I.copy(), f, 1))\n",
    "\n",
    "print(iteracoes_para_erro(I, f, 0.00000000000000001))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Métodos de Convergência\n",
    "\n",
    "A partir daqui as coisas ficam mais complicadas e um caderno de python não vai ajudar tanto, pq vc depende de derivadas de funções, então eu criei uma função que plota gráficos aproximados disso. O primeiro serve só pra plota grafico das derivadas e já da pra dar aquela analisada.\n",
    "\n",
    "## Ponto Fixo\n",
    "Achar zeros através de buscas binárias pode ser difícil e ineficientes (muitas iterações para reduzir o erro), o método do ponto fixo busca construir uma função $\\phi(x)$ a partir de $f(x)$, tal que $\\exists \\phi(x^*) = x^*$.\n",
    "\n",
    "Isso é útil, pois $0 = x^* - \\phi(x^*)$, então se: $f(x) = x - \\phi(x)$, podemos dizer:\n",
    "\n",
    "### $\\phi(x) = x + a(x)f(x), a(x) \\ne 0 {\\ }\\forall x$ $f(x^*) = 0 \\iff x^* = g(x^*)$\n",
    "\n",
    "### Regras para convergência do Ponto Fixo\n",
    "- $\\phi$ e $\\phi '$ são contínuas em I\n",
    "- $max|\\phi'(x)| \\le k \\lt 1, x\\in I$\n",
    "- $x_0 \\in I, x_{n+1} = \\phi(x_n) \\in I, n =0, 1, 2,...$\n",
    "\n",
    "Se isso for verdadeiro, $x_{n+1} = \\phi(x_n)$ converge para $x^*$\n",
    "\n",
    "\n",
    "### Escolhendo $x_0$\n",
    "Sendo $I = ]a; b[$\n",
    "Queremos $x_0$ sendo o extremo mais próximo de $I$\n",
    "1. se $g(\\frac{a+b}{2}) \\gt 0, b$ é o extremo mais próximo de $x_0$\n",
    "2. se $g(\\frac{a+b}{2}) \\lt 0, a$ é o extremo mais próximo de $x_0$\n",
    "3. se $g(\\frac{a+b}{2}) = 0$ você achou $x^* = \\frac{a+b}{2}$\n",
    "\n",
    "\n",
    "## Convergência de Newton\n",
    "Caso particular do ponto fixo\n",
    "Constrói $\\phi(x)$ de forma que $\\phi'(x) = 0$\n",
    "### $\\phi (x_n) = x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}$\n",
    "### Regras para convergência de Newton\n",
    " - $f'(x)$ e $f''(x)$ são contínuas em $[a;b]$\n",
    " - $f'(x) \\ne 0 $ e $f''(x) \\ne 0$ para $x \\in [a;b]$\n",
    " - $f'(x)$ e $f''(x)$ são contínuas em $[a;b]$\n",
    "  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plota_funcao(I, f, n_pontos = 10000):\n",
    "    NUMERO_DE_PONTOS=n_pontos\n",
    "    DELTA_X = 0.001\n",
    "    DELTA_X_2 = DELTA_X * DELTA_X\n",
    "    \n",
    "    x = [I[0]]\n",
    "    y = [f(x[0])]\n",
    "    zeros = [0]\n",
    "    x_linha = []\n",
    "    y_linha = []\n",
    "    aumento = (I[1] - I[0])/ NUMERO_DE_PONTOS\n",
    "    \n",
    "    for i in range(1, NUMERO_DE_PONTOS):\n",
    "        x.append(x[i-1] + aumento)\n",
    "        y.append(f(x[i]))\n",
    "        zeros.append(0)\n",
    "        \n",
    "    fig, ax = plt.subplots()\n",
    "    ax.plot(x, y, label = \"Função\")\n",
    "    ax.set_title(\"f(x)\")\n",
    "    plt.show()\n",
    "    \n",
    "    fig, ax = plt.subplots()\n",
    "    \n",
    "    for i in range(NUMERO_DE_PONTOS):\n",
    "        tg = 2 * DELTA_X\n",
    "        y_linha.append((-f(x[i] - DELTA_X) + f(x[i] + DELTA_X))/tg)\n",
    "    ax.plot(x, y_linha)\n",
    "    ax.set_title(\"f'(x)\")\n",
    "    plt.show()\n",
    "    DELTA_X = 0.1\n",
    "    \n",
    "    fig, ax = plt.subplots()\n",
    "    y_2_linha = []\n",
    "    for i in range(NUMERO_DE_PONTOS):\n",
    "\n",
    "        y_2_linha.append((f(x[i]+DELTA_X) - 2*f(x[i]) + f(x[i]-DELTA_X))/(DELTA_X_2))\n",
    "    ax.plot(x, y_2_linha)\n",
    "    \n",
    "    plt.show()\n",
    "    print(len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "I = [-1, 1]\n",
    "funcao = lambda x: x*x*x*x\n",
    "plota_funcao(I, funcao, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def acha_x0(I, g):\n",
    "    conta = g((I[0] + I[1])/2)\n",
    "    if conta == 0:\n",
    "        return conta\n",
    "    if conta > 0:\n",
    "        return I[1]\n",
    "    else:\n",
    "        return I[0]\n",
    "\n",
    "def ponto_fixo_oscilante(I, g, iteracoes, erro):\n",
    "    x0 = acha_x0(I, g)\n",
    "    x = [x0]\n",
    "    k = 0\n",
    "    while k <= iteracoes:\n",
    "        x.append(g(x[-1]))\n",
    "        if abs(x[-1] - x[-2]) <= erro:\n",
    "            break\n",
    "        else:\n",
    "            k += 1\n",
    "    return x[-1]\n",
    "\n",
    "def ponto_fixo(I, g, iteracoes, erro, crescente, phi):\n",
    "    x0 = acha_x0(I, g)\n",
    "    x = x[x0]\n",
    "    k = 0\n",
    "    if not crescente:\n",
    "        erro *= -1 \n",
    "    while k <= iteracoes:\n",
    "        x.append(g(x[-1]))\n",
    "        if phi(g, x[-1] + 2*erro) > 0:\n",
    "            k += 1\n",
    "        else:\n",
    "            break\n",
    "    return x[-1] + erro\n",
    "\n",
    "def ponto_fixo_crescente(I, g, iteracoes, erro):\n",
    "    phi=lambda g, x: g(x) - x\n",
    "    return ponto_fixo(I, g, iteracoes, erro, True, phi)\n",
    "    \n",
    "\n",
    "\n",
    "def ponto_fixo_decrescente(I, g, iteracoes, erro):\n",
    "    phi=lambda g, x: g(x) - x\n",
    "    return ponto_fixo(I, g, iteracoes, erro, False, phi)\n",
    "\n",
    "def metodo_newton_crescente(I, f, f_linha, iteracoes):\n",
    "    g = lambda x: x - f(x)/f_linha(x)\n",
    "    phi = lambda g, x: g(x) - x\n",
    "    return ponto_fixo(I, g, iteracoes, erro, True, phi)\n",
    "\n",
    "def metodo_newton_decrescente(I, f, f_linha, iteracoes):\n",
    "    g = lambda x: x - f(x)/f_linha(x)\n",
    "    phi = lambda g, x: g(x) - x\n",
    "    return ponto_fixo(I, g, iteracoes, erro, False, phi)\n",
    "    \n",
    "    "
   ]
  },
  {
   "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}