diff --git a/arbitragelab/arblab_tearsheet/tearsheet_test.ipynb b/arbitragelab/arblab_tearsheet/tearsheet_test.ipynb
new file mode 100644
index 00000000..64c23188
--- /dev/null
+++ b/arbitragelab/arblab_tearsheet/tearsheet_test.ipynb
@@ -0,0 +1,6023 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import arbitragelab as al\n",
+    "import dash\n",
+    "import yfinance as yf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import dash_core_components as dcc\n",
+    "import dash_html_components as html\n",
+    "import plotly.express as px\n",
+    "import pandas as pd\n",
+    "from flask import request"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[*********************100%***********************]  2 of 2 completed\n",
+      "[*********************100%***********************]  2 of 2 completed\n"
+     ]
+    },
+    {
+     "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Date</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2015-12-31</th>\n",
+       "      <td>101.459999</td>\n",
+       "      <td>17.784159</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-04</th>\n",
+       "      <td>102.889999</td>\n",
+       "      <td>18.330364</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-05</th>\n",
+       "      <td>103.180000</td>\n",
+       "      <td>18.367397</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-06</th>\n",
+       "      <td>104.669998</td>\n",
+       "      <td>18.682161</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-07</th>\n",
+       "      <td>106.150002</td>\n",
+       "      <td>19.117277</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   GLD       GDXJ\n",
+       "Date                             \n",
+       "2015-12-31  101.459999  17.784159\n",
+       "2016-01-04  102.889999  18.330364\n",
+       "2016-01-05  103.180000  18.367397\n",
+       "2016-01-06  104.669998  18.682161\n",
+       "2016-01-07  106.150002  19.117277"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Loading data\n",
+    "train_data =  yf.download(\"GLD GDXJ\", start=\"2016-01-01\", end=\"2018-01-01\")\n",
+    "test_data =  yf.download(\"GLD GDXJ\", start=\"2018-01-02\", end=\"2020-01-01\")\n",
+    "\n",
+    "# Taking close prices for chosen instruments\n",
+    "train_three_elements = train_data[\"Adj Close\"][[\"GLD\", \"GDXJ\"]]\n",
+    "\n",
+    "test_three_elements = test_data[\"Adj Close\"][[\"GLD\", \"GDXJ\"]]\n",
+    "\n",
+    "# Looking at the downloaded data\n",
+    "train_three_elements.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### ADF"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from statsmodels.tsa.stattools import adfuller\n",
+    "def adf_test(timeseries):\n",
+    "    print ('Results of Dickey-Fuller Test:')\n",
+    "    dftest = adfuller(timeseries, autolag='AIC')\n",
+    "    dfoutput = pd.Series(dftest[0:4], index=['Test Statistic','p-value','#Lags Used','Number of Observations Used'])\n",
+    "    for key,value in dftest[4].items():\n",
+    "       dfoutput['Critical Value (%s)'%key] = value\n",
+    "    print (dfoutput)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Results of Dickey-Fuller Test:\n",
+      "Test Statistic                  -3.014962\n",
+      "p-value                          0.033521\n",
+      "#Lags Used                       4.000000\n",
+      "Number of Observations Used    499.000000\n",
+      "Critical Value (1%)             -3.443523\n",
+      "Critical Value (5%)             -2.867350\n",
+      "Critical Value (10%)            -2.569864\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "adf_test(train_three_elements['GLD'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-2.6073716854664704,\n",
+       " 0.09148324139788433,\n",
+       " 4,\n",
+       " 499,\n",
+       " {'1%': -3.4435228622952065,\n",
+       "  '5%': -2.867349510566146,\n",
+       "  '10%': -2.569864247011056},\n",
+       " 1410.0891848889364)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adfuller(train_three_elements['GDXJ'], autolag='AIC')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Results of Dickey-Fuller Test:\n",
+      "Test Statistic                  -2.607372\n",
+      "p-value                          0.091483\n",
+      "#Lags Used                       4.000000\n",
+      "Number of Observations Used    499.000000\n",
+      "Critical Value (1%)             -3.443523\n",
+      "Critical Value (5%)             -2.867350\n",
+      "Critical Value (10%)            -2.569864\n",
+      "dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "adf_test(train_three_elements['GDXJ'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Johansen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialising an object containing needed methods\n",
+    "j_portfolio = al.cointegration_approach.JohansenPortfolio()\n",
+    "\n",
+    "# Fitting the data on a dataset of three elements with constant term\n",
+    "j_portfolio.fit(train_three_elements, det_order=0)\n",
+    "\n",
+    "# Getting results of the eigenvalue and trace Johansen tests\n",
+    "j_eigenvalue_statistics = j_portfolio.johansen_eigen_statistic\n",
+    "j_trace_statistics = j_portfolio.johansen_trace_statistic\n",
+    "j_cointegration_vectors = j_portfolio.cointegration_vectors\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>90%</th>\n",
+       "      <td>12.2971</td>\n",
+       "      <td>2.705500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95%</th>\n",
+       "      <td>14.2639</td>\n",
+       "      <td>3.841500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>99%</th>\n",
+       "      <td>18.5200</td>\n",
+       "      <td>6.634900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>eigen_value</th>\n",
+       "      <td>10.2804</td>\n",
+       "      <td>2.873192</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 GLD      GDXJ\n",
+       "90%          12.2971  2.705500\n",
+       "95%          14.2639  3.841500\n",
+       "99%          18.5200  6.634900\n",
+       "eigen_value  10.2804  2.873192"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# First, the eigenvalue statistic test\n",
+    "j_eigenvalue_statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>90%</th>\n",
+       "      <td>13.429400</td>\n",
+       "      <td>2.705500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95%</th>\n",
+       "      <td>15.494300</td>\n",
+       "      <td>3.841500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>99%</th>\n",
+       "      <td>19.934900</td>\n",
+       "      <td>6.634900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>trace_statistic</th>\n",
+       "      <td>13.153592</td>\n",
+       "      <td>2.873192</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                       GLD      GDXJ\n",
+       "90%              13.429400  2.705500\n",
+       "95%              15.494300  3.841500\n",
+       "99%              19.934900  6.634900\n",
+       "trace_statistic  13.153592  2.873192"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Next, the alternative trace statistic test\n",
+    "j_trace_statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.184139</td>\n",
+       "      <td>0.003739</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-0.206006</td>\n",
+       "      <td>0.235060</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        GLD      GDXJ\n",
+       "0  0.184139  0.003739\n",
+       "1 -0.206006  0.235060"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Coefficients to construct a mean-reverting portfolio \n",
+    "j_cointegration_vectors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Portfolio calculation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GLD     0.184139\n",
+       "GDXJ    0.003739\n",
+       "Name: 0, dtype: float64"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Weights of elements for the Johansen portfolio\n",
+    "j_cointegration_vectors.loc[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GLD     0.9801\n",
+       "GDXJ    0.0199\n",
+       "Name: 0, dtype: float64"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Scaling cointegration vectors so they sum up to 1\n",
+    "j_scaled_vectors = j_cointegration_vectors.loc[0] / abs(j_cointegration_vectors.loc[0]).sum()\n",
+    "\n",
+    "j_scaled_vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Also adding weights to take initial prices of our ETFs into account\n",
+    "weights  = train_three_elements.iloc[0] / abs(train_three_elements.iloc[0]).sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'train_three_elements_returns' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-18-16390e94422d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Calculating portfolio values during the training period\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mj_portfolio_returns\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mtrain_three_elements_returns\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mj_scaled_vectors\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mweights\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msum\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mj_portfolio_price\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mj_portfolio_returns\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcumprod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'train_three_elements_returns' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "# Calculating portfolio values during the training period\n",
+    "j_portfolio_returns = (train_three_elements_returns * j_scaled_vectors * weights).sum(axis=1)\n",
+    "j_portfolio_price = (j_portfolio_returns + 1).cumprod()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plotting Johansen portfolio price\n",
+    "j_portfolio_price.plot(title='Johansen portfolio price', figsize=(10,5));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Another way to construct portfolios is by using the construct_mean_reverting_portfolio function from the JohansenPortfolio or the EngleGrangerPortfolio class. This portfolio is created by summing up price series with given coefficients."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Alternative way to construct portfolios\n",
+    "alternative_j_portfolio_price = j_portfolio.construct_mean_reverting_portfolio(train_three_elements, j_cointegration_vectors.loc[0])\n",
+    "\n",
+    "# Plotting the portfolio price\n",
+    "alternative_j_portfolio_price.plot(title='Alternative Johansen portfolio price', figsize=(10,5));"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "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": [
+    "import numpy as np\n",
+    "import statsmodels.api as sm\n",
+    "import pylab as py\n",
+    "  \n",
+    "# np.random generates different random numbers\n",
+    "# whenever the code is executed\n",
+    "# Note: When you execute the same code \n",
+    "# the graph look different than shown below.\n",
+    "  \n",
+    "# Random data points generated\n",
+    "data_points = np.random.normal(0, 1, 100)    \n",
+    "  \n",
+    "sm.qqplot(data_points, line ='45')\n",
+    "py.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\u001b[1;31mSignature:\u001b[0m\n",
+       " \u001b[0mstats\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mprobplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m\n",
+       "\u001b[0m    \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
+       "\u001b[0m    \u001b[0msparams\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
+       "\u001b[0m    \u001b[0mdist\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'norm'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
+       "\u001b[0m    \u001b[0mfit\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
+       "\u001b[0m    \u001b[0mplot\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
+       "\u001b[0m    \u001b[0mrvalue\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
+       "\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+       "\u001b[1;31mDocstring:\u001b[0m\n",
+       "Calculate quantiles for a probability plot, and optionally show the plot.\n",
+       "\n",
+       "Generates a probability plot of sample data against the quantiles of a\n",
+       "specified theoretical distribution (the normal distribution by default).\n",
+       "`probplot` optionally calculates a best-fit line for the data and plots the\n",
+       "results using Matplotlib or a given plot function.\n",
+       "\n",
+       "Parameters\n",
+       "----------\n",
+       "x : array_like\n",
+       "    Sample/response data from which `probplot` creates the plot.\n",
+       "sparams : tuple, optional\n",
+       "    Distribution-specific shape parameters (shape parameters plus location\n",
+       "    and scale).\n",
+       "dist : str or stats.distributions instance, optional\n",
+       "    Distribution or distribution function name. The default is 'norm' for a\n",
+       "    normal probability plot.  Objects that look enough like a\n",
+       "    stats.distributions instance (i.e. they have a ``ppf`` method) are also\n",
+       "    accepted.\n",
+       "fit : bool, optional\n",
+       "    Fit a least-squares regression (best-fit) line to the sample data if\n",
+       "    True (default).\n",
+       "plot : object, optional\n",
+       "    If given, plots the quantiles and least squares fit.\n",
+       "    `plot` is an object that has to have methods \"plot\" and \"text\".\n",
+       "    The `matplotlib.pyplot` module or a Matplotlib Axes object can be used,\n",
+       "    or a custom object with the same methods.\n",
+       "    Default is None, which means that no plot is created.\n",
+       "\n",
+       "Returns\n",
+       "-------\n",
+       "(osm, osr) : tuple of ndarrays\n",
+       "    Tuple of theoretical quantiles (osm, or order statistic medians) and\n",
+       "    ordered responses (osr).  `osr` is simply sorted input `x`.\n",
+       "    For details on how `osm` is calculated see the Notes section.\n",
+       "(slope, intercept, r) : tuple of floats, optional\n",
+       "    Tuple  containing the result of the least-squares fit, if that is\n",
+       "    performed by `probplot`. `r` is the square root of the coefficient of\n",
+       "    determination.  If ``fit=False`` and ``plot=None``, this tuple is not\n",
+       "    returned.\n",
+       "\n",
+       "Notes\n",
+       "-----\n",
+       "Even if `plot` is given, the figure is not shown or saved by `probplot`;\n",
+       "``plt.show()`` or ``plt.savefig('figname.png')`` should be used after\n",
+       "calling `probplot`.\n",
+       "\n",
+       "`probplot` generates a probability plot, which should not be confused with\n",
+       "a Q-Q or a P-P plot.  Statsmodels has more extensive functionality of this\n",
+       "type, see ``statsmodels.api.ProbPlot``.\n",
+       "\n",
+       "The formula used for the theoretical quantiles (horizontal axis of the\n",
+       "probability plot) is Filliben's estimate::\n",
+       "\n",
+       "    quantiles = dist.ppf(val), for\n",
+       "\n",
+       "            0.5**(1/n),                  for i = n\n",
+       "      val = (i - 0.3175) / (n + 0.365),  for i = 2, ..., n-1\n",
+       "            1 - 0.5**(1/n),              for i = 1\n",
+       "\n",
+       "where ``i`` indicates the i-th ordered value and ``n`` is the total number\n",
+       "of values.\n",
+       "\n",
+       "Examples\n",
+       "--------\n",
+       ">>> from scipy import stats\n",
+       ">>> import matplotlib.pyplot as plt\n",
+       ">>> nsample = 100\n",
+       ">>> np.random.seed(7654321)\n",
+       "\n",
+       "A t distribution with small degrees of freedom:\n",
+       "\n",
+       ">>> ax1 = plt.subplot(221)\n",
+       ">>> x = stats.t.rvs(3, size=nsample)\n",
+       ">>> res = stats.probplot(x, plot=plt)\n",
+       "\n",
+       "A t distribution with larger degrees of freedom:\n",
+       "\n",
+       ">>> ax2 = plt.subplot(222)\n",
+       ">>> x = stats.t.rvs(25, size=nsample)\n",
+       ">>> res = stats.probplot(x, plot=plt)\n",
+       "\n",
+       "A mixture of two normal distributions with broadcasting:\n",
+       "\n",
+       ">>> ax3 = plt.subplot(223)\n",
+       ">>> x = stats.norm.rvs(loc=[0,5], scale=[1,1.5],\n",
+       "...                    size=(nsample//2,2)).ravel()\n",
+       ">>> res = stats.probplot(x, plot=plt)\n",
+       "\n",
+       "A standard normal distribution:\n",
+       "\n",
+       ">>> ax4 = plt.subplot(224)\n",
+       ">>> x = stats.norm.rvs(loc=0, scale=1, size=nsample)\n",
+       ">>> res = stats.probplot(x, plot=plt)\n",
+       "\n",
+       "Produce a new figure with a loggamma distribution, using the ``dist`` and\n",
+       "``sparams`` keywords:\n",
+       "\n",
+       ">>> fig = plt.figure()\n",
+       ">>> ax = fig.add_subplot(111)\n",
+       ">>> x = stats.loggamma.rvs(c=2.5, size=500)\n",
+       ">>> res = stats.probplot(x, dist=stats.loggamma, sparams=(2.5,), plot=ax)\n",
+       ">>> ax.set_title(\"Probplot for loggamma dist with shape parameter 2.5\")\n",
+       "\n",
+       "Show the results with Matplotlib:\n",
+       "\n",
+       ">>> plt.show()\n",
+       "\u001b[1;31mFile:\u001b[0m      d:\\programs\\anaconda\\envs\\arbitragelab\\lib\\site-packages\\scipy\\stats\\morestats.py\n",
+       "\u001b[1;31mType:\u001b[0m      function\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "? stats.probplot"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# DATA ARBITRAGELAB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 372,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import arbitragelab as al\n",
+    "import yfinance as yf\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from scipy import stats\n",
+    "from scipy.stats import kurtosis, skew, shapiro\n",
+    "from arbitragelab.cointegration_approach import get_half_life_of_mean_reversion\n",
+    "from statsmodels.tsa.stattools import pacf, adfuller, acf"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Data raw"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[*********************100%***********************]  2 of 2 completed\n",
+      "[*********************100%***********************]  2 of 2 completed\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Loading data\n",
+    "train_data =  yf.download(\"GLD GDXJ\", start=\"2016-01-01\", end=\"2018-01-01\")\n",
+    "test_data =  yf.download(\"GLD GDXJ\", start=\"2018-01-02\", end=\"2020-01-01\")\n",
+    "\n",
+    "# Taking close prices for chosen instruments\n",
+    "train_three_elements = train_data[\"Adj Close\"][[\"GLD\", \"GDXJ\"]]\n",
+    "\n",
+    "test_three_elements = test_data[\"Adj Close\"][[\"GLD\", \"GDXJ\"]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def adf_test(timeseries):\n",
+    "    print ('Results of Dickey-Fuller Test:')\n",
+    "    dftest = adfuller(timeseries, autolag='AIC')\n",
+    "    dfoutput = pd.Series(dftest[0:4], index=['Test Statistic','p-value','#Lags Used','Number of Observations Used'])\n",
+    "    for key,value in dftest[4].items():\n",
+    "       dfoutput['Critical Value (%s)'%key] = value\n",
+    "    print (dfoutput)\n",
+    "    return (dftest)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "ADF test\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " test statistic is less (more negative) than the critical value"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "first_adf = adfuller(train_three_elements['GLD'], autolag='AIC')\n",
+    "\n",
+    "second_adf = adfuller(train_three_elements['GDXJ'], autolag='AIC')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 320,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[-3.4435228622952065, -2.867349510566146, -2.569864247011056]"
+      ]
+     },
+     "execution_count": 320,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list(adfuller(train_three_elements['GLD'])[4].values())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 324,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ass_n=train_three_elements.columns[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 331,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['GLD'], dtype='object')"
+      ]
+     },
+     "execution_count": 331,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = pd.DataFrame(data=train_three_elements[ass_n])\n",
+    "a.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 332,
+   "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>Confidence level</th>\n",
+       "      <th>Value</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>99%</td>\n",
+       "      <td>-3.44352</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>95%</td>\n",
+       "      <td>-2.86735</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>90%</td>\n",
+       "      <td>-2.56986</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Confidence level    Value\n",
+       "0              99% -3.44352\n",
+       "1              95% -2.86735\n",
+       "2              90% -2.56986"
+      ]
+     },
+     "execution_count": 332,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[-3.4435228622952065, -2.867349510566146, -2.569864247011056]"
+      ]
+     },
+     "execution_count": 27,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list(first_adf[4].values())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Results of Dickey-Fuller Test:\n",
+      "Test Statistic                  -2.607372\n",
+      "p-value                          0.091483\n",
+      "#Lags Used                       4.000000\n",
+      "Number of Observations Used    499.000000\n",
+      "Critical Value (1%)             -3.443523\n",
+      "Critical Value (5%)             -2.867350\n",
+      "Critical Value (10%)            -2.569864\n",
+      "dtype: float64\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(-2.6073716854664704,\n",
+       " 0.09148324139788433,\n",
+       " 4,\n",
+       " 499,\n",
+       " {'1%': -3.4435228622952065,\n",
+       "  '5%': -2.867349510566146,\n",
+       "  '10%': -2.569864247011056},\n",
+       " 1410.0891848889364)"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "adf_test(train_three_elements['GDXJ'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 352,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Date</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2015-12-31</th>\n",
+       "      <td>101.459999</td>\n",
+       "      <td>17.784159</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-04</th>\n",
+       "      <td>102.889999</td>\n",
+       "      <td>18.330364</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-05</th>\n",
+       "      <td>103.180000</td>\n",
+       "      <td>18.367397</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-06</th>\n",
+       "      <td>104.669998</td>\n",
+       "      <td>18.682161</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-07</th>\n",
+       "      <td>106.150002</td>\n",
+       "      <td>19.117277</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-12-22</th>\n",
+       "      <td>120.940002</td>\n",
+       "      <td>32.702591</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-12-26</th>\n",
+       "      <td>121.769997</td>\n",
+       "      <td>33.453594</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-12-27</th>\n",
+       "      <td>122.230003</td>\n",
+       "      <td>33.414581</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-12-28</th>\n",
+       "      <td>122.849998</td>\n",
+       "      <td>33.404827</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2017-12-29</th>\n",
+       "      <td>123.650002</td>\n",
+       "      <td>33.287788</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>504 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   GLD       GDXJ\n",
+       "Date                             \n",
+       "2015-12-31  101.459999  17.784159\n",
+       "2016-01-04  102.889999  18.330364\n",
+       "2016-01-05  103.180000  18.367397\n",
+       "2016-01-06  104.669998  18.682161\n",
+       "2016-01-07  106.150002  19.117277\n",
+       "...                ...        ...\n",
+       "2017-12-22  120.940002  32.702591\n",
+       "2017-12-26  121.769997  33.453594\n",
+       "2017-12-27  122.230003  33.414581\n",
+       "2017-12-28  122.849998  33.404827\n",
+       "2017-12-29  123.650002  33.287788\n",
+       "\n",
+       "[504 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 352,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_three_elements"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Data on Coint-related data**"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Engle-Granger"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 354,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialising an object containing needed methods\n",
+    "eg_portfolio = al.cointegration_approach.EngleGrangerPortfolio()\n",
+    "\n",
+    "# Fitting the data on a dataset of three elements with constant term\n",
+    "eg_portfolio.fit(train_three_elements, add_constant=False)\n",
+    "\n",
+    "# Getting results of the Engle-Granger test\n",
+    "eg_adf_statistics = eg_portfolio.adf_statistics\n",
+    "eg_cointegration_vectors = eg_portfolio.cointegration_vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 355,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>-3.481752</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   GLD      GDXJ\n",
+       "0  1.0 -3.481752"
+      ]
+     },
+     "execution_count": 355,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eg_cointegration_vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 300,
+   "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>0</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>99%</th>\n",
+       "      <td>-3.443523</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95%</th>\n",
+       "      <td>-2.867350</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>90%</th>\n",
+       "      <td>-2.569864</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>statistic_value</th>\n",
+       "      <td>-2.442489</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                        0\n",
+       "99%             -3.443523\n",
+       "95%             -2.867350\n",
+       "90%             -2.569864\n",
+       "statistic_value -2.442489"
+      ]
+     },
+     "execution_count": 300,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eg_adf_statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 339,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "adf = {'Confidence level':['99%', '95%', '90%']}\n",
+    "\n",
+    "# adf['Value'] = eg_adf_statistics[:-1].reset_index()[0].astype(float).round(5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 361,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[-3.4435, -2.86734, -2.56986]"
+      ]
+     },
+     "execution_count": 361,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "list(eg_adf_statistics[:-1][0].round(5))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 362,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-2.2888656100651565"
+      ]
+     },
+     "execution_count": 362,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eg_adf_statistics[' '] = eg_adf_statistics.index\n",
+    "\n",
+    "eg_adf = eg_adf_statistics[:-1]\n",
+    "\n",
+    "test_stat = eg_adf_statistics.loc['statistic_value'][0]\n",
+    "test_stat \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-1.7004577107383319"
+      ]
+     },
+     "execution_count": 89,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eg_adf_statistics_2[' '] = eg_adf_statistics_2.index\n",
+    "\n",
+    "eg_adf_2 = eg_adf_statistics_2[:-1]\n",
+    "\n",
+    "eg_adf_2\n",
+    "test_stat_2 = eg_adf_statistics_2.loc['statistic_value'][0]\n",
+    "test_stat_2 "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[-3.44352, -2.86735, -2.56986, -2.442488670394889]"
+      ]
+     },
+     "execution_count": 90,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Looking at the statistic from the last step of the Engle-Granger test\n",
+    "list(eg_adf_statistics[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 91,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>-0.630068</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   GLD      GDXJ\n",
+       "0  1.0 -0.630068"
+      ]
+     },
+     "execution_count": 91,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eg_cointegration_vectors\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 92,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Date\n",
+       "2015-12-31   -8.234267\n",
+       "2016-01-04   -7.148413\n",
+       "2016-01-05   -6.881746\n",
+       "2016-01-06   -5.590071\n",
+       "2016-01-07   -4.384220\n",
+       "                ...   \n",
+       "2017-12-22    1.846107\n",
+       "2017-12-26    2.202918\n",
+       "2017-12-27    2.687506\n",
+       "2017-12-28    3.313647\n",
+       "2017-12-29    4.187392\n",
+       "Name: GLD, Length: 504, dtype: float64"
+      ]
+     },
+     "execution_count": 92,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Residuals\n",
+    "\n",
+    "res = eg_portfolio.residuals\n",
+    "res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 258,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Q-Q plot data\n",
+    "\n",
+    "qq = stats.probplot(eg_portfolio.residuals, dist='norm', sparams=(1))\n",
+    "x = np.array([qq[0][0][0], qq[0][0][-1]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialising an object containing needed methods\n",
+    "eg_portfolio_2 = al.cointegration_approach.EngleGrangerPortfolio()\n",
+    "\n",
+    "# Fitting the data on a dataset of three elements with constant term\n",
+    "eg_portfolio_2.fit(train_three_elements[['GDXJ','GLD']], add_constant=True)\n",
+    "\n",
+    "# Getting results of the Engle-Granger test\n",
+    "eg_adf_statistics_2 = eg_portfolio_2.adf_statistics\n",
+    "eg_cointegration_vectors_2 = eg_portfolio_2.cointegration_vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 272,
+   "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>0</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>99%</th>\n",
+       "      <td>-3.443520</td>\n",
+       "      <td>99%</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95%</th>\n",
+       "      <td>-2.867350</td>\n",
+       "      <td>95%</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>90%</th>\n",
+       "      <td>-2.569860</td>\n",
+       "      <td>90%</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>statistic_value</th>\n",
+       "      <td>-2.442489</td>\n",
+       "      <td>statistic_value</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                        0                 \n",
+       "99%             -3.443520              99%\n",
+       "95%             -2.867350              95%\n",
+       "90%             -2.569860              90%\n",
+       "statistic_value -2.442489  statistic_value"
+      ]
+     },
+     "execution_count": 272,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eg_adf_statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[-3.4434175660489905,\n",
+       " -2.8673031724657454,\n",
+       " -2.5698395516760275,\n",
+       " -1.7004577107383319]"
+      ]
+     },
+     "execution_count": 96,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Looking at the statistic from the last step of the Engle-Granger test\n",
+    "list(eg_adf_statistics_2[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 97,
+   "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>GDXJ</th>\n",
+       "      <th>GLD</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>-0.862224</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   GDXJ       GLD\n",
+       "0   1.0 -0.862224"
+      ]
+     },
+     "execution_count": 97,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eg_cointegration_vectors_2\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 257,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Date\n",
+       "2015-12-31   -8.234267\n",
+       "2016-01-04   -7.148413\n",
+       "2016-01-05   -6.881746\n",
+       "2016-01-06   -5.590071\n",
+       "2016-01-07   -4.384220\n",
+       "                ...   \n",
+       "2017-12-22    1.846107\n",
+       "2017-12-26    2.202918\n",
+       "2017-12-27    2.687506\n",
+       "2017-12-28    3.313647\n",
+       "2017-12-29    4.187392\n",
+       "Name: GLD, Length: 504, dtype: float64"
+      ]
+     },
+     "execution_count": 257,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Residuals\n",
+    "\n",
+    "res = eg_portfolio.residuals\n",
+    "res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Q-Q plot data\n",
+    "\n",
+    "qq_2 = stats.probplot(eg_portfolio_2.residuals, dist='norm', sparams=(1))\n",
+    "x_2 = np.array([qq[0][0][0], qq[0][0][-1]])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Johansen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 100,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Initialising an object containing needed methods\n",
+    "j_portfolio = al.cointegration_approach.JohansenPortfolio()\n",
+    "\n",
+    "# Fitting the data on a dataset of three elements with constant term\n",
+    "j_portfolio.fit(train_three_elements, det_order=0)\n",
+    "\n",
+    "# Getting results of the eigenvalue and trace Johansen tests\n",
+    "j_eigenvalue_statistics = j_portfolio.johansen_eigen_statistic\n",
+    "j_trace_statistics = j_portfolio.johansen_trace_statistic\n",
+    "j_cointegration_vectors = j_portfolio.cointegration_vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 101,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>90%</th>\n",
+       "      <td>12.2971</td>\n",
+       "      <td>2.705500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95%</th>\n",
+       "      <td>14.2639</td>\n",
+       "      <td>3.841500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>99%</th>\n",
+       "      <td>18.5200</td>\n",
+       "      <td>6.634900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>eigen_value</th>\n",
+       "      <td>10.2804</td>\n",
+       "      <td>2.873192</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 GLD      GDXJ\n",
+       "90%          12.2971  2.705500\n",
+       "95%          14.2639  3.841500\n",
+       "99%          18.5200  6.634900\n",
+       "eigen_value  10.2804  2.873192"
+      ]
+     },
+     "execution_count": 101,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# First, the eigenvalue statistic test\n",
+    "j_eigenvalue_statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 102,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>90%</th>\n",
+       "      <td>13.429400</td>\n",
+       "      <td>2.705500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95%</th>\n",
+       "      <td>15.494300</td>\n",
+       "      <td>3.841500</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>99%</th>\n",
+       "      <td>19.934900</td>\n",
+       "      <td>6.634900</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>trace_statistic</th>\n",
+       "      <td>13.153592</td>\n",
+       "      <td>2.873192</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                       GLD      GDXJ\n",
+       "90%              13.429400  2.705500\n",
+       "95%              15.494300  3.841500\n",
+       "99%              19.934900  6.634900\n",
+       "trace_statistic  13.153592  2.873192"
+      ]
+     },
+     "execution_count": 102,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Next, the alternative trace statistic test\n",
+    "j_trace_statistics"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 103,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.184139</td>\n",
+       "      <td>0.003739</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>-0.206006</td>\n",
+       "      <td>0.235060</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        GLD      GDXJ\n",
+       "0  0.184139  0.003739\n",
+       "1 -0.206006  0.235060"
+      ]
+     },
+     "execution_count": 103,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Coefficients to construct a mean-reverting portfolio \n",
+    "j_cointegration_vectors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Portfolio creation**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "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>GLD</th>\n",
+       "      <th>GDXJ</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Date</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>2016-01-04</th>\n",
+       "      <td>0.014094</td>\n",
+       "      <td>0.030713</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-05</th>\n",
+       "      <td>0.002819</td>\n",
+       "      <td>0.002020</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-06</th>\n",
+       "      <td>0.014441</td>\n",
+       "      <td>0.017137</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-07</th>\n",
+       "      <td>0.014140</td>\n",
+       "      <td>0.023290</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2016-01-08</th>\n",
+       "      <td>-0.004428</td>\n",
+       "      <td>-0.028571</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 GLD      GDXJ\n",
+       "Date                          \n",
+       "2016-01-04  0.014094  0.030713\n",
+       "2016-01-05  0.002819  0.002020\n",
+       "2016-01-06  0.014441  0.017137\n",
+       "2016-01-07  0.014140  0.023290\n",
+       "2016-01-08 -0.004428 -0.028571"
+      ]
+     },
+     "execution_count": 104,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Calculating returns of our elements (ETFs)\n",
+    "train_three_elements_returns = (train_three_elements / train_three_elements.shift(1) - 1)[1:]\n",
+    "\n",
+    "train_three_elements_returns.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Johasen**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GLD     0.184139\n",
+       "GDXJ    0.003739\n",
+       "Name: 0, dtype: float64"
+      ]
+     },
+     "execution_count": 105,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Weights of elements for the Johansen portfolio\n",
+    "j_cointegration_vectors.loc[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 106,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GLD     0.9801\n",
+       "GDXJ    0.0199\n",
+       "Name: 0, dtype: float64"
+      ]
+     },
+     "execution_count": 106,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Scaling cointegration vectors so they sum up to 1\n",
+    "j_scaled_vectors = j_cointegration_vectors.loc[0] / abs(j_cointegration_vectors.loc[0]).sum()\n",
+    "\n",
+    "j_scaled_vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 107,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Also adding weights to take initial prices of our ETFs into account\n",
+    "weights  = train_three_elements.iloc[0] / abs(train_three_elements.iloc[0]).sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 108,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Also adding weights to take initial prices of our ETFs into account\n",
+    "weights_2  = train_three_elements[['GDXJ','GLD']].iloc[0] / abs(train_three_elements[['GDXJ','GLD']].iloc[0]).sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 109,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Calculating portfolio values during the training period\n",
+    "j_portfolio_returns = (train_three_elements_returns * j_scaled_vectors * weights).sum(axis=1)\n",
+    "j_portfolio_price = (j_portfolio_returns + 1).cumprod()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 110,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plotting Johansen portfolio price\n",
+    "j_portfolio_price.plot(title='Johansen portfolio price', figsize=(10,5));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Engle-Granger**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 111,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GLD     1.000000\n",
+       "GDXJ   -0.630068\n",
+       "Name: 0, dtype: float64"
+      ]
+     },
+     "execution_count": 111,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Weights of elements for the Engle-Granger portfolio\n",
+    "eg_cointegration_vectors.loc[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 112,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GLD     0.613471\n",
+       "GDXJ   -0.386529\n",
+       "Name: 0, dtype: float64"
+      ]
+     },
+     "execution_count": 112,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Scaling weights so they sum up to 1\n",
+    "eg_scaled_vectors = eg_cointegration_vectors.loc[0] / abs(eg_cointegration_vectors.loc[0]).sum()\n",
+    "\n",
+    "eg_scaled_vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 113,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Calculating portfolio values during the training period\n",
+    "eg_portfolio_returns = (train_three_elements_returns * eg_scaled_vectors * weights).sum(axis=1)\n",
+    "eg_portfolio_price = (eg_portfolio_returns + 1).cumprod()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 114,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plotting Engle-Granger portfolio price\n",
+    "eg_portfolio_price.plot(title='Engle-Granger portfolio price', figsize=(10,5));"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 115,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GDXJ    1.000000\n",
+       "GLD    -0.862224\n",
+       "Name: 0, dtype: float64"
+      ]
+     },
+     "execution_count": 115,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Weights of elements for the Engle-Granger portfolio\n",
+    "eg_cointegration_vectors_2.loc[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 116,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GDXJ    0.536992\n",
+       "GLD    -0.463008\n",
+       "Name: 0, dtype: float64"
+      ]
+     },
+     "execution_count": 116,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Scaling weights so they sum up to 1\n",
+    "eg_scaled_vectors_2 = eg_cointegration_vectors_2.loc[0] / abs(eg_cointegration_vectors_2.loc[0]).sum()\n",
+    "\n",
+    "eg_scaled_vectors_2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 117,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Calculating portfolio values during the training period\n",
+    "eg_portfolio_returns_2 = (train_three_elements_returns[['GDXJ','GLD']] * eg_scaled_vectors_2 * weights_2).sum(axis=1)\n",
+    "eg_portfolio_price_2 = (eg_portfolio_returns_2 + 1).cumprod()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plotting Engle-Granger portfolio price\n",
+    "eg_portfolio_price_2.plot(title='Engle-Granger portfolio price', figsize=(10,5));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can see that these portfolios perform similarly, as relative weights of elements in them are close. Let's compare them if we upscale the weights of the Johansen portfolio to match the weight of the first weight in the Engle-Granger portfolio."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "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>Johansen weights</th>\n",
+       "      <th>Engle-Granger weights</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>GLD</th>\n",
+       "      <td>0.452797</td>\n",
+       "      <td>1.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>GDXJ</th>\n",
+       "      <td>0.009194</td>\n",
+       "      <td>-0.630068</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "      Johansen weights  Engle-Granger weights\n",
+       "GLD           0.452797               1.000000\n",
+       "GDXJ          0.009194              -0.630068"
+      ]
+     },
+     "execution_count": 119,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Scaling Johansen portfolio weights\n",
+    "weights = pd.concat([j_cointegration_vectors.loc[0]*2.459,\n",
+    "                     eg_cointegration_vectors.loc[0]],\n",
+    "                    axis=1,\n",
+    "                    keys = ['Johansen weights', 'Engle-Granger weights'])\n",
+    "\n",
+    "weights"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## RESIDUALS DATA"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Skewness & Kurtosis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 262,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(-0.7305115393889677, -0.19668952145303908)"
+      ]
+     },
+     "execution_count": 262,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "skewn = skew(res)\n",
+    "kurtos = kurtosis(res)\n",
+    "\n",
+    "skewn_2 = skew(res_2)\n",
+    "kurtos_2 = kurtosis(res_2)\n",
+    "skewn, kurtos"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 266,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res_df = pd.DataFrame(data={'Charachteristic': ['Standard Deviation', 'Half-life', 'Skewness', 'Kurtosis', 'Shapiro-Wilk normality test'], 'Value': [round(std,5), round(eg_res_half_life,5), round(skewn,5), round(kurtos,5), shap]})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 267,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res_df_2 = pd.DataFrame(data={'Charachteristic': ['Standard Deviation', 'Half-life', 'Skewness', 'Kurtosis', 'Shapiro-Wilk normality test'], 'Value': [round(std_2,5), round(eg_res_half_life_2,5), round(skewn_2,5), round(kurtos_2,5), shap_2]})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 268,
+   "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>Charachteristic</th>\n",
+       "      <th>Value</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Standard Deviation</td>\n",
+       "      <td>3.64817</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Half-life</td>\n",
+       "      <td>33.4797</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Skewness</td>\n",
+       "      <td>-0.73051</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Kurtosis</td>\n",
+       "      <td>-0.19669</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Shapiro-Wilk normality test</td>\n",
+       "      <td>Failed</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "               Charachteristic    Value\n",
+       "0           Standard Deviation  3.64817\n",
+       "1                    Half-life  33.4797\n",
+       "2                     Skewness -0.73051\n",
+       "3                     Kurtosis -0.19669\n",
+       "4  Shapiro-Wilk normality test   Failed"
+      ]
+     },
+     "execution_count": 268,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "res_df\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 263,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eg_res_half_life = get_half_life_of_mean_reversion(res)\n",
+    "eg_res_half_life_2 = get_half_life_of_mean_reversion(res_2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 264,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9862629771232605"
+      ]
+     },
+     "execution_count": 264,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "std = res.std()\n",
+    "std_2 = res_2.std()\n",
+    "\n",
+    "stat"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 265,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stat, p = shapiro(res)\n",
+    "alpha = 0.05\n",
+    "\n",
+    "p,alpha\n",
+    "\n",
+    "if p>alpha:\n",
+    "    shap='Passed'\n",
+    "else:\n",
+    "    shap = 'Failed'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 230,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stat_2, p_2 = shapiro(res_2)\n",
+    "alpha_2 = 0.05\n",
+    "\n",
+    "p_2,alpha\n",
+    "\n",
+    "if p_2>alpha:\n",
+    "    shap_2='Passed'\n",
+    "else:\n",
+    "    shap_2 = 'Failed'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 373,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "D:\\programs\\Anaconda\\envs\\arbitragelab\\lib\\site-packages\\statsmodels\\tsa\\stattools.py:667: FutureWarning:\n",
+      "\n",
+      "fft=True will become the default after the release of the 0.12 release of statsmodels. To suppress this warning, explicitly set fft=False.\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "PACF = pacf(res, nlags=20)\n",
+    "ACF = acf(res, nlags=20)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 125,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from scipy import stats\n",
+    "import plotly.graph_objects as go\n",
+    "\n",
+    "qq = stats.probplot(eg_portfolio.residuals, dist='norm', sparams=(1))\n",
+    "x = np.array([qq[0][0][0], qq[0][0][-1]])\n",
+    "\n",
+    "# fig = go.Figure()\n",
+    "# fig.add_scatter(x=qq[0][0], y=qq[0][1], mode='markers')\n",
+    "# fig.add_scatter(x=x, y=qq[1][1] + qq[1][0]*x, mode='lines')\n",
+    "# fig.layout.update(showlegend=False)\n",
+    "# fig.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 374,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res_2 = eg_portfolio_2.residuals\n",
+    "\n",
+    "qq_2 = stats.probplot(eg_portfolio_2.residuals, dist='norm', sparams=(1))\n",
+    "\n",
+    "x_2 = np.array([qq_2[0][0][0], qq_2[0][0][-1]])\n",
+    "\n",
+    "PACF_2 = pacf(res_2, nlags=20)\n",
+    "\n",
+    "ACF_2 = acf(res_2, nlags=20)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 127,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      " * Serving Flask app \"__main__\" (lazy loading)\n",
+      " * Environment: production\n",
+      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
+      "   Use a production WSGI server instead.\n",
+      " * Debug mode: off\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " * Running on http://127.0.0.1:8050/ (Press CTRL+C to quit)\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "fig_1 = go.Figure()\n",
+    "fig_1.add_trace(go.Scatter(\n",
+    "    x= np.arange(len(PACF)),\n",
+    "    y= PACF,\n",
+    "    name= 'PACF',\n",
+    "    ))\n",
+    "fig_1.update_xaxes(rangeslider_visible=True)\n",
+    "fig_1.update_layout(\n",
+    "    title=\"Partial Autocorrelation\",\n",
+    "    xaxis_title=\"Lag\",\n",
+    "    yaxis_title=\"Partial Autocorrelation\",\n",
+    "    #     autosize=False,\n",
+    "    #     width=500,\n",
+    "         height=500,\n",
+    "    )\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    dcc.Graph(\n",
+    "        id='example-graph-2',\n",
+    "        figure=fig_1\n",
+    "        , style={'width':'30%', \n",
+    "                    'height':'80%',\n",
+    "                    'margin-top': 0,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "#                     'display':'inline-block'\n",
+    "                }),\n",
+    "\n",
+    "\n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Compiled data**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "residuals_data = {'skewness':skew, 'kurtosis':kurtosis, 'half-life':eg_res_half_life, 'standard deviation':std, 'normality p':p}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 346,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "confidence_levels = ['Confidence level',['99%', '95%', '90%']]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 349,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'confidence_level' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-349-85f8c8dc61e7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdata\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[0mconfidence_level\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m:\u001b[0m\u001b[0mconfidence_level\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m: name 'confidence_level' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "data = {confidence_levels[0]:confidence_levels[1]}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eg_portfolio_price.index"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# VISUALS PLOTLY"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 50,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import plotly.graph_objects as go\n",
+    "import plotly.express as px"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "fig = go.Figure()\n",
+    "fig.add_trace(go.Scatter(x=eg_portfolio_price.index, y=eg_portfolio_price,\n",
+    "                    mode='lines', line=dict(color='darkturquoise')))\n",
+    "fig.update_layout(\n",
+    "    title=\"GLD/GDXJ portfolio price\",\n",
+    "    xaxis_title=\"Date\",\n",
+    "    yaxis_title=\"Price\",\n",
+    "    \n",
+    "    #     autosize=False,\n",
+    "    #     width=500,\n",
+    "         height=500,\n",
+    "    )\n",
+    "\n",
+    "fig.update_xaxes(rangeslider_visible=True)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    \n",
+    "     dcc.Graph(\n",
+    "        id='example-graph',\n",
+    "        figure=fig\n",
+    "        , style={'width':'90%', \n",
+    "                    'height':'90%',\n",
+    "                    'margin-top': 30,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "#                     'display':'inline-block'\n",
+    "                })  \n",
+    "\n",
+    "    \n",
+    "    \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "df_pacf = PACF\n",
+    "fig = go.Figure()\n",
+    "fig.add_trace(go.Scatter(\n",
+    "    x= np.arange(len(df_pacf)),\n",
+    "    y= df_pacf,\n",
+    "    name= 'PACF',\n",
+    "    ))\n",
+    "fig.update_xaxes(rangeslider_visible=True)\n",
+    "fig.update_layout(\n",
+    "    title=\"Partial Autocorrelation\",\n",
+    "    xaxis_title=\"Lag\",\n",
+    "    yaxis_title=\"Partial Autocorrelation\",\n",
+    "    #     autosize=False,\n",
+    "    #     width=500,\n",
+    "         height=500,\n",
+    "    )\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    dcc.Graph(\n",
+    "        id='example-graph',\n",
+    "        figure=fig\n",
+    "        , style={'width':'90%', \n",
+    "                    'height':'90%',\n",
+    "                    'margin-top': 30,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "#                     'display':'inline-block'\n",
+    "                })  \n",
+    "    \n",
+    "    \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## **PACF**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 270,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      " * Serving Flask app \"__main__\" (lazy loading)\n",
+      " * Environment: production\n",
+      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
+      "   Use a production WSGI server instead.\n",
+      " * Debug mode: off\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " * Running on http://127.0.0.1:8050/ (Press CTRL+C to quit)\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET / HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET /_dash-component-suites/dash_renderer/polyfill@7.v1_9_0m1617880301.8.7.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET /_dash-component-suites/dash_renderer/prop-types@15.v1_9_0m1617880301.7.2.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET /_dash-component-suites/dash_renderer/react@16.v1_9_0m1617880301.14.0.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET /_dash-component-suites/dash_renderer/react-dom@16.v1_9_0m1617880301.14.0.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET /_dash-component-suites/dash_html_components/dash_html_components.v1_1_2m1617880302.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET /_dash-component-suites/dash_core_components/dash_core_components-shared.v1_15_0m1617880302.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET /_dash-component-suites/dash_table/bundle.v4_11_2m1617880301.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET /_dash-component-suites/dash_renderer/dash_renderer.v1_9_0m1617880301.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:10] \"\u001b[37mGET /_dash-component-suites/dash_core_components/dash_core_components.v1_15_0m1617880302.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:11] \"\u001b[37mGET /_dash-layout HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:11] \"\u001b[37mGET /_dash-dependencies HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [13/Apr/2021 09:35:11] \"\u001b[37mGET /_favicon.ico?v=1.19.0 HTTP/1.1\u001b[0m\" 200 -\n"
+     ]
+    }
+   ],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "trace2 = {\n",
+    "  \"name\": \"pacf\", \n",
+    "  \"type\": \"bar\", \n",
+    "  \"y\": PACF\n",
+    "}\n",
+    "\n",
+    "fig = go.Figure(data=trace2)\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    dcc.Graph(\n",
+    "        id='example-graph',\n",
+    "        figure=fig\n",
+    "        , style={'width':'40%', \n",
+    "                    'height':'90%',\n",
+    "                    'margin-top': 30,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "#                     'display':'inline-block'\n",
+    "                })  \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# VISUALS DASH"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Imports"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import dash\n",
+    "import dash_core_components as dcc\n",
+    "import dash_html_components as html\n",
+    "from flask import request\n",
+    "import dash_table"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'fig_1' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-52-c174a5e22990>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     58\u001b[0m     dcc.Graph(\n\u001b[0;32m     59\u001b[0m         \u001b[0mid\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'example-graph-2'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 60\u001b[1;33m         \u001b[0mfigure\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mfig_1\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     61\u001b[0m         , style={'width':'30%', \n\u001b[0;32m     62\u001b[0m                     \u001b[1;34m'height'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;34m'80%'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'fig_1' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "# assume you have a \"long-form\" data frame\n",
+    "# see https://plotly.com/python/px-arguments/ for more options\n",
+    "\n",
+    "fig =  go.Figure()\n",
+    "fig.add_scatter(x=qq[0][0], y=qq[0][1], mode='markers')\n",
+    "fig.add_scatter(x=x, y=qq[1][1] + qq[1][0]*x, mode='lines')\n",
+    "fig.layout.update(showlegend=False)\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    html.Div(children=[\n",
+    "        html.Img(src='/assets/LB_Hudson_Thames_ProductLogos_ArbitrageLab-01.png', \n",
+    "             style={'width':'15%', \n",
+    "                    'height':'15%',\n",
+    "                    'margin-bottom': 30,\n",
+    "                    'margin-left': 30, \n",
+    "                    'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "                    'display':'inline-block'\n",
+    "                   }),\n",
+    "\n",
+    "        html.H1(children='Hello Dash',\n",
+    "                style={'padding-bottom': '1%',\n",
+    "                       'vertical-align': 'bottom', \n",
+    "                       'horizontal-align': 'right',\n",
+    "                       'display':'inline-block'\n",
+    "                   })]),\n",
+    "\n",
+    "    html.Div(children='''\n",
+    "        Q-Q PLOT.\n",
+    "        ''',\n",
+    "             style={'font-family':'Josefin Sans', \n",
+    "                    'font-weight':'300',\n",
+    "                    'font-size': 30,\n",
+    "                    'margin-left': 70, \n",
+    "                    'align': 'center',\n",
+    "#                     'display':'inline-block'\n",
+    "                    \n",
+    "                }),\n",
+    "\n",
+    "    dcc.Graph(\n",
+    "        id='example-graph',\n",
+    "        figure=fig\n",
+    "        , style={'width':'30%', \n",
+    "                    'height':'80%',\n",
+    "                    'margin-top': 0,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "                    'display':'inline-block'\n",
+    "                }),\n",
+    "    dcc.Graph(\n",
+    "        id='example-graph-2',\n",
+    "        figure=fig_1\n",
+    "        , style={'width':'30%', \n",
+    "                    'height':'80%',\n",
+    "                    'margin-top': 0,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "#                     'display':'inline-block'\n",
+    "                }),\n",
+    "\n",
+    "\n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 99,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:__main__:Dash is running on http://127.0.0.1:8050/\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " * Serving Flask app \"__main__\" (lazy loading)\n",
+      " * Environment: production\n",
+      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
+      "   Use a production WSGI server instead.\n",
+      " * Debug mode: off\n"
+     ]
+    }
+   ],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "fig = go.Figure()\n",
+    "fig.add_trace(go.Scatter(x=train_three_elements.index, y=train_three_elements['GLD'],\n",
+    "                    mode='lines', line=dict(color='darkturquoise')))\n",
+    "fig.update_layout(\n",
+    "    title=\"GLD/GDXJ portfolio price\",\n",
+    "    xaxis_title=\"Date\",\n",
+    "    yaxis_title=\"Price\",\n",
+    "    #     autosize=False,\n",
+    "    #     width=500,\n",
+    "         height=500,\n",
+    "    )\n",
+    "\n",
+    "fig.update_xaxes(rangeslider_visible=True)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    \n",
+    "     dcc.Graph(\n",
+    "        id='example-graph',\n",
+    "        figure=fig\n",
+    "        , style={'width':'90%', \n",
+    "                    'height':'90%',\n",
+    "                    'margin-top': 30,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "#                     'display':'inline-block'\n",
+    "                })  \n",
+    "\n",
+    "    \n",
+    "    \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "norm_GLD = (train_three_elements['GLD'] - train_three_elements['GLD'].min())/(train_three_elements['GLD'].max()-train_three_elements['GLD'].min())\n",
+    "norm_GDXJ = (train_three_elements['GDXJ'] - train_three_elements['GDXJ'].min())/(train_three_elements['GDXJ'].max()-train_three_elements['GDXJ'].min())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "height: auto;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      " * Serving Flask app \"__main__\" (lazy loading)\n",
+      " * Environment: production\n",
+      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
+      "   Use a production WSGI server instead.\n",
+      " * Debug mode: off\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " * Running on http://127.0.0.1:8050/ (Press CTRL+C to quit)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import dash\n",
+    "import dash_core_components as dcc\n",
+    "import dash_html_components as html\n",
+    "from dash.dependencies import Input, Output\n",
+    "\n",
+    "\n",
+    "blue = '#0C9AAC'\n",
+    "orange = '#DE612F'\n",
+    "grey = '#949494'\n",
+    "light_grey = '#F2F3F4'\n",
+    "black = '#0B0D13'\n",
+    "white = '#ffffff'\n",
+    "oxford_blue = '#072040'\n",
+    "colors = {\n",
+    "    'background': light_grey,\n",
+    "    'text': black,\n",
+    "    'highlight': blue,\n",
+    "    'white': white,\n",
+    "    'orange': orange\n",
+    "}\n",
+    "\n",
+    "asset_prices = go.Figure()\n",
+    "asset_prices.add_trace(go.Scatter(x=train_three_elements.index, y=norm_GLD,\n",
+    "                    mode='lines', line=dict(color=blue), name='GLD'))\n",
+    "asset_prices.add_trace(go.Scatter(x=train_three_elements.index, y=norm_GDXJ,\n",
+    "                    mode='lines', line=dict(color=orange), name='GDXJ'))\n",
+    "asset_prices.update_layout(\n",
+    "    legend=dict(\n",
+    "    yanchor=\"top\",\n",
+    "    y=0.97,\n",
+    "    xanchor=\"left\",\n",
+    "    x=0.925),\n",
+    "    title=\"Asset prices\",\n",
+    "    xaxis_title=\"Date\",\n",
+    "    yaxis_title=\"Price\",\n",
+    "    font_family='Josefin Sans', \n",
+    "    font_size=18,\n",
+    "    #     autosize=False,\n",
+    "    #     width=500,\n",
+    "    height=500,\n",
+    "    hovermode='x unified'\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "\n",
+    "asset_prices.update_xaxes(rangeslider_visible=True)\n",
+    "\n",
+    "\n",
+    "app = dash.Dash()\n",
+    "\n",
+    "\n",
+    "app.layout = html.Div(style={'backgroundColor': colors['background'], 'padding-bottom': 30}, children=[\n",
+    "    \n",
+    "    html.Img(src='/assets/LB_Hudson_Thames_ProductLogos_ArbitrageLab-13.png', \n",
+    "         style={'width':'20%', \n",
+    "                'height':'20%',\n",
+    "                'padding-top': 50,                \n",
+    "                'display': 'block',\n",
+    "                'margin-left': 'auto',\n",
+    "                'margin-right': 'auto'\n",
+    "               }),\n",
+    "\n",
+    "    html.H1(\n",
+    "        children='COINTEGRATION ANALYSIS OF GLD/GDXJ',\n",
+    "        style={\n",
+    "            'textAlign': 'center',\n",
+    "            'color': colors['text'],\n",
+    "            'font-family':'Josefin Sans', \n",
+    "            'font-weight':'300',\n",
+    "            'font-size': 50,\n",
+    "            'padding-top': 30,\n",
+    "            'padding-left': 50,\n",
+    "            'margin-top': 30,\n",
+    "            'margin-left': 'auto',\n",
+    "            'margin-right': 'auto'\n",
+    "        }\n",
+    "    ),\n",
+    "    \n",
+    "   # INITIAL DIV \n",
+    "    html.Div(style={'margin-left': '5%', 'margin-right': '5%',\n",
+    "                    'margin-top': '5%', 'margin-bottom': '5%',  \n",
+    "                    'backgroundColor': colors['white'],\n",
+    "                    'horizontal-align': 'center'}, children=[\n",
+    "        \n",
+    "        html.Div(style={'backgroundColor': colors['white'],\n",
+    "                    'display':'inline-block', 'padding-left': 30,\n",
+    "                    'padding-right': 50, 'padding-top': 60,\n",
+    "                    'padding-bottom': 50, 'margin-left': 50,\n",
+    "                    'margin-right': 50, 'margin-top': 0,\n",
+    "                    'margin-bottom': 50, 'vertical-align':'center', \n",
+    "                    'horizontal-align': 'center', 'height': 315, 'width': '20%'}, children=[        \n",
+    "        \n",
+    "            html.H2(\n",
+    "            children='The results of the ADF tests:',\n",
+    "            style={\n",
+    "                'textAlign': 'left',\n",
+    "                'color': colors['text'],\n",
+    "                'font-family':'Josefin Sans', \n",
+    "                'font-weight':'500',\n",
+    "                'font-size': 24,\n",
+    "                'padding-bottom': '20%',\n",
+    "            }\n",
+    "            ),\n",
+    "\n",
+    "            html.P(\n",
+    "            children='GLD',\n",
+    "            style={\n",
+    "                'textAlign': 'left',\n",
+    "                'color': colors['highlight'],\n",
+    "                'font-family':'Josefin Sans', \n",
+    "                'font-weight':'500',\n",
+    "                'font-size': 20\n",
+    "\n",
+    "            }),\n",
+    "\n",
+    "\n",
+    "            html.P(\n",
+    "            children='The hypothesis is not rejected at 95% confidence level',\n",
+    "            style={\n",
+    "                'textAlign': 'left',\n",
+    "                'color': colors['text'],\n",
+    "                'font-family':'Roboto', \n",
+    "                'font-weight':'300',\n",
+    "                'font-size': 18\n",
+    "\n",
+    "            }),\n",
+    "\n",
+    "            html.P(\n",
+    "            children='GDXJ',\n",
+    "            style={\n",
+    "                'textAlign': 'left',\n",
+    "                'color': colors['highlight'],\n",
+    "                'font-family':'Josefin Sans', \n",
+    "                'font-weight':'500',\n",
+    "                'font-size': 20\n",
+    "\n",
+    "            }),\n",
+    "\n",
+    "\n",
+    "            html.P(\n",
+    "            children='The hypothesis is not rejected at 90% confidence level',\n",
+    "            style={\n",
+    "                'textAlign': 'left',\n",
+    "                'color': colors['text'],\n",
+    "                'font-family':'Roboto', \n",
+    "                'font-weight':'300',\n",
+    "                'font-size': 18\n",
+    "\n",
+    "            }),\n",
+    "\n",
+    "\n",
+    "        ]),\n",
+    "    \n",
+    "    dcc.Graph(\n",
+    "        id='example-graph',\n",
+    "        figure=asset_prices\n",
+    "        , style={'width': '60%', \n",
+    "                 'height': '100%',\n",
+    "                 'padding-left': 50,\n",
+    "                 #'padding-right': 50,\n",
+    "                 'padding-top': 50,\n",
+    "                 'padding-bottom': 30, \n",
+    "                 #'margin-right': 50, \n",
+    "                 'margin-top': 0,\n",
+    "                 'margin-bottom': 0, 'vertical-align':'top', \n",
+    "                 'horizontal-align': 'right',\n",
+    "                 'display':'inline-block',\n",
+    "                 'font-family':'Josefin Sans', \n",
+    "                 'font-weight':'300',\n",
+    "                 'font-size': 24,\n",
+    "             \n",
+    "                })\n",
+    "        \n",
+    "        \n",
+    "    ]),\n",
+    "    \n",
+    "    \n",
+    "    html.Div(style={'margin-left': '5%', 'margin-right': '5%',\n",
+    "                    'margin-top': '5%', 'margin-bottom': '5%', \n",
+    "#                     'margin-left': '1%',\n",
+    "#                     'margin-right': '0%', 'margin-top': '1%',\n",
+    "#                     'margin-bottom': '1%', \n",
+    "                    'backgroundColor': colors['white'],\n",
+    "                    'horizontal-align': 'center'}, children=[\n",
+    "        \n",
+    "        \n",
+    "            html.H2(\n",
+    "                children='ENGLE-GRANGER APPROACH',\n",
+    "                style={\n",
+    "                    'textAlign': 'left',\n",
+    "                    'color': colors['text'],\n",
+    "                    'font-family':'Josefin Sans', \n",
+    "                    'font-weight':'300',\n",
+    "                    'font-size': 40,\n",
+    "                    'padding-left': 50,\n",
+    "                    'padding-right': 50,\n",
+    "                    'padding-top': 60,\n",
+    "                    'padding-bottom': 0,\n",
+    "                    'margin-left': 50,\n",
+    "                    'margin-right': 50,\n",
+    "                    'margin-top': 0,\n",
+    "                    'margin-bottom': 0,\n",
+    "                    \n",
+    "                }\n",
+    "            ),         \n",
+    "            \n",
+    "            html.Div(style={'display':'block',\n",
+    "                            'padding-left': 50,\n",
+    "                            'padding-right': 50,\n",
+    "                            'padding-top': 60,\n",
+    "                            'padding-bottom': 0,\n",
+    "                            'margin-left': 50,\n",
+    "                            'margin-right': 50,\n",
+    "                            'margin-top': 0,\n",
+    "                            'margin-bottom': 0,\n",
+    "                            'vertical-align':'center',\n",
+    "                            'horizontal-align': 'right'}, children=[               \n",
+    "                \n",
+    "                html.Button('GLD/GDXJ', id='btn-nclicks-1', n_clicks=0, style={'BackgroundColor': colors['white'], 'padding-left': 40,\n",
+    "                                                                               'padding-right': 40, 'padding-top': 20,\n",
+    "                                                                               'padding-bottom': 20, 'margin-left': 0,\n",
+    "                                                                               'margin-right': 25, 'margin-top': 0,\n",
+    "                                                                               'margin-bottom': 0, 'font-family':'Josefin Sans',\n",
+    "                                                                               'font-weight':'300', 'font-size': 20,\n",
+    "                                                                              }),\n",
+    "                \n",
+    "                html.Button('GDXJ/GLD', id='btn-nclicks-2', n_clicks=0, style={'BackgroundColor': colors['white'], 'padding-left': 40,\n",
+    "                                                                               'padding-right': 40, 'padding-top': 20,\n",
+    "                                                                               'padding-bottom': 20, 'margin-left': 25,\n",
+    "                                                                               'margin-right': 40, 'margin-top': 0,\n",
+    "                                                                               'margin-bottom': 0, 'font-family':'Josefin Sans',\n",
+    "                                                                               'font-weight':'300', 'font-size': 20,\n",
+    "                                                                              }),\n",
+    "            ]),\n",
+    "                \n",
+    "            \n",
+    "            \n",
+    "                \n",
+    "            html.Div(id='container-button'),\n",
+    "              \n",
+    "    ])\n",
+    "])\n",
+    "\n",
+    "@app.callback(Output('container-button', 'children'),\n",
+    "              Input('btn-nclicks-1', 'n_clicks'),\n",
+    "              Input('btn-nclicks-2', 'n_clicks'))\n",
+    "\n",
+    "def displayClick(btn1, btn2):\n",
+    "    changed_id = [p['prop_id'] for p in dash.callback_context.triggered][0]\n",
+    "    if 'btn-nclicks-1' in changed_id:\n",
+    "        asset_1 = 'GLD'\n",
+    "        asset_2 = 'GDXJ'\n",
+    "        coint_test = eg_adf\n",
+    "        test_statistic = test_stat\n",
+    "        beta = eg_cointegration_vectors.loc[0][1]\n",
+    "        portfolio_price = eg_portfolio_price\n",
+    "        portfolio_return = eg_portfolio_returns\n",
+    "        pacf = PACF\n",
+    "        acf = ACF\n",
+    "        residuals = res\n",
+    "        qq_data = qq\n",
+    "        x_data = x\n",
+    "        res_data = res_df\n",
+    "        \n",
+    "    elif 'btn-nclicks-2' in changed_id:\n",
+    "        asset_1 = 'GDXJ'\n",
+    "        asset_2 = 'GLD'\n",
+    "        coint_test = eg_adf_2\n",
+    "        test_statistic = test_stat_2\n",
+    "        beta = eg_cointegration_vectors_2.loc[0][1]\n",
+    "        portfolio_price = eg_portfolio_price_2\n",
+    "        portfolio_return = eg_portfolio_returns_2\n",
+    "        pacf = PACF_2\n",
+    "        acf = ACF_2\n",
+    "        residuals = res_2\n",
+    "        qq_data = qq_2\n",
+    "        x_data = x_2\n",
+    "        res_data = res_df_2\n",
+    "        \n",
+    "    else:\n",
+    "        asset_1 = 'GLD'\n",
+    "        asset_2 = 'GDXJ'\n",
+    "        coint_test = eg_adf\n",
+    "        test_statistic = test_stat\n",
+    "        beta = eg_cointegration_vectors.loc[0][1]\n",
+    "        portfolio_price = eg_portfolio_price\n",
+    "        portfolio_return = eg_portfolio_returns\n",
+    "        pacf = PACF\n",
+    "        acf = ACF\n",
+    "        residuals = res\n",
+    "        qq_data = qq\n",
+    "        x_data = x\n",
+    "        res_data = res_df\n",
+    "    \n",
+    "    \n",
+    "    portfolio = go.Figure()\n",
+    "    portfolio.add_trace(go.Scatter(x=portfolio_price.index, y=portfolio_price,\n",
+    "                    mode='lines', line=dict(color=blue), name='Portfolio price'))\n",
+    "    portfolio.add_trace(go.Scatter(x=portfolio_return.index, y=portfolio_return,\n",
+    "                    mode='lines', line=dict(color=orange), name='Portfolio return', visible='legendonly'))\n",
+    "    portfolio.update_layout(\n",
+    "        legend=dict(\n",
+    "        yanchor=\"top\",\n",
+    "        y=0.97,\n",
+    "        xanchor=\"left\",\n",
+    "        x=0.77),\n",
+    "        title=\"Normalized portfolio\",\n",
+    "        xaxis_title=\"Date\",\n",
+    "        yaxis_title=\"Price\",\n",
+    "        font_family='Josefin Sans', \n",
+    "        font_size=18,\n",
+    "        height=500,\n",
+    "        )\n",
+    "    portfolio.update_xaxes(rangeslider_visible=True)\n",
+    "    \n",
+    "    trace = {\n",
+    "        \"name\": \"PACF\", \n",
+    "        \"type\": \"bar\",\n",
+    "        \"marker_color\": blue,\n",
+    "        \"y\": pacf\n",
+    "        \n",
+    "    }\n",
+    "    \n",
+    "    _pacf_plot = go.Figure(data=trace)\n",
+    "    \n",
+    "    _pacf_plot.update_layout(\n",
+    "        title=\"PACF\",\n",
+    "        xaxis_title=\"Lag\",\n",
+    "        #yaxis_title=\"Price\",\n",
+    "        font_family='Josefin Sans', \n",
+    "        font_size=14,\n",
+    "        height = 250,\n",
+    "        margin=dict(l=30, r=30, t=50, b=30))\n",
+    "    \n",
+    "    trace = {\n",
+    "        \"name\": \"ACF\", \n",
+    "        \"type\": \"bar\",\n",
+    "        \"marker_color\": blue,\n",
+    "        \"y\": acf\n",
+    "        \n",
+    "    }\n",
+    "    \n",
+    "    _acf_plot = go.Figure(data=trace)\n",
+    "    \n",
+    "    _acf_plot.update_layout(\n",
+    "        title=\"ACF\",\n",
+    "        xaxis_title=\"Lag\",\n",
+    "        #yaxis_title=\"Price\",\n",
+    "        font_family='Josefin Sans', \n",
+    "        font_size=14,\n",
+    "        height = 250,\n",
+    "        margin=dict(l=30, r=30, t=50, b=30))\n",
+    "    \n",
+    "    resid_plot = go.Figure()\n",
+    "    resid_plot.add_trace(go.Scatter(x=residuals.index, y=residuals,\n",
+    "                    mode='lines', line=dict(color=orange)))\n",
+    "    resid_plot.add_shape(type='line',\n",
+    "                         x0='2015-12-31', y0=0, x1='2017-12-29', y1=0, \n",
+    "                         line=dict(color=grey, dash='dash'))\n",
+    "    resid_plot.update_layout(\n",
+    "        title=\"Residuals plot\",\n",
+    "        font_family='Josefin Sans', \n",
+    "        font_size=14,\n",
+    "        height = 250,\n",
+    "        margin=dict(l=30, r=30, t=50, b=30)\n",
+    "        )\n",
+    "    \n",
+    "    _qq_plot =  go.Figure()\n",
+    "    _qq_plot.add_scatter(x=qq_data[0][0], y=qq_data[0][1], mode='markers', line=dict(color=blue))\n",
+    "    _qq_plot.add_scatter(x=x, y=qq_data[1][1] + qq_data[1][0]*x_data, mode='lines', line=dict(color=grey))\n",
+    "    _qq_plot.update_layout(\n",
+    "            title=\"Q-Q Plot\",\n",
+    "        font_family='Josefin Sans', \n",
+    "        font_size=14,\n",
+    "        height = 550,\n",
+    "        margin=dict(l=30, r=30, t=50, b=30),\n",
+    "        showlegend=False\n",
+    "        )\n",
+    "    \n",
+    "        \n",
+    "    \n",
+    "    return html.Div(style={'padding-left': 50,\n",
+    "                            'padding-right': 0,\n",
+    "                            'padding-top': 20,\n",
+    "                            'padding-bottom': 50,\n",
+    "                            'margin-left': 50,\n",
+    "                            'margin-right': 0,\n",
+    "                            'margin-top': 0,\n",
+    "                            'margin-bottom': 0,\n",
+    "                            'backgroundColor': colors['white'],\n",
+    "                            'horizontal-align': 'center', \n",
+    "                             }, children=[\n",
+    "        # Equation\n",
+    "        html.Div(style={'backgroundColor': colors['white'],\n",
+    "                        'padding-top': 30,\n",
+    "                        'textAlign':'left', \n",
+    "                        'horizontal-align':'center'}, children=[\n",
+    "                 \n",
+    "                 html.H2(children='{} ='.format(asset_1),\n",
+    "                    style={'textAlign': 'left',\n",
+    "                           'color': colors['text'],\n",
+    "                           'font-family':'Josefin Sans', \n",
+    "                           'font-weight':'300',\n",
+    "                           'font-size': 30,\n",
+    "                           'padding-bottom': 30,\n",
+    "                           'display':'inline-block'\n",
+    "                          }\n",
+    "                    ),\n",
+    "            \n",
+    "                html.H2(children='⠀{}⠀'.format(round(beta,4)),\n",
+    "                        style={'textAlign': 'left',\n",
+    "                               'color': colors['highlight'],\n",
+    "                               'font-family':'Josefin Sans', \n",
+    "                               'font-weight':'400',\n",
+    "                               'font-size': 30,\n",
+    "                               'padding-bottom': 30,\n",
+    "                               'display':'inline-block'\n",
+    "                              }\n",
+    "                        ),\n",
+    "\n",
+    "                html.H2(children='* {} + ε(t)'.format(asset_2),\n",
+    "                        style={'textAlign': 'left',\n",
+    "                               'color': colors['text'],\n",
+    "                               'font-family':'Josefin Sans', \n",
+    "                               'font-weight':'300',\n",
+    "                               'font-size': 30,\n",
+    "                               'padding-bottom': 30,\n",
+    "                               'display':'inline-block'\n",
+    "                              }\n",
+    "                        ),\n",
+    "                 \n",
+    "             ]),\n",
+    "        \n",
+    "        # Coint tests\n",
+    "        html.Div(children=[\n",
+    "        \n",
+    "            html.Div(style={'backgroundColor': colors['white'],\n",
+    "                        'display':'inline-block', 'padding-left': 0,\n",
+    "                        'padding-right': 50, 'padding-top': 0,\n",
+    "                        'padding-bottom': 0, 'margin-left': 0,\n",
+    "                        'margin-right': 10, 'margin-top': 0,\n",
+    "                        'margin-bottom': 0, 'vertical-align':'center', \n",
+    "                        'horizontal-align': 'center', 'width': '22%'}, children=[ \n",
+    "\n",
+    "\n",
+    "                      html.H3(children='Cointegration test results:',\n",
+    "                              style={'textAlign': 'left',\n",
+    "                                       'color': colors['text'],\n",
+    "                                       'font-family':'Josefin Sans', \n",
+    "                                       'font-weight':'500',\n",
+    "                                       'font-size': 22,\n",
+    "                                       'padding-bottom': '2%',\n",
+    "                                       'display':'block'\n",
+    "                                      }\n",
+    "                                ),\n",
+    "                      html.P(children='HYPOTHESIS REJECTED',\n",
+    "                            style={'textAlign': 'left',\n",
+    "                                   'color': colors['orange'],\n",
+    "                                   'font-family':'Josefin Sans', \n",
+    "                                   'font-weight':'350',\n",
+    "                                   'font-size': 20,\n",
+    "                                   'padding-bottom': '15%',\n",
+    "                                   'padding-top': 0,\n",
+    "                                   'display':'block'\n",
+    "                                  }\n",
+    "                            ),\n",
+    "\n",
+    "                      dash_table.DataTable(\n",
+    "                      data=coint_test.to_dict('records'),\n",
+    "                        columns=[{'id': c, 'name': c} for c in coint_test.columns],\n",
+    "                        style_as_list_view=True,\n",
+    "\n",
+    "                        style_cell={'padding': '10px', \n",
+    "                                    'backgroundColor': 'white',\n",
+    "                                    'fontSize': 14,\n",
+    "                                    'font-family':'Roboto'},\n",
+    "\n",
+    "                        style_header={'backgroundColor': 'white',\n",
+    "                                        'fontWeight': 'bold',\n",
+    "                                        'fontSize': 14,\n",
+    "                                        'font-family':'Josefin Sans'\n",
+    "\n",
+    "                        },),\n",
+    "\n",
+    "\n",
+    "                      html.Div(style={'display':'block'},children=[\n",
+    "\n",
+    "                                  html.P(\n",
+    "                                    children='Test statistic value: ',\n",
+    "                                    style={'textAlign': 'left',\n",
+    "                                           'color': colors['text'],\n",
+    "                                           'font-family':'Josefin Sans', \n",
+    "                                           'font-weight':'400',\n",
+    "                                           'font-size': 18,\n",
+    "                                           'padding-bottom': '10%',\n",
+    "                                           'display':'inline-block'\n",
+    "                                          }\n",
+    "                                    ),\n",
+    "\n",
+    "                                 html.P(children='⠀{}⠀'.format(round(test_statistic,5)),\n",
+    "                                        style={'textAlign': 'center',\n",
+    "                                               'color': colors['highlight'],\n",
+    "                                               'font-family':'Josefin Sans', \n",
+    "                                               'font-weight':'400',\n",
+    "                                               'font-size': 18,\n",
+    "                                               'padding-bottom': '10%',\n",
+    "                                               'display':'inline-block'\n",
+    "                                              }\n",
+    "                                        ),\n",
+    "\n",
+    "                                  ]),\n",
+    "\n",
+    "\n",
+    "                  ]),\n",
+    "\n",
+    "                  dcc.Graph(\n",
+    "                      id='example-graph-3',\n",
+    "                      figure=portfolio,\n",
+    "                      style={'width': '68%', \n",
+    "                     'height': '100%',\n",
+    "                     'padding-left': 50,\n",
+    "                     #'padding-right': 50,\n",
+    "                     'padding-top': 0,\n",
+    "                     'padding-bottom': 50, \n",
+    "                     #'margin-right': 50, \n",
+    "                     'margin-top': 0,\n",
+    "                     'margin-bottom': 0, 'vertical-align':'top', \n",
+    "                     'horizontal-align': 'right',\n",
+    "                     'display':'inline-block',\n",
+    "                     'font-family':'Josefin Sans', \n",
+    "                     'font-weight':'300',\n",
+    "                     'font-size': 20,})                                          \n",
+    "        \n",
+    "        ]),\n",
+    "        \n",
+    "        # Coint tests\n",
+    "        html.Div(id='resid',children=[\n",
+    "            \n",
+    "            html.Div(style={'backgroundColor': colors['white'],\n",
+    "                        'display':'inline-block', 'padding-left': 0,\n",
+    "                        'padding-right': 0, 'padding-top': 0,\n",
+    "                        'padding-bottom': 0, 'margin-left': 0,\n",
+    "                        'margin-right': 0, 'margin-top': 0,\n",
+    "                        'margin-bottom': 0, 'vertical-align':'center', \n",
+    "                        'horizontal-align': 'center', 'width': '100%'}, children=[ \n",
+    "\n",
+    "\n",
+    "                      html.H3(children='Residuals analysis results:',\n",
+    "                              style={'textAlign': 'left',\n",
+    "                                       'color': colors['text'],\n",
+    "                                       'font-family':'Josefin Sans', \n",
+    "                                       'font-weight':'500',\n",
+    "                                       'font-size': 22,\n",
+    "                                       'padding-bottom': '2%',\n",
+    "                                       'display':'block'\n",
+    "                                      }\n",
+    "                                ),\n",
+    "                html.Div(style={'backgroundColor': colors['white'],\n",
+    "                        'display':'inline-block', 'padding-left': 0,\n",
+    "                        'padding-right': 20, 'padding-top': 0,\n",
+    "                        'padding-bottom': 0, 'margin-left': 0,\n",
+    "                        'margin-right': 0, 'margin-top': 0,\n",
+    "                        'margin-bottom': 0, 'vertical-align':'top', \n",
+    "                        'horizontal-align': 'center', 'width': '30%'}, children=[ \n",
+    "                    \n",
+    "                 dash_table.DataTable(\n",
+    "                      data=res_data.to_dict('records'),\n",
+    "                        columns=[{'id': c, 'name': c} for c in res_data.columns],\n",
+    "                        style_as_list_view=True,\n",
+    "\n",
+    "                        style_cell={'padding': '10px', \n",
+    "                                    'backgroundColor': 'white',\n",
+    "                                    'fontSize': 14,\n",
+    "                                    'font-family':'Roboto',\n",
+    "                                    'textAlign':'left'},\n",
+    "\n",
+    "                        style_header={'padding': '15px',\n",
+    "                                      'backgroundColor': colors['background'],\n",
+    "                                      'fontSize': 18,\n",
+    "                                      'font-family':'Josefin Sans',\n",
+    "                                      'textAlign':'left'\n",
+    "\n",
+    "                        }),\n",
+    "                    \n",
+    "                 dcc.Graph(\n",
+    "                          id='example-graph-9',\n",
+    "                          figure=resid_plot,\n",
+    "                          style={'width': '100%', \n",
+    "                         'height': '100%',\n",
+    "                         'padding-left': 0,\n",
+    "                         #'padding-right': 50,\n",
+    "                         'padding-top': 50,\n",
+    "                         'padding-bottom': 0, \n",
+    "                         #'margin-right': 50, \n",
+    "                         'margin-top': 0,\n",
+    "                         'margin-bottom': 0, 'vertical-align':'top', \n",
+    "                         'horizontal-align': 'right',\n",
+    "                         'display':'block',\n",
+    "                         'font-family':'Josefin Sans', \n",
+    "                         'font-weight':'300',\n",
+    "                         'font-size': 20,}),\n",
+    "                \n",
+    "                ]),\n",
+    "                \n",
+    "                \n",
+    "                html.Div(style={'backgroundColor': colors['white'],\n",
+    "                        'display':'inline-block', 'width': '30%', 'vertical-align':'center', \n",
+    "                        'horizontal-align': 'center',},children=[\n",
+    "                    \n",
+    "                      dcc.Graph(\n",
+    "                          id='example-graph-4',\n",
+    "                          figure=_pacf_plot,\n",
+    "                          style={'width': '100%', \n",
+    "                         'height': '100%',\n",
+    "                         'padding-left': 0,\n",
+    "                         #'padding-right': 50,\n",
+    "                         'padding-top': 0,\n",
+    "                         'padding-bottom': 50, \n",
+    "                         #'margin-right': 50, \n",
+    "                         'margin-top': 0,\n",
+    "                         'margin-bottom': 0, 'vertical-align':'top', \n",
+    "                         'horizontal-align': 'right',\n",
+    "                         'display':'block',\n",
+    "                         'font-family':'Josefin Sans', \n",
+    "                         'font-weight':'300',\n",
+    "                         'font-size': 20,}),\n",
+    "                \n",
+    "                      dcc.Graph(\n",
+    "                          id='example-graph-5',\n",
+    "                          figure=_acf_plot,\n",
+    "                          style={'width': '100%', \n",
+    "                         'height': '100%',\n",
+    "                         'padding-left': 0,\n",
+    "                         #'padding-right': 50,\n",
+    "                         'padding-top': 0,\n",
+    "                         'padding-bottom': 50, \n",
+    "                         #'margin-right': 50, \n",
+    "                         'margin-top': 0,\n",
+    "                         'margin-bottom': 0, 'vertical-align':'top', \n",
+    "                         'horizontal-align': 'right',\n",
+    "                         'display':'block',\n",
+    "                         'font-family':'Josefin Sans', \n",
+    "                         'font-weight':'300',\n",
+    "                         'font-size': 20,}),\n",
+    "                ]),\n",
+    "                \n",
+    "                html.Div(style={'backgroundColor': colors['white'],\n",
+    "                        'display':'inline-block', 'padding-left': 0,\n",
+    "                        'padding-right': 0, 'padding-top': 0,\n",
+    "                        'padding-bottom': 0, 'margin-left': 0,\n",
+    "                        'margin-right': 0, 'margin-top': 0,\n",
+    "                        'margin-bottom': 0, 'vertical-align':'center', \n",
+    "                        'horizontal-align': 'center', 'width': '30%'}, children=[ \n",
+    "                    \n",
+    "                 dcc.Graph(\n",
+    "                          id='example-graph-6',\n",
+    "                          figure=_qq_plot,\n",
+    "                          style={'width': '100%', \n",
+    "                         'height': '100%',\n",
+    "                         'padding-left': 10,\n",
+    "                         #'padding-right': 50,\n",
+    "                         'padding-top': 0,\n",
+    "                         'padding-bottom': 50, \n",
+    "                         #'margin-right': 50, \n",
+    "                         'margin-top': 0,\n",
+    "                         'margin-bottom': 0, 'vertical-align':'top', \n",
+    "                         'horizontal-align': 'right',\n",
+    "                         'display':'block',\n",
+    "                         'font-family':'Josefin Sans', \n",
+    "                         'font-weight':'300',\n",
+    "                         'font-size': 20,}),\n",
+    "                \n",
+    "                 \n",
+    "                ]),\n",
+    "                \n",
+    "                \n",
+    "            \n",
+    "            ]), \n",
+    "            \n",
+    "            \n",
+    "            \n",
+    "            \n",
+    "            \n",
+    "        ]),\n",
+    "        \n",
+    "    \n",
+    "   ])\n",
+    "        \n",
+    "        \n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 244,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Date\n",
+       "2015-12-31   -0.006846\n",
+       "2016-01-04   -0.693621\n",
+       "2016-01-05   -0.906633\n",
+       "2016-01-06   -1.876581\n",
+       "2016-01-07   -2.717559\n",
+       "                ...   \n",
+       "2017-12-22   -1.884535\n",
+       "2017-12-26   -1.849172\n",
+       "2017-12-27   -2.284814\n",
+       "2017-12-28   -2.829142\n",
+       "2017-12-29   -3.635963\n",
+       "Name: GDXJ, Length: 504, dtype: float64"
+      ]
+     },
+     "execution_count": 244,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "            \n",
+    "#             html.Div(style={'padding-top': 0,\n",
+    "#                             'padding-left': 50,\n",
+    "#                             'margin-top': 0,\n",
+    "#                             'margin-left': 'auto',\n",
+    "#                             'margin-right': 'auto',\n",
+    "#                             'backgroundColor': colors['white'],\n",
+    "#                             'horizontal-align': 'center'}, children=[\n",
+    "        \n",
+    "#         html.Div(style={'backgroundColor': colors['white'],\n",
+    "#                                 'display':'inline-block', 'padding-left': 0,\n",
+    "#                                 'padding-right': 0, 'padding-top': 50,\n",
+    "#                                 'padding-bottom': '6%', 'margin-left': 0,\n",
+    "#                                 'margin-right': 0, 'margin-top': 50,\n",
+    "#                                 'margin-bottom': 50, 'vertical-align':'center', \n",
+    "#                                 'horizontal-align': 'center', 'height': 315}, children=[ \n",
+    "                    \n",
+    "                    \n",
+    "#                     html.H2(\n",
+    "#                         children='{} = {} * {} + ε(t)'.format('GLD',\n",
+    "#                                                                eg_cointegration_vectors.loc[0][1], \n",
+    "#                                                               'GDXJ'),\n",
+    "#                         style={'textAlign': 'left',\n",
+    "#                                'color': colors['text'],\n",
+    "#                                'font-family':'Josefin Sans', \n",
+    "#                                'font-weight':'500',\n",
+    "#                                'font-size': 26,\n",
+    "#                                'padding-bottom': '20%',\n",
+    "#                               }\n",
+    "#                     ),\n",
+    "\n",
+    "#                     html.P(\n",
+    "#                     children='GLD',\n",
+    "#                     style={'textAlign': 'left',\n",
+    "#                            'color': colors['highlight'],\n",
+    "#                            'font-family':'Josefin Sans', \n",
+    "#                            'font-weight':'500',\n",
+    "#                            'font-size': 24,\n",
+    "#                           }\n",
+    "#                     ),\n",
+    "\n",
+    "\n",
+    "#                     html.P(\n",
+    "#                     children='The hypothesis is not rejected at 95% confidence level',\n",
+    "#                     style={'textAlign': 'left',\n",
+    "#                            'color': colors['text'],\n",
+    "#                            'font-family':'Roboto', \n",
+    "#                            'font-weight':'300',\n",
+    "#                            'font-size': 24,\n",
+    "#                            }\n",
+    "#                     ),\n",
+    "\n",
+    "#                     html.P(\n",
+    "#                     children='GDXJ',\n",
+    "#                     style={'textAlign': 'left',\n",
+    "#                            'color': colors['highlight'],\n",
+    "#                            'font-family':'Josefin Sans', \n",
+    "#                            'font-weight':'500',\n",
+    "#                            'font-size': 24,\n",
+    "#                           }\n",
+    "#                     ),\n",
+    "\n",
+    "\n",
+    "#                     html.P(\n",
+    "#                     children='The hypothesis is not rejected at 90% confidence level',\n",
+    "#                     style={'textAlign': 'left',\n",
+    "#                            'color': colors['text'],\n",
+    "#                            'font-family':'Roboto', \n",
+    "#                            'font-weight':'300',\n",
+    "#                            'font-size': 24,\n",
+    "#                           }\n",
+    "#                     ),\n",
+    "\n",
+    "\n",
+    "#                 ]), \n",
+    "#             ]),\n",
+    "                \n",
+    "                \n",
+    "  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 255,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Date\n",
+       "2015-12-31   -0.006846\n",
+       "2016-01-04   -0.693621\n",
+       "2016-01-05   -0.906633\n",
+       "2016-01-06   -1.876581\n",
+       "2016-01-07   -2.717559\n",
+       "                ...   \n",
+       "2017-12-22   -1.884535\n",
+       "2017-12-26   -1.849172\n",
+       "2017-12-27   -2.284814\n",
+       "2017-12-28   -2.829142\n",
+       "2017-12-29   -3.635963\n",
+       "Name: GDXJ, Length: 504, dtype: float64"
+      ]
+     },
+     "execution_count": 255,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "res_2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 156,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eg_adf_statistics[' '] = eg_adf_statistics.index\n",
+    "\n",
+    "eg_adf = eg_adf_statistics[:-1]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "eg_adf_statistics_2[' '] = eg_adf_statistics_2.index\n",
+    "\n",
+    "eg_adf_2 = eg_adf_statistics_2[:-1]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 86,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-0.6300681663889197"
+      ]
+     },
+     "execution_count": 86,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Weights of elements for the Engle-Granger portfolio\n",
+    "eg_cointegration_vectors.loc[0][1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 368,
+   "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>Value</th>\n",
+       "      <th>Significance level</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>99%</th>\n",
+       "      <td>-3.44350</td>\n",
+       "      <td>99%</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95%</th>\n",
+       "      <td>-2.86734</td>\n",
+       "      <td>95%</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>90%</th>\n",
+       "      <td>-2.56986</td>\n",
+       "      <td>90%</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       Value Significance level\n",
+       "99% -3.44350                99%\n",
+       "95% -2.86734                95%\n",
+       "90% -2.56986                90%"
+      ]
+     },
+     "execution_count": 368,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eg_adf=eg_adf.set_axis(['Value', 'Significance level'], axis=1, inplace=False)\n",
+    "eg_adf = eg_adf\n",
+    "eg_adf['Value'] = eg_adf['Value'].round(decimals=5)\n",
+    "eg_adf = eg_adf\n",
+    "eg_adf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 366,
+   "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>Value</th>\n",
+       "      <th>Significance level</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>99%</th>\n",
+       "      <td>-3.44342</td>\n",
+       "      <td>99%</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>95%</th>\n",
+       "      <td>-2.86730</td>\n",
+       "      <td>95%</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>90%</th>\n",
+       "      <td>-2.56984</td>\n",
+       "      <td>90%</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "       Value Significance level\n",
+       "99% -3.44342                99%\n",
+       "95% -2.86730                95%\n",
+       "90% -2.56984                90%"
+      ]
+     },
+     "execution_count": 366,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "eg_adf_2=eg_adf_2.set_axis(['Value', 'Significance level'], axis=1, inplace=False)\n",
+    "eg_adf_2 = eg_adf_2\n",
+    "eg_adf_2['Value'] = round(eg_adf_2['Value'],5)\n",
+    "eg_adf_2 = eg_adf_2\n",
+    "eg_adf_2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 315,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "GLD     0.613471\n",
+       "GDXJ   -0.386529\n",
+       "Name: 0, dtype: float64"
+      ]
+     },
+     "execution_count": 315,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Scaling weights so they sum up to 1\n",
+    "eg_scaled_vectors = eg_cointegration_vectors.loc[0] / abs(eg_cointegration_vectors.loc[0]).sum()\n",
+    "\n",
+    "eg_scaled_vectors"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 104,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Calculating portfolio values during the training period\n",
+    "eg_portfolio_returns = (train_three_elements_returns * eg_scaled_vectors * weights).sum(axis=1)\n",
+    "eg_portfolio_price = (eg_portfolio_returns + 1).cumprod()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 105,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 720x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plotting Engle-Granger portfolio price\n",
+    "eg_portfolio_price.plot(title='Engle-Granger portfolio price', figsize=(10,5));"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 143,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:__main__:Dash is running on http://127.0.0.1:8050/\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " * Serving Flask app \"__main__\" (lazy loading)\n",
+      " * Environment: production\n",
+      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
+      "   Use a production WSGI server instead.\n",
+      " * Debug mode: off\n"
+     ]
+    }
+   ],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "fig = go.Figure()\n",
+    "fig.add_trace(go.Scatter(x=eg_portfolio_price.index, y=eg_portfolio_price,\n",
+    "                    mode='lines', line=dict(color='darkturquoise')))\n",
+    "fig.update_layout(\n",
+    "    title=\"GLD/GDXJ portfolio price\",\n",
+    "    xaxis_title=\"Date\",\n",
+    "    yaxis_title=\"Price\",\n",
+    "    #     autosize=False,\n",
+    "    #     width=500,\n",
+    "         height=500,\n",
+    "    )\n",
+    "\n",
+    "fig.update_xaxes(rangeslider_visible=True)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    \n",
+    "     dcc.Graph(\n",
+    "        id='example-graph',\n",
+    "        figure=fig\n",
+    "        , style={'width':'90%', \n",
+    "                    'height':'90%',\n",
+    "                    'margin-top': 30,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "#                     'display':'inline-block'\n",
+    "                })  \n",
+    "\n",
+    "    \n",
+    "    \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 142,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:__main__:Dash is running on http://127.0.0.1:8050/\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " * Serving Flask app \"__main__\" (lazy loading)\n",
+      " * Environment: production\n",
+      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
+      "   Use a production WSGI server instead.\n",
+      " * Debug mode: off\n"
+     ]
+    }
+   ],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "fig = go.Figure()\n",
+    "fig.add_trace(go.Scatter(x=eg_portfolio_price.index, y=eg_portfolio_price,\n",
+    "                    mode='lines', line=dict(color='darkturquoise')))\n",
+    "fig.update_layout(\n",
+    "    title=\"GLD/GDXJ portfolio price\",\n",
+    "    xaxis_title=\"Date\",\n",
+    "    yaxis_title=\"Price\",\n",
+    "    #     autosize=False,\n",
+    "    #     width=500,\n",
+    "         height=500,\n",
+    "    )\n",
+    "\n",
+    "fig.update_xaxes(rangeslider_visible=True)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    \n",
+    "     dcc.Graph(\n",
+    "        id='example-graph',\n",
+    "        figure=fig\n",
+    "        , style={'width':'90%', \n",
+    "                    'height':'90%',\n",
+    "                    'margin-top': 30,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "#                     'display':'inline-block'\n",
+    "                })  \n",
+    "\n",
+    "    \n",
+    "    \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 130,
+   "metadata": {
+    "collapsed": true,
+    "jupyter": {
+     "outputs_hidden": true
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "INFO:__main__:Dash is running on http://127.0.0.1:8050/\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " * Serving Flask app \"__main__\" (lazy loading)\n",
+      " * Environment: production\n",
+      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
+      "   Use a production WSGI server instead.\n",
+      " * Debug mode: off\n"
+     ]
+    }
+   ],
+   "source": [
+    "external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']\n",
+    "\n",
+    "app = dash.Dash(__name__, external_stylesheets=external_stylesheets)\n",
+    "\n",
+    "fig = go.Figure()\n",
+    "fig.add_trace(go.Scatter(x=eg_portfolio_price.index, y=eg_portfolio_price,\n",
+    "                    mode='lines', line=dict(color='darkturquoise')))\n",
+    "fig.update_layout(\n",
+    "    title=\"GLD/GDXJ portfolio price\",\n",
+    "    xaxis_title=\"Date\",\n",
+    "    yaxis_title=\"Price\",\n",
+    "    #     autosize=False,\n",
+    "    #     width=500,\n",
+    "         height=500,\n",
+    "    )\n",
+    "\n",
+    "fig.update_xaxes(rangeslider_visible=True)\n",
+    "\n",
+    "app.layout = html.Div(children=[\n",
+    "    \n",
+    "    \n",
+    "     dcc.Graph(\n",
+    "        id='example-graph',\n",
+    "        figure=fig\n",
+    "        , style={'width':'90%', \n",
+    "                    'height':'90%',\n",
+    "                    'margin-top': 30,\n",
+    "                    'margin-rigt': 30, \n",
+    "#                     'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'left',\n",
+    "#                     'display':'inline-block'\n",
+    "                })  \n",
+    "\n",
+    "    \n",
+    "    \n",
+    "])\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Add stylized logo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 379,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      "Dash is running on http://127.0.0.1:8050/\n",
+      "\n",
+      " * Serving Flask app \"__main__\" (lazy loading)\n",
+      " * Environment: production\n",
+      "   WARNING: This is a development server. Do not use it in a production deployment.\n",
+      "   Use a production WSGI server instead.\n",
+      " * Debug mode: off\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      " * Running on http://127.0.0.1:8050/ (Press CTRL+C to quit)\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:19] \"\u001b[37mGET / HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:20] \"\u001b[37mGET /_dash-layout HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:20] \"\u001b[37mGET /_dash-dependencies HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:20] \"\u001b[37mGET /assets/LB_Hudson_Thames_ProductLogos_ArbitrageLab-01.png HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET / HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET /_dash-component-suites/dash_table/bundle.v4_11_2m1617880301.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET /_dash-component-suites/dash_renderer/polyfill@7.v1_9_0m1617880301.8.7.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET /_dash-component-suites/dash_renderer/prop-types@15.v1_9_0m1617880301.7.2.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET /_dash-component-suites/dash_html_components/dash_html_components.v1_1_2m1617880302.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET /_dash-component-suites/dash_renderer/react-dom@16.v1_9_0m1617880301.14.0.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET /_dash-component-suites/dash_renderer/react@16.v1_9_0m1617880301.14.0.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET /_dash-component-suites/dash_core_components/dash_core_components-shared.v1_15_0m1617880302.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET /_dash-component-suites/dash_core_components/dash_core_components.v1_15_0m1617880302.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:30] \"\u001b[37mGET /_dash-component-suites/dash_renderer/dash_renderer.v1_9_0m1617880301.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:31] \"\u001b[37mGET /_dash-layout HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:31] \"\u001b[37mGET /_dash-dependencies HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:31] \"\u001b[36mGET /assets/LB_Hudson_Thames_ProductLogos_ArbitrageLab-01.png HTTP/1.1\u001b[0m\" 304 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:51] \"\u001b[37mGET / HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-component-suites/dash_table/bundle.v4_11_2m1617880301.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-component-suites/dash_renderer/polyfill@7.v1_9_0m1617880301.8.7.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-component-suites/dash_renderer/prop-types@15.v1_9_0m1617880301.7.2.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-component-suites/dash_html_components/dash_html_components.v1_1_2m1617880302.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-component-suites/dash_renderer/react-dom@16.v1_9_0m1617880301.14.0.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-component-suites/dash_renderer/react@16.v1_9_0m1617880301.14.0.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-component-suites/dash_core_components/dash_core_components.v1_15_0m1617880302.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-component-suites/dash_core_components/dash_core_components-shared.v1_15_0m1617880302.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-component-suites/dash_renderer/dash_renderer.v1_9_0m1617880301.min.js HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-layout HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[37mGET /_dash-dependencies HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:28:52] \"\u001b[36mGET /assets/LB_Hudson_Thames_ProductLogos_ArbitrageLab-01.png HTTP/1.1\u001b[0m\" 304 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:29:23] \"\u001b[37mGET / HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:29:23] \"\u001b[37mGET /_dash-layout HTTP/1.1\u001b[0m\" 200 -\n",
+      "127.0.0.1 - - [15/Apr/2021 22:29:23] \"\u001b[37mGET /_dash-dependencies HTTP/1.1\u001b[0m\" 200 -\n"
+     ]
+    }
+   ],
+   "source": [
+    "app = dash.Dash(__name__)\n",
+    "\n",
+    "app.layout = html.Div(\n",
+    "    html.Img(src='assets/LB_Hudson_Thames_ProductLogos_ArbitrageLab-01.png', \n",
+    "             style={'width':'11%', \n",
+    "                    'height':'11%',\n",
+    "                    'margin-top': 30,\n",
+    "                    'margin-rigt': 30, \n",
+    "                    'vertical-align': 'top', \n",
+    "                    'horizontal-align': 'right',\n",
+    "                    'display':'inline-block'}))\n",
+    "\n",
+    "if __name__ == '__main__':\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Color\n",
+    "Munsell #0C9AAC\n",
+    "\n",
+    "Flame #DE612F\n",
+    "\n",
+    "Black #0B0D13\n",
+    "\n",
+    "Blue #072040\n",
+    "\n",
+    "Grey dark #949494\n",
+    "\n",
+    "Grey light #F2F3F4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "! pip install dash-bootstrap-components\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import required packages\n",
+    "import dash\n",
+    "import dash_table\n",
+    "import dash_core_components as dcc\n",
+    "import dash_html_components as html\n",
+    "import dash_bootstrap_components as dbc\n",
+    "import plotly.graph_objs as go\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "\n",
+    "# define figure creation function\n",
+    "def create_figure():\n",
+    "    N = 100\n",
+    "    x_min = 0\n",
+    "    x_max = 10\n",
+    "    y_min = 0\n",
+    "    y_max = 10\n",
+    "\n",
+    "    blue = '#6683f3'\n",
+    "    orange = '#ff9266'\n",
+    "    grey = '#e0e1f5'\n",
+    "    black = '#212121'\n",
+    "\n",
+    "    x = np.linspace(x_min, x_max, N)\n",
+    "    y = np.linspace(y_min, y_max, N)\n",
+    "    XX, YY = np.meshgrid(x, y)\n",
+    "\n",
+    "    Z1 = XX*2*YY/10\n",
+    "    Z2 = np.sin(XX)*YY**2\n",
+    "\n",
+    "    data = [go.Contour(z = Z1,\n",
+    "                       name = 'Z1',\n",
+    "                       contours_coloring = 'lines',\n",
+    "                       line_width = 2,\n",
+    "                       showscale = False,\n",
+    "                       showlegend = True,\n",
+    "                       colorscale = [[0, blue], [1, blue]],\n",
+    "                       ncontours = 11,\n",
+    "                       contours = dict(showlabels = True,\n",
+    "                                       labelformat = '.0f')),\n",
+    "\n",
+    "            go.Contour(z = Z2,\n",
+    "                       name = 'Z2',\n",
+    "                       contours_coloring = 'lines',\n",
+    "                       line_width = 2,\n",
+    "                       showscale = False,\n",
+    "                       showlegend = True,\n",
+    "                       colorscale = [[0, orange], [1, orange]],\n",
+    "                       ncontours = 21,\n",
+    "                       contours = dict(showlabels = True,\n",
+    "                                       labelformat = '.0f'))]\n",
+    "\n",
+    "    layout = go.Layout(plot_bgcolor = black,\n",
+    "                       hovermode = 'x unified')\n",
+    "\n",
+    "    figure = go.Figure(data = data, layout = layout)\n",
+    "\n",
+    "    figure.update_xaxes(title_text = 'X',\n",
+    "                        linewidth = 1,\n",
+    "                        nticks = 11,\n",
+    "                        gridwidth = 0.5,\n",
+    "                        gridcolor = grey,\n",
+    "                        tickformat = '.0f')\n",
+    "\n",
+    "    figure.update_yaxes(title_text = 'Y',\n",
+    "                        linewidth = 1,\n",
+    "                        nticks = 11,\n",
+    "                        gridwidth = 0.5,\n",
+    "                        gridcolor = grey,\n",
+    "                        tickformat = '.0f')\n",
+    "\n",
+    "    figure.update_layout(legend = dict(itemsizing = 'constant'), margin = dict(t=0, b=0, l=0, r=0))\n",
+    "\n",
+    "    return figure\n",
+    "\n",
+    "# define dataframe creation function\n",
+    "def create_dataframe():\n",
+    "    rows = 6\n",
+    "    df = pd.DataFrame(columns = list('ABCDEFGHIJ'))\n",
+    "    data = np.random.random(size = (rows, len(df.columns)))\n",
+    "\n",
+    "    for line in data:\n",
+    "        df = df.append(dict(zip(df.columns, line)), ignore_index=True)\n",
+    "\n",
+    "    return df\n",
+    "\n",
+    "\n",
+    "# call figure and dataframe functions\n",
+    "figure = create_figure()\n",
+    "df = create_dataframe()\n",
+    "\n",
+    "\n",
+    "# page layout\n",
+    "app = dash.Dash(external_stylesheets = [dbc.themes.BOOTSTRAP])\n",
+    "\n",
+    "app.layout = html.Div([\n",
+    "\n",
+    "    # first row\n",
+    "    html.Div(children=[\n",
+    "\n",
+    "        # first column of first row\n",
+    "        html.Div(children=[\n",
+    "\n",
+    "            dcc.RadioItems(id = 'radio-item-1',\n",
+    "                           options = [dict(label = 'option A', value = 'A'),\n",
+    "                                      dict(label = 'option B', value = 'B'),\n",
+    "                                      dict(label = 'option C', value = 'C')],\n",
+    "                            value = 'A',\n",
+    "                            labelStyle={'display': 'block'}),\n",
+    "\n",
+    "            html.P(id = 'text-1',\n",
+    "                   children = 'First paragraph'),\n",
+    "\n",
+    "        ], style={'display': 'inline-block', 'vertical-align': 'top', 'margin-left': '3vw', 'margin-top': '3vw'}),\n",
+    "\n",
+    "        # second column of first row\n",
+    "        html.Div(children=[\n",
+    "\n",
+    "            dcc.RadioItems(id = 'radio-item-2',\n",
+    "                       options = [dict(label = 'option 1', value = '1'),\n",
+    "                                  dict(label = 'option 2', value = '2'),\n",
+    "                                  dict(label = 'option 3', value = '3')],\n",
+    "                       value = '1',\n",
+    "                       labelStyle={'display': 'block'}),\n",
+    "\n",
+    "            html.P(id='text-2',\n",
+    "                   children='Second paragraph'),\n",
+    "\n",
+    "        ], style={'display': 'inline-block', 'vertical-align': 'top', 'margin-left': '3vw', 'margin-top': '3vw'}),\n",
+    "\n",
+    "        # third column of first row\n",
+    "        html.Div(children=[\n",
+    "\n",
+    "            html.Div(dcc.Graph(id = 'main-graph',\n",
+    "                               figure = figure)),\n",
+    "\n",
+    "        ], style={'display': 'inline-block', 'vertical-align': 'top', 'margin-left': '3vw', 'margin-top': '3vw'}),\n",
+    "\n",
+    "    ], className='row'),\n",
+    "\n",
+    "    # second row\n",
+    "    html.Div(children=[\n",
+    "\n",
+    "        html.Div(dash_table.DataTable(id = 'main-table',\n",
+    "                                      columns = [{\"name\": i, \"id\": i} for i in df.columns],\n",
+    "                                      data = df.to_dict('records'),\n",
+    "                                      style_table={'margin-left': '3vw', 'margin-top': '3vw'})),\n",
+    "\n",
+    "    ], className='row'),\n",
+    "\n",
+    "])\n",
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "    app.run_server()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ArbitrageLab",
+   "language": "python",
+   "name": "arbitragelab"
+  },
+  "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.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}