paperversionspellman.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "            df1=pd.read_excel(r'cho_data.xlsx')\n",
    "#df2=pd.read_csv(r'58.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fact(n): \n",
    "    f = 1; \n",
    "    for i in range(2, n + 1): \n",
    "        f *= i; \n",
    "    return f; "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def u_cal(u, n): \n",
    "  \n",
    "    temp = u; \n",
    "    for i in range(1, n): \n",
    "        temp = temp * (u - i); \n",
    "    return temp; "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df2=df2.iloc[:,[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]]\n",
    "df1=df1.drop(\"Unnamed: 0\", axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.array(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.11,  0.1 ,  0.01, ...,  0.58, -0.36,  0.13],\n",
       "       [-0.14, -0.71,  0.1 , ...,  0.55, -0.08,  0.33],\n",
       "       [-0.02, -0.48, -0.11, ...,  0.23, -0.45,  0.02],\n",
       "       ...,\n",
       "       [-0.79, -0.25,  1.18, ..., -0.27, -0.32, -0.19],\n",
       "       [-0.68, -0.19,  1.23, ..., -0.22, -0.33,  0.08],\n",
       "       [-0.37, -0.48,  0.97, ..., -0.2 , -0.09, -0.27]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>alpha0</th>\n",
       "      <th>alpha7</th>\n",
       "      <th>alpha14</th>\n",
       "      <th>alpha21</th>\n",
       "      <th>alpha28</th>\n",
       "      <th>alpha35</th>\n",
       "      <th>alpha42</th>\n",
       "      <th>alpha49</th>\n",
       "      <th>alpha56</th>\n",
       "      <th>alpha63</th>\n",
       "      <th>alpha70</th>\n",
       "      <th>alpha77</th>\n",
       "      <th>alpha84</th>\n",
       "      <th>alpha91</th>\n",
       "      <th>alpha98</th>\n",
       "      <th>alpha105</th>\n",
       "      <th>alpha112</th>\n",
       "      <th>alpha119</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>-0.11</td>\n",
       "      <td>0.10</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.06</td>\n",
       "      <td>0.04</td>\n",
       "      <td>-0.26</td>\n",
       "      <td>0.04</td>\n",
       "      <td>0.19</td>\n",
       "      <td>-0.22</td>\n",
       "      <td>-0.20</td>\n",
       "      <td>0.12</td>\n",
       "      <td>0.21</td>\n",
       "      <td>-0.26</td>\n",
       "      <td>-0.30</td>\n",
       "      <td>0.22</td>\n",
       "      <td>0.58</td>\n",
       "      <td>-0.36</td>\n",
       "      <td>0.13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>-0.14</td>\n",
       "      <td>-0.71</td>\n",
       "      <td>0.10</td>\n",
       "      <td>-0.32</td>\n",
       "      <td>-0.40</td>\n",
       "      <td>-0.58</td>\n",
       "      <td>0.11</td>\n",
       "      <td>0.21</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.57</td>\n",
       "      <td>-0.14</td>\n",
       "      <td>0.29</td>\n",
       "      <td>0.01</td>\n",
       "      <td>0.04</td>\n",
       "      <td>0.05</td>\n",
       "      <td>0.55</td>\n",
       "      <td>-0.08</td>\n",
       "      <td>0.33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>-0.02</td>\n",
       "      <td>-0.48</td>\n",
       "      <td>-0.11</td>\n",
       "      <td>0.12</td>\n",
       "      <td>-0.03</td>\n",
       "      <td>0.19</td>\n",
       "      <td>0.13</td>\n",
       "      <td>0.76</td>\n",
       "      <td>0.07</td>\n",
       "      <td>0.04</td>\n",
       "      <td>-0.06</td>\n",
       "      <td>0.30</td>\n",
       "      <td>-0.47</td>\n",
       "      <td>-0.16</td>\n",
       "      <td>-0.11</td>\n",
       "      <td>0.23</td>\n",
       "      <td>-0.45</td>\n",
       "      <td>0.02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>-0.05</td>\n",
       "      <td>-0.53</td>\n",
       "      <td>-0.47</td>\n",
       "      <td>-0.06</td>\n",
       "      <td>0.11</td>\n",
       "      <td>-0.07</td>\n",
       "      <td>0.25</td>\n",
       "      <td>0.46</td>\n",
       "      <td>0.12</td>\n",
       "      <td>0.49</td>\n",
       "      <td>-0.42</td>\n",
       "      <td>0.28</td>\n",
       "      <td>-0.30</td>\n",
       "      <td>-0.18</td>\n",
       "      <td>-0.30</td>\n",
       "      <td>0.68</td>\n",
       "      <td>-0.24</td>\n",
       "      <td>0.22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>-0.60</td>\n",
       "      <td>-0.45</td>\n",
       "      <td>-0.13</td>\n",
       "      <td>0.35</td>\n",
       "      <td>-0.01</td>\n",
       "      <td>0.49</td>\n",
       "      <td>0.18</td>\n",
       "      <td>0.43</td>\n",
       "      <td>-0.23</td>\n",
       "      <td>-0.30</td>\n",
       "      <td>-0.24</td>\n",
       "      <td>0.23</td>\n",
       "      <td>0.04</td>\n",
       "      <td>0.09</td>\n",
       "      <td>0.18</td>\n",
       "      <td>0.16</td>\n",
       "      <td>-0.01</td>\n",
       "      <td>-0.21</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   alpha0  alpha7  alpha14  alpha21  alpha28  alpha35  alpha42  alpha49  \\\n",
       "0   -0.11    0.10     0.01     0.06     0.04    -0.26     0.04     0.19   \n",
       "1   -0.14   -0.71     0.10    -0.32    -0.40    -0.58     0.11     0.21   \n",
       "2   -0.02   -0.48    -0.11     0.12    -0.03     0.19     0.13     0.76   \n",
       "3   -0.05   -0.53    -0.47    -0.06     0.11    -0.07     0.25     0.46   \n",
       "4   -0.60   -0.45    -0.13     0.35    -0.01     0.49     0.18     0.43   \n",
       "\n",
       "   alpha56  alpha63  alpha70  alpha77  alpha84  alpha91  alpha98  alpha105  \\\n",
       "0    -0.22    -0.20     0.12     0.21    -0.26    -0.30     0.22      0.58   \n",
       "1     0.09     0.57    -0.14     0.29     0.01     0.04     0.05      0.55   \n",
       "2     0.07     0.04    -0.06     0.30    -0.47    -0.16    -0.11      0.23   \n",
       "3     0.12     0.49    -0.42     0.28    -0.30    -0.18    -0.30      0.68   \n",
       "4    -0.23    -0.30    -0.24     0.23     0.04     0.09     0.18      0.16   \n",
       "\n",
       "   alpha112  alpha119  \n",
       "0     -0.36      0.13  \n",
       "1     -0.08      0.33  \n",
       "2     -0.45      0.02  \n",
       "3     -0.24      0.22  \n",
       "4     -0.01     -0.21  "
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def missingvaluegenerator(l,cols):\n",
    "    if(cols==1):\n",
    "        k=random.randint(0,len(l))\n",
    "        return l[k]\n",
    "    if(cols==2):\n",
    "        k1=random.randint(0,len(l))\n",
    "        k2=random.randint(0,len(l))\n",
    "        return l[k1],l[k2]\n",
    "    if(cols==3):\n",
    "        k1=random.randint(0,len(l))\n",
    "        k2=random.randint(0,len(l))\n",
    "        k3=random.randint(0,len(l))\n",
    "        \n",
    "        return l[k1],l[k2],l[k3]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The missing value is   49\n",
      "[0, 14, 28, 42, 56, 70, 84, 98, 112]\n",
      "lag\n",
      "0.07066703719630213\n"
     ]
    }
   ],
   "source": [
    "cols=1\n",
    "l=[0,7,14,21,28,35,42,49,56,63,70,77,84,91,98,105,112,119]\n",
    "pivot1=int(len(l)/6)\n",
    "pivot2=5*pivot1\n",
    "if(cols==1):\n",
    "    k=missingvaluegenerator(l,cols)\n",
    "    print(\"The missing value is  \",k)\n",
    "    mat,n,x=matrix1(l,a,k)\n",
    "    if(l.index(k)<pivot1):\n",
    "        l1=newtonforward(mat,n,x,k)\n",
    "        print(\"nf\")\n",
    "        nrmse=nrmse2(k,l1,l)\n",
    "        print(nrmse)\n",
    "    elif(l.index(k)<pivot2):\n",
    "        l1=lagrange(mat,n,x,k)\n",
    "        print(\"lag\")\n",
    "        nrmse=nrmse2(k,l1,l)\n",
    "        print(nrmse)\n",
    "    else:\n",
    "        l1=newtonbackward(mat,n,x,k)\n",
    "        print(\"nbf\")\n",
    "        nrmse=nrmse2(k,l1,l)\n",
    "        print(nrmse)\n",
    "if(cols==2):\n",
    "    k1,k2=missingvaluegenerator(l,cols)\n",
    "    print(k1,k2)\n",
    "\n",
    "    mat,n,x=matrix2(l,a,k1,k2)\n",
    "    if(l.index(k1)<pivot1):\n",
    "        l1=newtonforward(mat,n,x,k1)\n",
    "        nrmse=nrmse2(k1,l1,l)\n",
    "        print(nrmse)\n",
    "        \n",
    "    elif(l.index(k1)<pivot2):\n",
    "        l1=newtonbackward(mat,n,x,k1)\n",
    "        nrmse=nrmse2(k1,l1,l)\n",
    "        print(nrmse)\n",
    "    else:\n",
    "        l1=lagrange(mat,n,x,k1)\n",
    "        nrmse=nrmse2(k1,l1,l)\n",
    "        print(nrmse)\n",
    "    if(l.index(k2)<pivot1):\n",
    "        l2=newtonforward(mat,n,x,k2)\n",
    "        nrmse=nrmse2(k2,l2,l)\n",
    "        print(nrmse)\n",
    "\n",
    "    elif(l.index(k2)<pivot2):\n",
    "        l2=newtonbackward(mat,n,x,k2)\n",
    "        nrmse=nrmse2(k2,l2,l)\n",
    "        print(nrmse)\n",
    "       \n",
    "    else:\n",
    "        l2=lagrange(mat,n,x,k2)\n",
    "        nrmse=nrmse2(k2,l2,l)\n",
    "        print(nrmse)\n",
    "        \n",
    "if(cols==3):\n",
    "    k1,k2,k3=missingvaluegenerator(l,cols)\n",
    "    print(k1,k2,k3)\n",
    "\n",
    "    mat,n,x=matrix3(l,a,k1,k2,k3)\n",
    "    if(l.index(k1)<pivot1):\n",
    "        l1=newtonforward(mat,n,x,k1)\n",
    "        nrmse=nrmse2(k1,l1,l)\n",
    "        print(nrmse)\n",
    "       \n",
    "    elif(l.index(k1)<pivot2):\n",
    "        l1=newtonbackward(mat,n,x,k1)\n",
    "        nrmse=nrmse2(k1,l1,l)\n",
    "        print(nrmse)\n",
    "        \n",
    "    else:\n",
    "        l1=lagrange(mat,n,x,k1)\n",
    "        nrmse=nrmse2(k1,l1,l)\n",
    "        print(nrmse)\n",
    "    if(l.index(k2)<pivot1):\n",
    "        l2=newtonforward(mat,n,x,k2)\n",
    "        nrmse=nrmse2(k2,l2,l)\n",
    "        print(nrmse)\n",
    "       \n",
    "    elif(l.index(k2)<pivot2):\n",
    "        l2=newtonbackward(mat,n,x,k2)\n",
    "        nrmse=nrmse2(k2,l2,l)\n",
    "        print(nrmse)\n",
    "        \n",
    "    else:\n",
    "        l2=lagrange(mat,n,x,k2)\n",
    "        nrmse=nrmse2(k2,l2,l)\n",
    "        print(nrmse)\n",
    "    if(l.index(k3)<pivot1):\n",
    "        l3=newtonforward(mat,n,x,k3)\n",
    "        nrmse=nrmse2(k3,l3,l)\n",
    "        print(nrmse)\n",
    "       \n",
    "    elif(l.index(k3)<pivot2):\n",
    "        l3=newtonbackward(mat,n,x,k3)\n",
    "        nrmse=nrmse2(k3,l3,l)\n",
    "        print(nrmse)\n",
    "        \n",
    "    else:\n",
    "        l3=lagrange(mat,n,x,k3)\n",
    "        nrmse=nrmse2(k3,l3,l)\n",
    "        print(nrmse)\n",
    "        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random 2 previous inputted\n",
    "a=np.array(df1)\n",
    "l=[0,7,14,21,28,35,42,49,56,63,70,77,84,91,98,105,112,119]\n",
    "pivot1=int(len(l)/6)\n",
    "pivot2=5*pivot1\n",
    "k1,k2=missingvaluegenerator(l,2)\n",
    "mat,n,x=matrix2(l,a,k1,k2)\n",
    "if(l.index(k1)<pivot1):\n",
    "        l1=newtonforward(mat,n,x,k1)\n",
    "        n1=nrmse2(k1,l1,l)\n",
    "        print(n1)\n",
    "        \n",
    "elif(l.index(k1)<pivot2):\n",
    "        l1=newtonbackward(mat,n,x,k1)\n",
    "        n1=nrmse2(k1,l1,l)\n",
    "        print(n1)\n",
    "else:\n",
    "        l1=lagrange(mat,n,x,k1)\n",
    "        n1=nrmse2(k1,l1,l) \n",
    "        print(n1)\n",
    "\n",
    "a[:,l.index(k1)]=l1\n",
    "mat,n,x=matrix1(l,a,k2)\n",
    "if(l.index(k2)<pivot1):\n",
    "        l2=newtonforward(mat,n,x,k2)\n",
    "        n2=nrmse2(k2,l2,l)\n",
    "        print(n2)\n",
    "        \n",
    "elif(l.index(k2)<pivot2):\n",
    "        l2=newtonbackward(mat,n,x,k2)\n",
    "        n2=nrmse2(k2,l2,l)\n",
    "        print(n2)\n",
    "else:\n",
    "        l2=lagrange(mat,n,x,k2)\n",
    "        n1=nrmse2(k2,l2,l)\n",
    "        print(n2)\n",
    "print(k1,k2)\n",
    "print((n1+n2)/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#random 3 previous inputted\n",
    "a=np.array(df1)\n",
    "l=[0,7,14,21,28,35,42,49,56,63,70,77,84,91,98,105,112,119]\n",
    "pivot1=int(len(l)/6)\n",
    "pivot2=5*pivot1\n",
    "k1,k2,k3=missingvaluegenerator(l,3)\n",
    "mat,n,x=matrix3(l,a,k1,k2,k3)\n",
    "if(l.index(k1)<pivot1):\n",
    "        l1=newtonforward(mat,n,x,k1)\n",
    "        n1=nrmse2(k1,l1,l)\n",
    "        print(n1)\n",
    "        \n",
    "elif(l.index(k1)<pivot2):\n",
    "        l1=newtonbackward(mat,n,x,k1)\n",
    "        n1=nrmse2(k1,l1,l)\n",
    "        print(n1)\n",
    "else:\n",
    "        l1=lagrange(mat,n,x,k1)\n",
    "        n1=nrmse2(k1,l1,l)\n",
    "        print(n1)\n",
    "\n",
    "a[:,l.index(k1)]=l1\n",
    "mat,n,x=matrix2(l,a,k2,k3)\n",
    "if(l.index(k2)<pivot1):\n",
    "        l1=newtonforward(mat,n,x,k1)\n",
    "        n2=nrmse2(k2,l1,l)\n",
    "        print(n2)\n",
    "        \n",
    "elif(l.index(k2)<pivot2):\n",
    "        l1=newtonbackward(mat,n,x,k1)\n",
    "        n2=nrmse2(k2,l1,l)\n",
    "        print(n2)\n",
    "else:\n",
    "        l1=lagrange(mat,n,x,k1)\n",
    "        n1=nrmse2(k2,l1,l)\n",
    "        print(n2)\n",
    "a[:,l.index(k2)]=l1\n",
    "mat,n,x=matrix1(l,a,k3)\n",
    "if(l.index(k3)<pivot1):\n",
    "        l1=newtonforward(mat,n,x,k3)\n",
    "        n3=nrmse2(k3,l1,l)\n",
    "        print(n3)\n",
    "        \n",
    "elif(l.index(k3)<pivot2):\n",
    "        l1=newtonbackward(mat,n,x,k1)\n",
    "        n3=nrmse2(k3,l1,l)\n",
    "        print(n3)\n",
    "else:\n",
    "        l1=lagrange(mat,n,x,k1)\n",
    "        n3=nrmse2(k3,l1,l)\n",
    "        print(n3)\n",
    "print(k1,k2,k3)\n",
    "print((n1+n2+n3)/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.array(df1)\n",
    "l=[0,7,14,21,28,35,42,49,56,63,70,77,84,91,98,105,112,119]\n",
    "mat,n,x=matrix2(l,a,112,7)\n",
    "\n",
    "l1=newtonforward(mat,n,x,7)\n",
    "nrmse=nrmse2(7,l1,l)\n",
    "print(nrmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nf=[]\n",
    "nb=[]\n",
    "lag=[]\n",
    "for each in l:\n",
    "    mat,n,x= matrix1(l,a,each)\n",
    "    nf1=newtonforward(mat,n,x,each)\n",
    "    nb1=newtonbackward(mat,n,x,each)\n",
    "    lag1=lagrange(mat,n,x,each)\n",
    "    nf.append(nrmse2(each,nf1,l))\n",
    "    nb.append(nrmse2(each,nb1,l))\n",
    "    lag.append(nrmse2(each,lag1,l))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=0\n",
    "nrmsnf=[]\n",
    "nrmsnb=[]\n",
    "nrmslag=[]\n",
    "while(k+1<len(l)-1):\n",
    "    mat,n,x= matrix2(l,a,l[k],l[k+1])\n",
    "    nf1=newtonforward(mat,n,x,l[k])\n",
    "    nf2=newtonforward(mat,n,x,l[k+1])\n",
    "    nrmsea=(nrmse2(l[k],nf1,l)+nrmse2(l[k+1],nf2,l))/2\n",
    "    nb1=newtonbackward(mat,n,x,l[k])\n",
    "    nb2=newtonbackward(mat,n,x,l[k+1])\n",
    "    nrmseb=(nrmse2(l[k],nb1,l)+nrmse2(l[k+1],nb2,l))/2\n",
    "    lag1=lagrange(mat,n,x,l[k])\n",
    "    lag2=lagrange(mat,n,x,l[k+1])\n",
    "    nrmsec=(nrmse2(l[k],lag1,l)+nrmse2(l[k+1],lag2,l))/2\n",
    "    k=k+1\n",
    "    nrmslag.append(nrmsec)\n",
    "    nrmsnb.append(nrmseb)\n",
    "    nrmsnf.append(nrmsea)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for successive 1 column\n",
    "for i in range(len(nf)):\n",
    "    k=min(nf[i],nb[i],lag[i])\n",
    " \n",
    "    if(nf[i]==k):\n",
    "        print(\"nf\")\n",
    "    elif(nb[i]==k):\n",
    "        print(\"nb\")\n",
    "    else:\n",
    "        print(\"lag\")\n",
    "for i in range(len(nf)):\n",
    "    print(round(nf[i],5), end=\" \")\n",
    "    print(round(lag[i],5),end=\" \")\n",
    "    print(round(nb[i],5),end=\" \")\n",
    "    print(\"\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#for 2 successive columns\n",
    "for i in range(len(nrmsnf)):\n",
    "    k=min(nrmsnf[i],nrmsnb[i],nrmslag[i])\n",
    " \n",
    "    if(nrmsnf[i]==k):\n",
    "        print(\"nf\")\n",
    "    elif(nrmsnb[i]==k):\n",
    "        print(\"nb\")\n",
    "    else:\n",
    "        print(\"lag\")\n",
    "for i in range(len(nrmsnf)):\n",
    "    print(round(nrmsnf[i],5), end=\" \")\n",
    "    print(round(nrmslag[i],5),end=\" \")\n",
    "    print(round(nrmsnb[i],5),end=\" \")\n",
    "    print(\"\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def matrix1(l,a,k): \n",
    "    \n",
    "    x=[]\n",
    "    for i in range(len(l)):\n",
    "        if(l[i]==k):\n",
    "            n1=i\n",
    "    if(n1%2==0):\n",
    "        index=1\n",
    "        diff=2\n",
    "    else:\n",
    "        index=0\n",
    "        diff=2\n",
    "    ind=index\n",
    "   \n",
    "    while 1:\n",
    "        if(index>len(l)-1):\n",
    "            break\n",
    "        x.append(l[index])\n",
    "        index=index+diff\n",
    "    n=len(x)\n",
    "    print(x)\n",
    "    mat=np.zeros((a.shape[0],n))\n",
    "    for i in range(int(a.shape[0])):\n",
    "        mat[i]=a[i][ind::diff]\n",
    "    \n",
    "    return mat,n,x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def matrix2(l,a,k1,k2):    \n",
    "    \n",
    "    for i in range(len(l)):\n",
    "        if(l[i]==k1):\n",
    "            n1=i\n",
    "        if(l[i]==k2):\n",
    "            n2=i\n",
    "    if((n1%2==1 and n2%2==0) or n2%2==1 and n1%2==0 ):\n",
    "        if(n1%2==1):\n",
    "            if((n1-1)%4==0):\n",
    "                index=3\n",
    "                diff=4\n",
    "            else:\n",
    "                index=1\n",
    "                diff=4\n",
    "        if(n2%2==1):\n",
    "            if((n2-1)%4==0):\n",
    "                index=3\n",
    "                diff=4\n",
    "            else:\n",
    "                index=1\n",
    "                diff=4\n",
    "    if(n1%2==0 and n2%2==0):\n",
    "        index=1\n",
    "        diff=2\n",
    "    if(n1%2==1 and n2%2==1):\n",
    "        index=0\n",
    "        diff= 2\n",
    "    x=[]\n",
    "    ind=index\n",
    "    while 1:\n",
    "\n",
    "        if(index>len(l)-1):\n",
    "            break\n",
    "        x.append(l[index])\n",
    "        index=index+diff\n",
    "    n=len(x)\n",
    "    mat=np.zeros((a.shape[0],n))\n",
    "    for i in range(int(a.shape[0])):\n",
    "        mat[i]=a[i][ind::diff]\n",
    "    return mat,n,x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def matrix3(l,a,k1,k2,k3):\n",
    "   \n",
    "   \n",
    "    for i in range(len(l)):\n",
    "        if(l[i]==k1):\n",
    "            n1=i\n",
    "        if(l[i]==k2):\n",
    "            n2=i\n",
    "    if((n1%2==1 and n2%2==0) or n2%2==1 and n1%2==0 ):\n",
    "        if(n1%2==1):\n",
    "            if((n1-1)%4==0):\n",
    "                index=3\n",
    "                diff=4\n",
    "            else:\n",
    "                index=1\n",
    "                diff=4\n",
    "        if(n2%2==1):\n",
    "            if((n2-1)%4==0):\n",
    "                index=3\n",
    "                diff=4\n",
    "            else:\n",
    "                index=1\n",
    "                diff=4\n",
    "    if(n1%2==0 and n2%2==0):\n",
    "        index=1\n",
    "        diff=2\n",
    "    if(n1%2==1 and n2%2==1):\n",
    "        index=0\n",
    "        diff= 2\n",
    "    x=[]\n",
    "    ind=index\n",
    "    while 1:\n",
    "\n",
    "        if(index>len(l)-1):\n",
    "            break\n",
    "        x.append(l[index])\n",
    "        index=index+diff\n",
    "    j=0\n",
    "    for i  in range(len(x)):\n",
    "        if(x[i]==k3):\n",
    "            j=1\n",
    "            if(i%2==0):\n",
    "                index=1\n",
    "                diff=2\n",
    "            else:\n",
    "                index=0\n",
    "                diff=2\n",
    "    x1=[] \n",
    "\n",
    "    if j==1:             \n",
    "\n",
    "        l1=x\n",
    "\n",
    "        while 1:\n",
    "\n",
    "            if(index>len(l1)-1):\n",
    "                break\n",
    "            x1.append(l1[index])\n",
    "            index=index+diff  \n",
    "        for i in range(len(l)):\n",
    "            if(l[i]==x1[0]):\n",
    "                index=i\n",
    "            if(l[i]==x1[1]):\n",
    "                diff=i-index\n",
    "        ind=index\n",
    "\n",
    "    else:\n",
    "        x1=x\n",
    "\n",
    "    x=x1\n",
    "    n=len(x)\n",
    "    \n",
    "\n",
    "    mat=np.zeros((a.shape[0],n))\n",
    "    for i in range(int(a.shape[0])):\n",
    "        mat[i]=a[i][ind::diff]\n",
    "    return mat,n,x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#newton backward\n",
    "def newtonbackward(mat,n,x,miss):\n",
    "    l=[]\n",
    "    for k in range(0,a.shape[0]):\n",
    "        y_mat=np.zeros((n,n),dtype=float)\n",
    "        for i in range(0,n):\n",
    "             y_mat[i][0]=mat[k][i]\n",
    "\n",
    "        for i in range(1, n): \n",
    "            for j in range(n - i,i+1): \n",
    "                y_mat[j][i] = y_mat[j][i - 1] - y_mat[j-1][i - 1]; \n",
    "\n",
    "        sum = y_mat[n-1][0]; \n",
    "        u = (miss- x[n-1]) / (x[1] - x[0]); \n",
    "        for i in range(1,n): \n",
    "            sum = sum + (u_cal(u, i) * y_mat[n-1][i]) / fact(i); \n",
    "        l.append(round(sum,6))\n",
    "    return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#newton frward\n",
    "def newtonforward(mat,n,x,miss):\n",
    "    l=[]\n",
    "    for k in range(0,a.shape[0]):\n",
    "        y_mat=np.zeros((n,n),dtype=float)\n",
    "        for i in range(0,n):\n",
    "             y_mat[i][0]=mat[k][i]\n",
    "\n",
    "        for i in range(1, n): \n",
    "            for j in range(n - i): \n",
    "                y_mat[j][i] = y_mat[j + 1][i - 1] - y_mat[j][i - 1]; \n",
    "\n",
    "        sum = y_mat[0][0]; \n",
    "        u = (miss- x[0]) / (x[1] - x[0]); \n",
    "        for i in range(1,n): \n",
    "            sum = sum + (u_cal(u, i) * y_mat[0][i]) / fact(i); \n",
    "        l.append(round(sum,6))\n",
    "    return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#lagrange\n",
    "def lagrange(mat,n,x,xp):\n",
    "    l=[]\n",
    "    for k in range (a.shape[0]):\n",
    "        yp=0\n",
    "        for i in range(n):\n",
    "\n",
    "            p = 1\n",
    "\n",
    "            for j in range(n):\n",
    "                if i != j:\n",
    "                    p = p * (xp - x[j])/(x[i] - x[j])\n",
    "\n",
    "            yp = yp+p*mat[k][i]  \n",
    "\n",
    "        l.append(yp) \n",
    "    return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nrmse1(miss,l):    \n",
    "    rmsl=[]\n",
    "    for i in range(0,a.shape[0]):\n",
    "        rmsl.append((df[\"alpha\"+str(miss)][i]-l[i])**2)\n",
    "    sumrmse=np.sum(rmsl)\n",
    "    sqrrmse=sumrmse**(1/2)\n",
    "    rmse=sqrrmse/(a.shape[0]**(1/2))\n",
    "    m=np.max(df[\"alpha\"+str(miss)])-np.min(df[\"alpha\"+str(miss)])\n",
    "    print (m)\n",
    "    nrmse=rmse/m\n",
    "    return nrmse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nrmse2(miss,l,l1):    \n",
    "    rmsl=[]\n",
    "    for i in range(0,a.shape[0]):\n",
    "        rmsl.append((a[i,l1.index(miss)]-l[i])**2)\n",
    "    sumrmse=np.sum(rmsl)\n",
    "    sqrrmse=sumrmse**(1/2)\n",
    "    rmse=sqrrmse/(a.shape[0]**(1/2))\n",
    "    m=np.max(a[0:,l1.index(miss)])-np.min(a[0:,l1.index(miss)])\n",
    "   \n",
    "    nrmse=rmse/m\n",
    "    return nrmse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0:][1].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.max(a[0:,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=a[:][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[:][1]=l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=a[:,0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[:,1]=l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#row average\n",
    "lst=[]\n",
    "for i in range(0,4489):\n",
    "    avg=(np.sum(a[i])-a[i][11])/17\n",
    "    lst.append(avg)\n",
    "\n",
    "print(nrmse2(77,lst,l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.index(77)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#zero usb\n",
    "lst=[0]*4489\n",
    "lst2=percnt99(lst,63)\n",
    "print(nrmse2(63,lst,l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#99 percent changer\n",
    "def percnt99(l1,miss):\n",
    "    k=round(.01*a.shape[0])\n",
    "    indexlist=[]\n",
    "    l5=l1.copy()\n",
    "    #print(l5)\n",
    "    for i in range(0,k):\n",
    "        r=random.randint(0,a.shape[0]-1)\n",
    "        indexlist.append(r)\n",
    "   # print((indexlist))\n",
    "    for each in indexlist:\n",
    "        l5[each]=a[each][l.index(miss)]\n",
    "    return l5\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predictscattered():\n",
    "    c=0\n",
    "    ind=[]\n",
    "    predlist=[]\n",
    "    pred=[]\n",
    "    while(c<round(0.05*(4489*18))):\n",
    "        i=random.randint(0,4488)\n",
    "        j=random.randint(0,17)\n",
    "        if((i,j) in ind):\n",
    "            continue;\n",
    "        ind.append((i,j))\n",
    "        c+=1\n",
    "   \n",
    "    indvalues=[]\n",
    "    for each in ind:\n",
    "        indvalues.append(a[each[0]][each[1]])\n",
    "        mat,n,x=matrix1(l,a,l[each[1]])\n",
    "        if(each[1]<3):\n",
    "            pred=newtonforward(mat,n,x,l[each[1]])\n",
    "            predlist.append(pred[each[0]])\n",
    "\n",
    "        elif(each[1]<10):\n",
    "            pred=lagrange(mat,n,x,l[each[1]])\n",
    "            predlist.append(pred[each[0]])\n",
    "            \n",
    "        else:\n",
    "            pred=newtonbackward(mat,n,x,l[each[1]])\n",
    "           \n",
    "            predlist.append(pred[each[0]])\n",
    "           \n",
    "    return predlist,indvalues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nrmse2scat(lreal,lpred):    \n",
    "    rmsl=[]\n",
    "    for i in range(0,4040):\n",
    "        rmsl.append((lreal[i]-lpred[i])**2)\n",
    "    sumrmse=np.sum(rmsl)\n",
    "    sqrrmse=sumrmse**(1/2)\n",
    "    rmse=sqrrmse/(4040**(1/2))\n",
    "    m=np.max(lreal)-np.min(lpred)\n",
    "   \n",
    "    nrmse=rmse/m\n",
    "    return nrmse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "predlist,reallist=predictscattered()\n",
    "nrmse=nrmse2scat(reallist,predlist)\n",
    "print(nrmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " c=0\n",
    "ind=[]\n",
    "predlist=[]\n",
    "pred=[]\n",
    "while(c<round(0.05*(4489*18))):\n",
    "    i=random.randint(0,4488)\n",
    "    j=random.randint(0,17)\n",
    "    if((i,j) in ind):\n",
    "        continue;\n",
    "    ind.append((i,j))\n",
    "    c+=1\n",
    "f=0\n",
    "indvalues=[]\n",
    "for each in ind:\n",
    "    print(f)\n",
    "    f+=1\n",
    "    indvalues.append(a[each[0]][each[1]])\n",
    "#o sub\n",
    "reallist=indvalues\n",
    "predlist=[0]*4040\n",
    "nrmse=nrmse2scat(reallist,predlist)\n",
    "print(nrmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### extrapolate using Linear regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "lr=LinearRegression()\n",
    "l=np.array([0,7,14,21,28,35,42,49,56,63,70,77,84,91,98,105])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "regpred=[]\n",
    "for i in range(0,4489):\n",
    "    lr.fit(l.reshape(-1,1),df1.iloc[i,:-2])\n",
    "    regpred.append(lr.predict([[119]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nrmse2scat(df1.alpha119,regpred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from statsmodels.tsa.ar_model import AutoReg\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from math import sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[]\n",
    "for i in range(len(df1)):\n",
    "    train=df1.iloc[i].values[0:17]\n",
    "    test=df1.iloc[i].values[17:]\n",
    "    model = AutoReg(train, lags=0)\n",
    "    model_fit = model.fit()\n",
    "    predictions = model_fit.predict(start=119, end=119, dynamic=False)\n",
    "    rmse = sqrt(mean_squared_error(test, predictions))\n",
    "    nrmse=rmse/(max(train)-min(train))\n",
    "    l.append(rmse)\n",
    "   # print(nrmse)\n",
    "print(np.mean(l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test=df1.iloc[0].values[17:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}