regra_de_simpson.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy as sp"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementação do método de Simpson\n",
    "\n",
    "#### Explicação do método:\n",
    "\n",
    "A Regra de Simpson é uma aproximação da integral usando parábolas para aproximar a função. Ela é uma melhoria da regra do Trapézio, pois utiliza mais pontos para fazer a aproximação. A ideia é dividir o intervalo de integração em pares de subintervalos e aproximar a função em cada um desses pares por uma parábola. A área de cada parábola é então somada e multiplicada por um fator $\\frac{h}{3}$, onde $h$ é o tamanho de cada subintervalo. O resultado é a aproximação da integral.\n",
    "\n",
    "- A fórmula da Regra de Simpson para aproximação de uma integral é: $$\\int_{a}^{b} f(x) ,dx \\approx \\frac{h}{3} \\left[f(x_0) + 4f(x_1) + 2f(x_2) + 4f(x_3) + 2f(x_4) + \\cdots + 2f(x_{n-2}) + 4f(x_{n-1}) + f(x_n)\\right]$$\n",
    "\n",
    "- Onde $h = \\frac{b-a}{n}$, $n$ é o número de divisões do intervalo $[a, b]$, e $x_0 = a$, $x_n = b$ e $x_i = a + ih$, para $i=1, 2, 3, \\ldots, n-1$.\n",
    "\n",
    "#### Explicação da implementação\n",
    "\n",
    "- A implementação do código é a função simpson, que recebe quatro argumentos: a função a ser integrada, os limites inferior e superior do intervalo de integração e o número de divisões que serão feitas no intervalo \n",
    "  \n",
    "    - Primeiro, a função verifica se o número de divisões é par, como é requerido pela regra de Simpson.\n",
    "    - Em seguida, é calculado o valor de h, que é a largura de cada subintervalo do intervalo de integração.\n",
    "    - É feita uma soma inicial, somando os valores da função nos limites inferior e superior do intervalo de integração.\n",
    "    - Um loop percorre os subintervalos de índices ímpares, adicionando 4 vezes o valor da função no ponto médio de cada subintervalo à soma.\n",
    "    - Um segundo loop percorre os subintervalos de índices pares, adicionando 2 vezes o valor da função no ponto médio de cada subintervalo à soma.\n",
    "    - Por fim, a aproximação da integral é calculada pela fórmula da regra de Simpson, que envolve multiplicar a soma por h/3.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simpson(funcao_fx, intervalo_1, intervalo_2, iteracoes):\n",
    "    \n",
    "    #O primeiro bloco faz uma verificação se o número de iterações é par. A regra de Simpson requer que o \n",
    "    # número de iterações seja par, pois o método faz a aproximação por pares de intervalos. \n",
    "    if iteracoes % 2 == 1:\n",
    "        print(\"Número de divisões deve ser par!\")\n",
    "        return None\n",
    "    \n",
    "    # Calculado o valor de h, que é a largura de cada subintervalo do intervalo de integração.\n",
    "    h = (intervalo_2 - intervalo_1) / iteracoes\n",
    "    soma = funcao_fx(intervalo_1) + funcao_fx(intervalo_2)\n",
    "    \n",
    "    # Utiliza um loop para percorrer os subintervalos de índices ímpares, e adiciona 4 vezes o valor da \n",
    "    # função no ponto médio de cada subintervalo à soma.\n",
    "    for i in range(1, iteracoes, 2):\n",
    "        soma += 4 * funcao_fx(intervalo_1 + i * h)\n",
    "        \n",
    "    # Utiliza um segundo loop para percorrer os subintervalos de índices pares, e adiciona 2 vezes o valor \n",
    "    # da função no ponto médio de cada subintervalo à soma    \n",
    "    for i in range(2, iteracoes-1, 2):\n",
    "        soma += 2 * funcao_fx(intervalo_1 + i * h)\n",
    "    integral = h * soma / 3\n",
    "    \n",
    "    return integral"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sympify\n",
    "\n",
    "O sympify é uma função da biblioteca SymPy que converte uma string contendo uma expressão matemática em uma expressão matemática SymPy. Isso significa que a expressão passa a ser manipulável como um objeto SymPy e não como uma simples string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_str = input(\"Digite a expressão matemática da função: \")\n",
    "expr = sp.sympify(expr_str)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Input's do método\n",
    "\n",
    "- Os dois intervalos iniciais devem ser dados em sequência, começando do mais baixo até o mais alto. O número de iterações será quantas vezes será divido o método\n",
    "  - Lembrando que o método de Simpson apenas aceita iterações de números pares\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "intervalo_1 = float(input(\"Digite o limite inferior do intervalo: \"))\n",
    "intervalo_2 = float(input(\"Digite o limite superior do intervalo: \"))\n",
    "iteracoes = int(input(\"Digite o número de divisões: \"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Função f(x)\n",
    "\n",
    "- A definição da função é dada aqui, antes de chamar o método de aproximação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a função a ser integrada a partir da expressão lida, assim o 'x' não será mais uma string\n",
    "funcao_fx = lambda x: expr.subs('x', x)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aproximação\n",
    "\n",
    "- A integral aproximada é feita na função, passa-se os argumentos da própria função f(x), seus intervalos e quantas iterações serão executadas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calcula a aproximação da integral usando a regra de Simpson\n",
    "integral = simpson(funcao_fx, intervalo_1, intervalo_2, iteracoes)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print's\n",
    "\n",
    "- Para o usuario, será mostrado o polinômio de entrada com seus intervalos e suas iterações. Posteriormente será mostrada quanto foi a aproximação mas tambem uma informação extra, sendo o cáculo da integral para depois vermos a diferença que deu do método para a integral exata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O polinômio lido é: \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} + \\frac{1}{\\sqrt{x}}$"
      ],
      "text/plain": [
       "x**2 + 1/sqrt(x)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Imprime o resultado\n",
    "print(\"O polinômio lido é: \")\n",
    "sp.simplify(expr_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Com intervalos de [2.4, 2.6] com 4 iterações\n"
     ]
    }
   ],
   "source": [
    "print(f\"Com intervalos de [{intervalo_1}, {intervalo_2}] com {iteracoes} iterações\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sua aproximação foi de: \n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.37718308976203$"
      ],
      "text/plain": [
       "1.37718308976203"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Sua aproximação foi de: \")\n",
    "sp.simplify(integral)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = sp.Symbol('x')\n",
    "integral_real = sp.integrate(funcao_fx(x), (x, intervalo_1, intervalo_2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sua integral real tem valor de:\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.37718308902015$"
      ],
      "text/plain": [
       "1.37718308902015"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Calcula o valor da integral sem usar nenhum método de aproximação\n",
    "print(\"Sua integral real tem valor de:\")\n",
    "sp.simplify(integral_real)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O erro da aproximação foi de: 0.000000000741875227916466\n"
     ]
    }
   ],
   "source": [
    "erro = integral - integral_real\n",
    "print(\"O erro da aproximação foi de:\", format(erro, '9f'))"
   ]
  }
 ],
 "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.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}