Numerical_integration.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Постановка задачи"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для функции $f(x)$, заданной таблично, вычислить значение интеграла, используя формулу Симпсона.\n",
    "\n",
    "$x$    |0|0.25 |0.5  |0.75 |1    |1.25 |1.5  |1.75|2\n",
    "-------|-|-----|-----|-----|-----|-----|-----|----|--\n",
    "$f(x)$ |0|0.004|0.015|0.034|0.059|0.089|0.123|0.3 |0.2\n",
    "\n",
    "Поставим также задачу добиться точности $0.002$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({0.0: 0,\n",
       "  0.25: 0.004,\n",
       "  0.5: 0.015,\n",
       "  0.75: 0.034,\n",
       "  1.0: 0.059,\n",
       "  1.25: 0.089,\n",
       "  1.5: 0.123,\n",
       "  1.75: 0.3,\n",
       "  2.0: 0.2},\n",
       " 0.059)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f_val = dict(zip(np.arange(0, 2.25, 0.25), [0, 0.004, 0.015, 0.034, 0.059, 0.089, 0.123, 0.3, 0.2]))\n",
    "f_val, f_val[1.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Вычисления интерала"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Формула Симпсона\n",
    "$$\\int\\limits^b_a f(x)dx=\\frac{b−a}{6}\\left[f(a)+4f\\left(\\frac{a+b}{2}\\right)+f(b)\\right]$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для оценки точности будем использовать правило Рунге.\n",
    "Погрешность вычисления значения интеграла при числе шагов, равном 2n:\n",
    "$$\\Delta_{2n}=\\frac{|I_{2n} - I_n|}{2^p - 1},$$\n",
    "где $p$ - порядок аппроксимации\n",
    "\n",
    "При использовании формулы Симпсона: $$\\Delta_{2n}=\\frac{1}{15}|I_{2n} - I_n|$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "def simpson_method(func, mim_lim=0.0, max_lim=2.0, delta=0.002):\n",
    "    def integrate(func, mim_lim, max_lim, n):\n",
    "        integral = 0.0\n",
    "        step = (max_lim - mim_lim) / n\n",
    "        i = 0.0\n",
    "        while i + step*2 <= max_lim:\n",
    "            integral += step / 6 * (func[i] + 4 * func[i + step] + func[i + step*2])\n",
    "            i += 0.25\n",
    "        return integral\n",
    "\n",
    "    d, n = 1e10, 1\n",
    "    while n <= 4:\n",
    "        d = abs(integrate(func, mim_lim, max_lim, n) - integrate(func, mim_lim, max_lim, n*2)) / 15\n",
    "        print('Шаг: ', round(max_lim - mim_lim) / n, ', число точек: ', n)\n",
    "        print('d = ', d)\n",
    "        if d < delta:\n",
    "            print('Потребовалось', n, 'точек')\n",
    "            return integrate(func, mim_lim, max_lim, n)\n",
    "        else:\n",
    "            n *= 2\n",
    "            \n",
    "    print(\"Can't get such accuracy: {}\".format(delta))\n",
    "    return -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Шаг:  2.0 , число точек:  1\n",
      "d =  0.004844444444444444\n",
      "Шаг:  1.0 , число точек:  2\n",
      "d =  0.0071722222222222205\n",
      "Шаг:  0.5 , число точек:  4\n",
      "d =  0.001905555555555553\n",
      "Потребовалось 4 точек\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.18024999999999997"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simpson_method(f_val, delta=0.002)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Анализ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Проанализируем, какая точность будет максимально достижима"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Шаг:  2.0 , число точек:  1\n",
      "d =  0.004844444444444444\n",
      "Шаг:  1.0 , число точек:  2\n",
      "d =  0.0071722222222222205\n",
      "Шаг:  0.5 , число точек:  4\n",
      "d =  0.001905555555555553\n",
      "Can't get such accuracy: 0.001\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simpson_method(f_val, delta=0.0010)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что максимальная точность $\\approx$ 0.00191"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заметим, что мы можем посчитать интеграл, используя все 8 точек (т.е. с шагом 0.25). Однако в этом случае мы не уже сможем посчитать интеграл с удвоенным шагом, то есть не сможем доказать точность по правилу Рунге."
   ]
  }
 ],
 "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}