numerical-integration.ipynb

{
 "metadata": {
  "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.8.6-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "Python 3.8.6 64-bit",
   "display_name": "Python 3.8.6 64-bit",
   "metadata": {
    "interpreter": {
     "hash": "767d51c1340bd893661ea55ea3124f6de3c7a262a8b4abca0554b478b1e2ff90"
    }
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "## Numerical Integration"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Basic rules"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def trapezoidal_rule(x, y):\n",
    "    assert len(x) == len(y) == 2\n",
    "    h = x[1] - x[0]\n",
    "    return (h/2)*(y[0] + y[1])\n",
    "\n",
    "def simpson_one_third_rule(x, y):\n",
    "    assert len(x) == len(y) == 3\n",
    "    h = x[1] - x[0]\n",
    "    return (h/3)*(y[0] + 4*y[1] + y[2])\n",
    "\n",
    "def simpson_three_eighth_rule(x, y):\n",
    "    assert len(x) == len(y) == 4\n",
    "    h = x[1] - x[0]\n",
    "    return (3*h/8)*(y[0] + 3*y[1] + 3*y[2] + y[3])\n",
    "\n",
    "def boole_rule(x, y):\n",
    "    assert len(x) == len(y) == 5\n",
    "    h = x[1] - x[0]\n",
    "    return (2*h/45)*(7*y[0] + 32*y[1] + 12*y[2] + 32*y[3] + 7*y[4])"
   ]
  },
  {
   "source": [
    "## Composite Newton Cote's Rule"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### Composite trapezoidal rule"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def composite_trapezoidal_rule(x, y):\n",
    "    assert len(x) == len(y)\n",
    "    sum = 0\n",
    "    for i in range(0, len(x)-1):\n",
    "        sum += trapezoidal_rule(x[i:i+2], y[i:i+2])\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Composite trapezoidal rule\n",
    "\n",
    "x = [7.47, 7.48, 7.49, 7.50, 7.51, 7.52]\n",
    "y = [1.93, 1.95, 1.98, 2.01, 2.03, 2.06]\n",
    "\n",
    "composite_trapezoidal_rule(x, y)"
   ]
  },
  {
   "source": [
    "### Composite Simpson's one-third rule"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def composite_simpson_one_third_rule(x, y):\n",
    "    assert len(x) == len(y)\n",
    "    sum = 0\n",
    "    for i in range(0, len(x)-2, 2):\n",
    "        sum += simpson_one_third_rule(x[i:i+3], y[i:i+3])\n",
    "    return sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Composite trapezoidal rule\n",
    "\n",
    "x = [0, 0.25, 0.5, 0.75, 1.00, 1.25, 1.50, 1.75, 2.00]\n",
    "y = [0.5, 0.4923, 0.4706, 0.4384, 0.4, 0.3596, 0.32, 0.2832, 0.25]\n",
    "\n",
    "composite_simpson_one_third_rule(x, y)"
   ]
  },
  {
   "source": [
    "### Composite Simpson's three-eighth rule"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def composite_simpson_three_eighth_rule(x, y):\n",
    "    assert len(x) == len(y)\n",
    "    sum = 0\n",
    "    for i in range(0, len(x)-3, 3):\n",
    "        sum += simpson_three_eighth_rule(x[i:i+4], y[i:i+4])\n",
    "    return sum"
   ]
  },
  {
   "source": [
    "### Composite Boole's rule"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def composite_boole_rule(x, y):\n",
    "    assert len(x) == len(y)\n",
    "    sum = 0\n",
    "    for i in range(0, len(x)-4, 4):\n",
    "        sum += simpson_three_eighth_rule(x[i:i+5], y[i:i+5])\n",
    "    return sum"
   ]
  }
 ]
}