interpolation_and_sampler.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0a9bdd55",
   "metadata": {},
   "source": [
    "# *First and Second Assignment*\n",
    "First\n",
    "- Generate Interpolation Function;\n",
    "- Interpolate a a gaussian and compare the error to real Gaussian data;\n",
    "- Find the cumulative of the interpolated function and compare to the real cumulative;\n",
    "\n",
    "Second\n",
    "- Generate a sample using linear interpolation in the cumulative points;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "568d2478",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sc\n",
    "from scipy.special import erf\n",
    "import random as rd\n",
    "import matplotlib.pyplot as plt\n",
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "896bc574",
   "metadata": {},
   "source": [
    "# Interpolation Fcuntion\n",
    "\n",
    "We want to generate a linear interpolation function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0a8c3f08",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinearInterp:\n",
    "    def __init__(self, x_data, y_data):\n",
    "        self.x_data = x_data\n",
    "        self.y_data = y_data\n",
    "        self.cumulative_data = None\n",
    "   \n",
    "\n",
    "    def do_interp(self, x):\n",
    "        for a in range(0, len(self.y_data)-1):\n",
    "            if x >= self.x_data[a] and x <= self.x_data[a+1]:\n",
    "                dy = self.y_data[a+1] - self.y_data[a]\n",
    "                dx = self.x_data[a+1] - self.x_data[a]\n",
    "                coef_b = self.y_data [a] - (self.x_data[a] * dy) / dx  \n",
    "                coef_a = dy / dx\n",
    "                new_point = coef_b + x * coef_a\n",
    "                return [new_point, (coef_a, coef_b),(self.x_data[a], self.x_data[a+1])]\n",
    "    \n",
    "    def do_cumulative(self, a, b):\n",
    "        cumulative = 0\n",
    "        for x in self.x_data:\n",
    "            if x>=a and x<=b:\n",
    "                result = self.do_interp(x)\n",
    "                cumulative += result[2][1] ** 2 * result[1][0] /2 + result[2][1]*result[1][1] - result[2][0] ** 2 * result[1][0] /2 - result[2][0]*result[1][1]  \n",
    "        return [cumulative, result[1][0], result[1][1]]\n",
    "\n",
    "#This function checks if I generated one point before (if the cumulative data is empty. If I didnt, it computes the cumulative for all the knots).\n",
    "    def generate_random_g_point(self, a, b):\n",
    "        if self.cumulative_data == None:\n",
    "            temporary_list = []\n",
    "            for knot in range(0,len(self.x_data)-1):\n",
    "                temporary_list.append(self.do_cumulative(a, self.x_data[knot])[0])\n",
    "            self.cumulative_data = temporary_list\n",
    "        c = rd.uniform(min(self.cumulative_data),max(self.cumulative_data))\n",
    "        for knot in range(0,len(self.x_data)-1):\n",
    "            cumulative_i = self.cumulative_data[knot]\n",
    "            if cumulative_i >= c:\n",
    "                cumulative_j = self.do_cumulative(a, self.x_data[knot+1])[0]\n",
    "                dy = self.x_data[knot+1] - self.x_data[knot]\n",
    "                dx = cumulative_j - cumulative_i\n",
    "                coef_b = self.x_data[knot] - (cumulative_i * dy) / dx  \n",
    "                coef_a = dy / dx\n",
    "                new_point = coef_b + c * coef_a\n",
    "                return [new_point, (coef_a, coef_b),(self.x_data[a], self.x_data[a+1]), c]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "340ed96f",
   "metadata": {},
   "source": [
    "### Simple Test with a parabolic function \n",
    "\n",
    "Let's us first test our interpolation with a quadratic function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "690494fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Interpolated Point :6.5\n",
      "Real Point 6.25\n"
     ]
    }
   ],
   "source": [
    "x = [0,1,2,3,4]\n",
    "y = [a**2 for a in x]\n",
    "\n",
    "myobj = LinearInterp(x,y)\n",
    "n_p, coef_a, coef_b = myobj.do_interp(2.5)\n",
    "print(f\"Interpolated Point :{n_p}\")\n",
    "print(f\"Real Point {2.5**2}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b250693c",
   "metadata": {},
   "source": [
    "### Test With a Gaussian Function and Error plot\n",
    "\n",
    "Now, we test our interpolated function with a Gaussian function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c8c477e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "mu = 0\n",
    "sigma = 1\n",
    "interval_init = -5\n",
    "interval_end = 5\n",
    "def gaussian(x, mu, sig):\n",
    "    return np.exp(-np.power(x - mu, 2.) / (2 * np.power(sig, 2.))) * (1/ (np.sqrt(2 * np.pi)*sig))\n",
    "\n",
    "def gaussian_cdf(b, mu, sig):\n",
    "    arg = (b - mu)/(np.sqrt(2) * sig)\n",
    "    return 1/2 * (1 + erf(arg))\n",
    "\n",
    "\n",
    "x = np.linspace(interval_init,interval_end, 500)\n",
    "y = [gaussian(a, mu,sigma) for a in x]\n",
    "myobj = LinearInterp(x,y)\n",
    "\n",
    "err_list = []\n",
    "points_int = []\n",
    "for a in range (0,100):\n",
    "    point = rd.uniform(min(x),max(x))\n",
    "    n_p = myobj.do_interp(point)\n",
    "    err_list.append(abs(((n_p[0] - gaussian(point, mu, sigma)))))\n",
    "    points_int.append(n_p[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "79678e73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, ' Absolute Error')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(points_int, err_list, '.')\n",
    "plt.xlabel('Interpolated Points')\n",
    "plt.ylabel(' Absolute Error')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0f1fa7d",
   "metadata": {},
   "source": [
    "## Cumulative Gaussian Test\n",
    "\n",
    "Here, we calculate the cumulative function from the interpolated probability and then compare to the real values of the cumulative from a Gaussian function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0e954895",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, ' Interpolated Cumulative Error')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cdf_int = []\n",
    "cdf_real = []\n",
    "cdf_err = []\n",
    "interval = np.linspace(interval_init,interval_end, 500)\n",
    "for a in interval:\n",
    "    my_cdf = myobj.do_cumulative(-5,a)[0]\n",
    "    g_cdf = gaussian_cdf(a,mu,sigma)\n",
    "    cdf_int.append(my_cdf)\n",
    "    cdf_real.append(g_cdf)\n",
    "    cdf_err.append(abs((my_cdf - g_cdf)/g_cdf)*100)\n",
    "plt.plot(interval, cdf_err, '.')\n",
    "plt.xlabel('Interval')\n",
    "plt.ylabel(' Interpolated Cumulative Error')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b15f2140",
   "metadata": {},
   "source": [
    "## Sampler from the Cumulative\n",
    "\n",
    "We have a cumulative function that depends on $x$. We interpolated the proabbility and integrated to get the cumulative, so now we have a set of points $\\{x, C(x)\\}$. We can inverte this relations, such that we interpolate $\\{C, x(C)\\}$, so we are now able to generate points distributed by the gaussian, using the cumulative function, which is uniform and can be genarated by ````rd.uniform()````."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bfa940cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "##My sampler points, represented by sample\n",
    "\n",
    "sample = []\n",
    "for a in range (0,10000):\n",
    "    new_sample_p = myobj.generate_random_g_point(interval_init, interval_end)\n",
    "    sample.append(new_sample_p[0])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "57adf9a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.stats import truncnorm\n",
    "\n",
    "##Function to generate gaussian points from a definite interval.\n",
    "\n",
    "def get_truncated_normal(mean=0, sd=1, low=0, upp=10):\n",
    "    return truncnorm(\n",
    "        (low - mean) / sd, (upp - mean) / sd, loc=mean, scale=sd)\n",
    "real_gauss = get_truncated_normal(mean=0, sd=1, low=interval_init, upp=interval_end)\n",
    "\n",
    "\n",
    "## Plot of the results\n",
    "fig, ax = plt.subplots(2, sharex=True)\n",
    "ax[0].hist(sample,        )\n",
    "ax[1].hist(real_gauss.rvs(10000))\n",
    "\n",
    "ax[0].set_title('My Sampler')\n",
    "ax[0].set_xlabel('$x$')\n",
    "ax[0].set_ylabel('Number of Points')\n",
    "\n",
    "ax[1].set_xlabel('$x$')\n",
    "ax[1].set_ylabel('Number of Points')\n",
    "ax[1].set_title('Normal Gaussian Sampler')\n",
    "\n",
    "plt.subplots_adjust(wspace=0.4, \n",
    "                    hspace=0.4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "443bad2b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65c215cd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6b17e8c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}