portfolio_return.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import style\n",
    "style.use('classic')\n",
    "import numpy as np\n",
    "import datetime as dt\n",
    "from datetime import timedelta\n",
    "import simulate\n",
    "from debt import Debt\n",
    "import math\n",
    "import subprocess\n",
    "\n",
    "pd.options.display.float_format = '{:20,.5f}'.format\n",
    "pd.set_option('display.max_rows', 800)\n",
    "pd.set_option('display.max_columns', 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "spx = pd.read_csv('^GSPC.csv', index_col=0)\n",
    "\n",
    "start = dt.date(2020, 1, 1)\n",
    "end = dt.date(2080, 1, 31)\n",
    "\n",
    "Market = simulate.Market(spx.iloc[-7500:, -2], start, end)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration:      1,   Func. Count:      9,   Neg. LLF: 219034.93771858286\n",
      "Iteration:      2,   Func. Count:     21,   Neg. LLF: 262807.76526202995\n",
      "Iteration:      3,   Func. Count:     31,   Neg. LLF: 181565.29570811347\n",
      "Iteration:      4,   Func. Count:     40,   Neg. LLF: 2606331.78638033\n",
      "Iteration:      5,   Func. Count:     51,   Neg. LLF: 9680.033867601682\n",
      "Iteration:      6,   Func. Count:     60,   Neg. LLF: 446230.4465759386\n",
      "Iteration:      7,   Func. Count:     71,   Neg. LLF: 9579.92531052516\n",
      "Iteration:      8,   Func. Count:     80,   Neg. LLF: 9669.387750022546\n",
      "Iteration:      9,   Func. Count:     89,   Neg. LLF: 9570.089646588482\n",
      "Iteration:     10,   Func. Count:     98,   Neg. LLF: 12905.495278355076\n",
      "Iteration:     11,   Func. Count:    107,   Neg. LLF: 9564.312001905633\n",
      "Iteration:     12,   Func. Count:    115,   Neg. LLF: 9564.315592701609\n",
      "Iteration:     13,   Func. Count:    124,   Neg. LLF: 9564.307763835614\n",
      "Iteration:     14,   Func. Count:    133,   Neg. LLF: 9564.306592368332\n",
      "Iteration:     15,   Func. Count:    140,   Neg. LLF: 9564.306592368339\n",
      "Optimization terminated successfully    (Exit mode 0)\n",
      "            Current function value: 9564.306592368332\n",
      "            Iterations: 15\n",
      "            Function evaluations: 140\n",
      "            Gradient evaluations: 15\n",
      "mu                      0.03107\n",
      "omega                   0.01541\n",
      "alpha[1]                0.00000\n",
      "gamma[1]                0.18312\n",
      "beta[1]                 0.89658\n",
      "nu                      7.08545\n",
      "lambda                 -0.10478\n",
      "Name: params, dtype: float64\n",
      "                         Constant Mean - GJR-GARCH Model Results                         \n",
      "=========================================================================================\n",
      "Dep. Variable:                         Adj Close   R-squared:                       0.000\n",
      "Mean Model:                        Constant Mean   Adj. R-squared:                  0.000\n",
      "Vol Model:                             GJR-GARCH   Log-Likelihood:               -9564.31\n",
      "Distribution:      Standardized Skew Student's t   AIC:                           19142.6\n",
      "Method:                       Maximum Likelihood   BIC:                           19191.1\n",
      "                                                   No. Observations:                 7499\n",
      "Date:                           Thu, Apr 15 2021   Df Residuals:                     7498\n",
      "Time:                                   10:17:15   Df Model:                            1\n",
      "                                 Mean Model                                 \n",
      "============================================================================\n",
      "                 coef    std err          t      P>|t|      95.0% Conf. Int.\n",
      "----------------------------------------------------------------------------\n",
      "mu             0.0311  8.616e-03      3.606  3.106e-04 [1.419e-02,4.796e-02]\n",
      "                               Volatility Model                              \n",
      "=============================================================================\n",
      "                 coef    std err          t      P>|t|       95.0% Conf. Int.\n",
      "-----------------------------------------------------------------------------\n",
      "omega          0.0154  2.621e-03      5.879  4.123e-09  [1.027e-02,2.054e-02]\n",
      "alpha[1]   3.5049e-12  6.722e-03  5.214e-10      1.000 [-1.317e-02,1.317e-02]\n",
      "gamma[1]       0.1831  1.872e-02      9.779  1.379e-22      [  0.146,  0.220]\n",
      "beta[1]        0.8966  1.079e-02     83.066      0.000      [  0.875,  0.918]\n",
      "                                Distribution                               \n",
      "===========================================================================\n",
      "                 coef    std err          t      P>|t|     95.0% Conf. Int.\n",
      "---------------------------------------------------------------------------\n",
      "nu             7.0855      0.588     12.052  1.898e-33    [  5.933,  8.238]\n",
      "lambda        -0.1048  1.468e-02     -7.140  9.324e-13 [ -0.134,-7.602e-02]\n",
      "===========================================================================\n",
      "\n",
      "Covariance estimator: robust\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>data</th>\n",
       "      <th>volatility</th>\n",
       "      <th>errors</th>\n",
       "      <th>Price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2020-01-01</th>\n",
       "      <td>0.02370</td>\n",
       "      <td>1.80268</td>\n",
       "      <td>2.33907</td>\n",
       "      <td>100.00000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-02</th>\n",
       "      <td>-0.01052</td>\n",
       "      <td>1.71143</td>\n",
       "      <td>-1.08275</td>\n",
       "      <td>98.94832</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-03</th>\n",
       "      <td>-0.00487</td>\n",
       "      <td>1.69002</td>\n",
       "      <td>-0.51779</td>\n",
       "      <td>98.46673</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-06</th>\n",
       "      <td>-0.01592</td>\n",
       "      <td>1.62027</td>\n",
       "      <td>-1.62311</td>\n",
       "      <td>96.89910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-07</th>\n",
       "      <td>0.01835</td>\n",
       "      <td>1.68867</td>\n",
       "      <td>1.80435</td>\n",
       "      <td>98.67761</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2080-01-25</th>\n",
       "      <td>-0.00617</td>\n",
       "      <td>0.69277</td>\n",
       "      <td>-0.64759</td>\n",
       "      <td>5,062.06604</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2080-01-26</th>\n",
       "      <td>-0.00028</td>\n",
       "      <td>0.72284</td>\n",
       "      <td>-0.05947</td>\n",
       "      <td>5,060.62855</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2080-01-29</th>\n",
       "      <td>-0.00343</td>\n",
       "      <td>0.69607</td>\n",
       "      <td>-0.37457</td>\n",
       "      <td>5,043.24565</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2080-01-30</th>\n",
       "      <td>0.00382</td>\n",
       "      <td>0.68957</td>\n",
       "      <td>0.35085</td>\n",
       "      <td>5,062.50699</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2080-01-31</th>\n",
       "      <td>0.00126</td>\n",
       "      <td>0.66463</td>\n",
       "      <td>0.09460</td>\n",
       "      <td>5,068.86943</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>15676 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                           data           volatility               errors  \\\n",
       "2020-01-01              0.02370              1.80268              2.33907   \n",
       "2020-01-02             -0.01052              1.71143             -1.08275   \n",
       "2020-01-03             -0.00487              1.69002             -0.51779   \n",
       "2020-01-06             -0.01592              1.62027             -1.62311   \n",
       "2020-01-07              0.01835              1.68867              1.80435   \n",
       "...                         ...                  ...                  ...   \n",
       "2080-01-25             -0.00617              0.69277             -0.64759   \n",
       "2080-01-26             -0.00028              0.72284             -0.05947   \n",
       "2080-01-29             -0.00343              0.69607             -0.37457   \n",
       "2080-01-30              0.00382              0.68957              0.35085   \n",
       "2080-01-31              0.00126              0.66463              0.09460   \n",
       "\n",
       "                          Price  \n",
       "2020-01-01            100.00000  \n",
       "2020-01-02             98.94832  \n",
       "2020-01-03             98.46673  \n",
       "2020-01-06             96.89910  \n",
       "2020-01-07             98.67761  \n",
       "...                         ...  \n",
       "2080-01-25          5,062.06604  \n",
       "2080-01-26          5,060.62855  \n",
       "2080-01-29          5,043.24565  \n",
       "2080-01-30          5,062.50699  \n",
       "2080-01-31          5,068.86943  \n",
       "\n",
       "[15676 rows x 4 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Market.garch(log=False)\n",
    "#plt.plot(Market.garch(log=False)['Price'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checking stability of garch model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empirical_mu = ((spx.iloc[-7500:, -2][-1]/spx.iloc[-7500:, -2][0])**(1/7500)-1)*100\n",
    "market = Market.garch(log=False, mu_override = empirical_mu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting up functions to calculate performance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def determine_investment(phase, pv_u, tv_u, s, td, pi_rf, dst, g, period):\n",
    "    \n",
    "    # returns cash, new_equity, new_debt\n",
    "    \n",
    "    if phase == 1:\n",
    "        # Check if gearing cap has been reached\n",
    "        equity = tv_u+s-td\n",
    "        if td > (equity*g):\n",
    "            new_debt = 0\n",
    "        else:\n",
    "            #desired_debt = min(g*(equity+s), dst-equity)\n",
    "            #new_debt = max(0, desired_debt-td)\n",
    "            new_debt = nd(g, s, tv_u, td, dst, period)\n",
    "        return 0, s, new_debt\n",
    "    \n",
    "    if phase == 2: \n",
    "        stocks_sold = max(pv_u-dst, 0)\n",
    "        debt_repayment = min(td, s + stocks_sold)\n",
    "        repayment_left = debt_repayment\n",
    "        \n",
    "        if 'Nordnet' in debt_available.keys():\n",
    "            repayment = min(debt_repayment, debt_available['Nordnet'].debt_amount)\n",
    "            debt_available['Nordnet'].prepayment(repayment)\n",
    "            repayment_left = debt_repayment - repayment\n",
    "            \n",
    "        if 'SU' in debt_available.keys():\n",
    "            debt_available['SU'].prepayment(repayment_left)\n",
    "            \n",
    "        leftover_savings = max(s-debt_repayment - stocks_sold, 0)\n",
    "        return 0, leftover_savings, -debt_repayment\n",
    "    \n",
    "    if phase == 3:\n",
    "        return 0, s, 0\n",
    "    \n",
    "    if phase == 4:\n",
    "        desired_cash = (1-pi_rf)*(tv_u+s)\n",
    "        desired_savings = (pi_rf)*(tv_u+s)\n",
    "        change_in_stock = desired_savings - pv_u\n",
    "        return desired_cash, change_in_stock, 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function assumes monthly periods\n",
    "\n",
    "def nd(g, s, tv_u, td, dst, period):\n",
    "    \n",
    "    equity = tv_u+s-td\n",
    "    total_desired_debt = min(g/(g+1)*dst, equity*g)\n",
    "    remaning_debt_needed = max(0, total_desired_debt - td)\n",
    "    \n",
    "    SU_amount, Nordnet_amount = 0, 0\n",
    "    \n",
    "    \n",
    "    if period <= 60 and 'SU' in debt_available.keys():\n",
    "        # Has SU already been taken?\n",
    "        SU_amount = min(3234, remaning_debt_needed)\n",
    "        debt_available['SU'].add_debt(SU_amount)\n",
    "\n",
    "        remaning_debt_needed - SU_amount\n",
    "\n",
    "    if 'Nordnet' in debt_available.keys():\n",
    "        # Has Nordnet already been taken?\n",
    "        Nordnet_amount = min(max(0, g*equity), remaning_debt_needed)\n",
    "        debt_available['Nordnet'].add_debt(Nordnet_amount)\n",
    "\n",
    "\n",
    "    return SU_amount + Nordnet_amount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def interest():\n",
    "    interest_bill = 0\n",
    "    for debt in debt_available.keys():\n",
    "        try:\n",
    "            interest_bill += debt_available[debt].calculate_interest()\n",
    "        except:\n",
    "            pass\n",
    "        \n",
    "    return interest_bill"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def phase_check(phase, pi_rf, pi_rm, pi_hat, td):\n",
    "    if phase == 4:\n",
    "        return 4\n",
    "    \n",
    "    if td > 0:\n",
    "        #has target not been reached?\n",
    "        if pi_hat < pi_rm and phase <= 1:\n",
    "            return 1\n",
    "        else:\n",
    "            # if target has been reached once and debt remains, stay in phase 2\n",
    "            return 2\n",
    "    \n",
    "    #if target has been reached and no debt remains\n",
    "    #is the value still above the target?\n",
    "    if pi_hat < pi_rf:\n",
    "        return 3\n",
    "    else:\n",
    "        return 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calc_pi(gamma, sigma, mr, rate, cost = 0):\n",
    "    return (mr - cost - rate)/(gamma * sigma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#def (gearing_cap, su, ):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Combining with investment profile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_return(savings, market_returns, gearing_cap, pi_rf, pi_rm, rf):\n",
    "    \n",
    "    wipeout = False\n",
    "    \n",
    "    # Running controls\n",
    "    assert len(savings) == len(market), 'Investment plan should be same no of periods as market' \n",
    "    \n",
    "    # Setting up constants and dataframe for calculation\n",
    "    ses = savings.sum()     # Possibly add more sophisticated discounting\n",
    "    ist = pi_rm*ses\n",
    "    columns = ['period', 'savings', 'cash', 'new_equity', 'new_debt', 'total_debt', 'nip', 'pv_p', \n",
    "               'interest', 'market_returns', 'pv_u', 'tv_u', 'equity', 'dst', 'phase', 'pi_hat', 'ses', 'g_hat', 'SU_debt', 'Nordnet_debt']\n",
    "    \n",
    "    pp = pd.DataFrame(np.zeros((len(savings), len(columns))), columns = columns)\n",
    "        \n",
    "    pp['ses'] = ses\n",
    "    pp['period'] = range(len(savings))\n",
    "    pp['market_returns'] = market_returns\n",
    "    pp['savings'] = savings\n",
    "    pp.loc[0, 'market_returns'] = 0\n",
    "    \n",
    "    \n",
    "    # Initializing debt objects\n",
    "    if 'SU' in debt_available.keys():\n",
    "        debt_available['SU'] = Debt(rate_structure = [[0, 0, 0.04]], rate_structure_type='relative', initial_debt = 0)\n",
    "    if 'Nordnet' in debt_available.keys(): \n",
    "        debt_available['Nordnet'] = Debt(rate_structure = [[0, .4, 0.02], [.4, .6, 0.03], [.6, 0, 0.07]], rate_structure_type='relative', initial_debt = 0)\n",
    "\n",
    "                      \n",
    "    # Period 0 primo\n",
    "    pp.loc[0, 'cash'] = 0\n",
    "    pp.loc[0, 'new_equity'] = pp.loc[0, 'savings']\n",
    "    pp.loc[0, 'new_debt'] = pp.loc[0, 'new_equity']*gearing_cap\n",
    "    pp.loc[0, 'total_debt'] = pp.loc[0, 'new_debt']\n",
    "    pp.loc[0, 'SU_debt'] = min(pp.loc[0, 'new_debt'], 3248)\n",
    "    pp.loc[0, 'Nordnet_debt'] = max(0, pp.loc[0, 'new_debt'] - 3248)\n",
    "    pp.loc[0, 'nip'] = pp.loc[0, 'new_debt'] + pp.loc[0, 'new_equity']\n",
    "    pp.loc[0, 'pv_p'] = pp.loc[0, 'nip']\n",
    "    pp.loc[0, 'pi_hat'] =  pp.loc[0, 'pv_p']/ses\n",
    "    \n",
    "    # Period 0 ultimo\n",
    "    pp.loc[0, 'interest'] = pp.loc[0, 'new_debt']*max(interest(), 0)                   \n",
    "    pp.loc[0, 'pv_u'] = pp.loc[0, 'pv_p']                 \n",
    "    pp.loc[0, 'tv_u'] = pp.loc[0, 'pv_u'] + pp.loc[0, 'cash']\n",
    "    pp.loc[0, 'equity'] = pp.loc[0, 'tv_u'] - pp.loc[0, 'total_debt']\n",
    "    pp.loc[0, 'dst'] = ist\n",
    "    pp.loc[0, 'phase'] = 1\n",
    "    \n",
    "              \n",
    "    \n",
    "    # Looping over all reminaning periods\n",
    "    for i in range(1, len(savings)):\n",
    " \n",
    "        # Period t > 0 primo\n",
    "        if not(pp.loc[i-1, 'tv_u'] <= 0 and (pp.loc[i-1, 'interest'] > pp.loc[i, 'savings'])):\n",
    "\n",
    "            pp.loc[i, 'cash'] = pp.loc[i-1, 'cash']*(1+rf) \n",
    "            pp.loc[i, 'cash'], pp.loc[i, 'new_equity'], pp.loc[i, 'new_debt'] = determine_investment(\n",
    "                                                                                         pp.loc[i-1, 'phase'], pp.loc[i-1, 'pv_u'], \n",
    "                                                                                         pp.loc[i-1, 'tv_u'], pp.loc[i, 'savings'], pp.loc[i-1, 'total_debt'],\n",
    "                                                                                         pi_rf, pp.loc[i-1, 'dst'], gearing_cap, pp.loc[i, 'period'])\n",
    "\n",
    "            if 'SU' in debt_available.keys():\n",
    "                pp.loc[i, 'SU_debt'] = debt_available['SU'].debt_amount\n",
    "            if 'Nordnet' in debt_available.keys():\n",
    "                pp.loc[i, 'Nordnet_debt'] = debt_available['Nordnet'].debt_amount\n",
    "                \n",
    "            pp.loc[i, 'total_debt'] = pp.loc[i-1, 'total_debt'] + pp.loc[i, 'new_debt']\n",
    "            pp.loc[i, 'nip'] = pp.loc[i, 'new_equity'] + max(0, pp.loc[i, 'new_debt'])\n",
    "            pp.loc[i, 'pv_p'] = pp.loc[i-1, 'pv_u'] + pp.loc[i, 'nip']        \n",
    "\n",
    "\n",
    "            # Period t > 0 ultimo   \n",
    "            if pp.loc[i, 'period'] == 60 and 'SU' in debt_available.keys():\n",
    "                    debt_available['SU'].rate_structure = [[0, 0, 0.01]]\n",
    "    \n",
    "            pp.loc[i, 'interest'] = max(interest(), 0)\n",
    "            pp.loc[i, 'pv_u'] = pp.loc[i, 'pv_p']*(1+pp.loc[i, 'market_returns'])-pp.loc[i, 'interest']\n",
    "            pp.loc[i, 'tv_u'] = pp.loc[i, 'pv_u'] + pp.loc[i, 'cash']\n",
    "            pp.loc[i, 'equity'] =  pp.loc[i, 'tv_u'] - pp.loc[i, 'total_debt']\n",
    "            pp.loc[i, 'pi_hat'] = min(pp.loc[i, 'pv_u']/ses, pp.loc[i, 'pv_u']/pp.loc[i, 'tv_u'])\n",
    "\n",
    "            pp.loc[i, 'phase'] = phase_check(pp.loc[i-1, 'phase'], pi_rf, pi_rm, pp.loc[i, 'pi_hat'], pp.loc[i, 'total_debt'])\n",
    "            target_pi = pi_rm if pp.loc[i-1, 'phase'] < 3 else pi_rf\n",
    "            pp.loc[i, 'dst'] = max(pp.loc[i, 'tv_u']*target_pi, ist)  # Moving stock target\n",
    "            #pp.loc[i, 'dst'] = max(pp.loc[i-1, 'dst'], max(pp.loc[i, 'tv_u']*target_pi, ist))  # Locked stock target at highest previous position       \n",
    "       \n",
    "        else:\n",
    "            wipeout = True\n",
    "            print('Warning: Fatal wipeout')\n",
    "\n",
    "            text = 'Advarsel: Din portefølje er braget ned og er intet værd. Nuværende gæld er på ' + str(pp.loc[i-1, 'total_debt']) \n",
    "            speech = gTTS(text=text, lang='da', slow=False)\n",
    "            speech.save(\"voice.mp3\")\n",
    "            #return_code = subprocess.call([\"afplay\", 'voice.mp3'])\n",
    "            #playsound('voice.mp3')\n",
    "            \n",
    "            pp.loc[i:, ['savings', 'cash', 'new_equity', 'new_debt', 'nip', 'pv_p', 'interest', 'pv_u', 'tv_u', 'pi_hat', 'g_hat']] = 0\n",
    "            pp.loc[i:, 'total_debt'] = pp.loc[i-1,'total_debt']\n",
    "            pp.loc[i:, 'SU_debt'] = pp.loc[i-1, 'SU_debt']\n",
    "            pp.loc[i:, 'Nordnet_debt'] = pp.loc[i-1, 'Nordnet_debt']\n",
    "            pp.loc[i:, 'equity'] = pp.loc[i-1, 'equity']\n",
    "            pp.loc[i:, 'dst'] = pp.loc[i-1, 'dst']\n",
    "            pp.loc[i:, 'phase'] = pp.loc[i-1, 'phase']\n",
    "            break\n",
    "    \n",
    "    pp['g_hat'] = pp['total_debt']/pp['equity']\n",
    "    \n",
    "    return pp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate100return(savings, market_returns):\n",
    "     # Running controls\n",
    "    assert len(savings) == len(market), 'Investment plan should be same no of periods as market' \n",
    "    \n",
    "    columns = ['period', 'savings', 'pv_p', 'market_returns', 'tv_u']\n",
    "        \n",
    "    pp = pd.DataFrame(np.empty((len(savings), len(columns))), columns = columns)\n",
    "    \n",
    "    pp['period'] = range(len(savings))\n",
    "    pp['market_returns'] = market_returns\n",
    "    pp['savings'] = savings\n",
    "    pp.loc[0, 'market_returns'] = 0\n",
    "    pp.loc[0, 'pv_p'] = pp.loc[0, 'savings']\n",
    "    pp.loc[0, 'tv_u'] = pp.loc[0, 'savings']\n",
    "    \n",
    "    for i in range(1, len(savings)):\n",
    " \n",
    "        # Period t > 0 primo\n",
    "        pp.loc[i, 'pv_p'] = pp.loc[i-1, 'tv_u'] + pp.loc[i, 'savings']        \n",
    "        \n",
    "        # Period t > 0 ultimo\n",
    "        pp.loc[i, 'tv_u'] = pp.loc[i, 'pv_p']*(1+pp.loc[i, 'market_returns'])\n",
    "    \n",
    "    return pp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate9050return(savings, market_returns, rf):\n",
    "    # Strategy where 90% of value is initially invested in stocks, rest in risk free asset\n",
    "    # Ratio of stocks falls linearly to 50% by age 65 and stays there\n",
    "    \n",
    "    # Running controls\n",
    "    assert len(savings) == len(market), 'Investment plan should be same no of periods as market' \n",
    "    \n",
    "    columns = ['period',  'savings', 'cash', 'pv_p', 'market_returns', 'pv_u', 'tv_u', 'ratio']\n",
    "        \n",
    "    pp = pd.DataFrame(np.empty((len(savings), len(columns))), columns = columns)\n",
    "\n",
    "    pp['period'] = range(len(savings))\n",
    "    pp['market_returns'] = market_returns\n",
    "    pp['savings'] = savings\n",
    "    pp.loc[0, 'market_returns'] = 0\n",
    "    pp.loc[0, 'pv_p'] = pp.loc[0, 'savings']*0.9\n",
    "    pp.loc[0, 'cash'] = pp.loc[0, 'savings']*0.1\n",
    "    pp.loc[0, 'pv_u'] = pp.loc[0, 'pv_p']    \n",
    "    pp.loc[0, 'tv_u'] = pp.loc[0, 'savings']\n",
    "    pp.loc[0, 'ratio'] = 90\n",
    "    \n",
    "    for i in range(1, len(savings)):\n",
    "        ratio = max(90 - pp.loc[i, 'period']/12, 50)\n",
    "        pp.loc[i, 'ratio'] = ratio\n",
    "        \n",
    "        # Period t > 0 primo\n",
    "        pp.loc[i, 'pv_p'] = pp.loc[i-1, 'pv_u'] + pp.loc[i, 'savings']*(ratio/100)        \n",
    "        pp.loc[i, 'cash'] = pp.loc[i-1, 'cash']*(1+rf) + pp.loc[i, 'savings']*(1-ratio/100)\n",
    "        \n",
    "        # Period t > 0 ultimo\n",
    "        pp.loc[i, 'pv_u'] = pp.loc[i, 'pv_p']*(1+pp.loc[i, 'market_returns'])\n",
    "        pp.loc[i, 'tv_u'] = pp.loc[i, 'pv_u'] + pp.loc[i, 'cash']\n",
    "    \n",
    "    return pp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "savings_year = pd.read_csv('investment_plan_year.csv', sep=';', index_col=0)\n",
    "savings_year.index = pd.to_datetime(savings_year.index, format='%Y')\n",
    "savings_month = (savings_year.resample('BMS').pad()/12)['Earnings'].values\n",
    "savings_year = savings_year['Earnings'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "yearly_rf = 0.015\n",
    "yearly_rm = 0.04  # Weighted average of margin rates\n",
    "\n",
    "# Set period\n",
    "period = 'M'\n",
    "\n",
    "\n",
    "if period == 'M':\n",
    "    investments = savings_month*0.05\n",
    "    rf = math.exp(yearly_rf/12)-1\n",
    "    rm = math.exp(yearly_rm/12)-1\n",
    "    freq = 'BMS'\n",
    "else:\n",
    "    investments = savings_year*0.05\n",
    "    rf = yearly_rf\n",
    "    rm = yearly_rm\n",
    "    freq = 'BYS'\n",
    "\n",
    "\n",
    "global debt_available\n",
    "debt_available = {'SU': \"\", 'Nordnet': \"\"}\n",
    "gamma = 2.5\n",
    "sigma = Market.yearly.pct_change().std()**2\n",
    "mr = (Market.yearly[-1]/Market.yearly[0])**(1/len(Market.yearly))-1\n",
    "\n",
    "\n",
    "pi_rf = calc_pi(gamma, sigma, mr, yearly_rf, cost = 0)\n",
    "pi_rm = calc_pi(gamma, sigma, mr, yearly_rm, cost = 0)\n",
    "\n",
    "print('pi_rf', pi_rf, 'pi_rm', pi_rm)\n",
    "    \n",
    "#market = Market.draw(random_state = 16, freq=period).asfreq(freq, 'pad')\n",
    "#market = Market.norm_innovations(random_state = 6969, freq=period).asfreq(freq, 'pad')\n",
    "#market = Market.t_innovations(random_state = 6969, freq=period).asfreq(freq, 'pad')\n",
    "market = Market.garch(log = False, random_state = 6229, mu_override = 0.030800266141550736).asfreq(freq, 'pad')\n",
    "\n",
    "      \n",
    "port = calculate_return(investments, market['Price'].pct_change().values, 10, pi_rf, pi_rm, rf)\n",
    "port100 = calculate100return(investments, market['Price'].pct_change().values)\n",
    "port9050 = calculate9050return(investments, market['Price'].pct_change().values, rf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize = (15, 10))\n",
    "vars_to_plot = ['cash', 'total_debt', 'tv_u', '100tv_u', '9050tv_u']\n",
    "port['100tv_u'] = port100['tv_u']\n",
    "port['9050tv_u'] = port9050['tv_u']\n",
    "ax.plot(port.loc[0:200 ,vars_to_plot], linewidth = 2)\n",
    "ax.plot(port.loc[:200, 'dst'], linestyle=\"--\", color=\"black\", alpha = .5)\n",
    "#ax.set_yscale('log')\n",
    "vars_to_plot.append('dst')\n",
    "ax.legend(vars_to_plot, loc = 'upper left', frameon=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(port.loc[:, ['Nordnet_debt', 'SU_debt']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(port.loc[:, ['g_hat', 'pi_hat']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "columns = ['period', 'savings', 'cash', 'new_equity', 'new_debt', 'total_debt', 'nip', 'pv_p', \n",
    "               'interest', 'market_returns', 'pv_u', 'tv_u', 'dst', 'phase', 'pi_hat', 'ses', 'g_hat']\n",
    "    \n",
    "plt.bar(x = port['period'], height = port['phase'])\n",
    "#plt.xlim([0, 60])\n",
    "\n",
    "#plt.bar(x=port.loc[0:100, 'period'], height=port.loc[0:100, 'market_returns'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Characteristics of strategies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "std = port.loc[:, ['tv_u', '100tv_u', '9050tv_u']].pct_change().std()\n",
    "\n",
    "horizon = Market.years-1\n",
    "mean_return = (port.loc[horizon, ['tv_u', '100tv_u', '9050tv_u']]/port.loc[0, ['tv_u', '100tv_u', '9050tv_u']])**(1/horizon)-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sharpe = mean_return/std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sharpe"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Testing many markets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sim_market(seed):\n",
    "    returns = []\n",
    "    print(seed)\n",
    "    market = Market.garch(random_state = seed).asfreq(freq, 'pad')\n",
    "    port = calculate_return(investments, market['Price'].pct_change().values, 1, pi_rf, pi_rm, rf, rm)\n",
    "    port100 = calculate100return(investments, market['Price'].pct_change().values)\n",
    "    port9050 = calculate9050return(investments, market['Price'].pct_change().values, rf)\n",
    "    port['100tv_u'] = port100['tv_u']\n",
    "    port['9050tv_u'] = port9050['tv_u']\n",
    "    returns.append(port.loc[Market.years-1, ['tv_u', '100tv_u', '9050tv_u']].values)\n",
    "    return returns\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import concurrent\n",
    "from multiprocessing import Pool\n",
    "yearly_rf = 0.02\n",
    "yearly_rm = 0.03\n",
    "\n",
    "# Set period\n",
    "period = 'Y'\n",
    "\n",
    "\n",
    "if period == 'M':\n",
    "    investments = savings_month*0.05\n",
    "    rf = yearly_rf/12\n",
    "    rm = yearly_rm/12\n",
    "    freq = 'BMS'\n",
    "else:\n",
    "    investments = savings_year*0.05\n",
    "    rf = yearly_rf\n",
    "    rm = yearly_rm\n",
    "    freq = 'BYS'\n",
    "\n",
    "\n",
    "gamma = 1.5\n",
    "sigma = 0.20**2\n",
    "mr = 0.07\n",
    "\n",
    "pi_rf = calc_pi(gamma, sigma, mr, yearly_rf, cost = 0)\n",
    "pi_rm = calc_pi(gamma, sigma, mr, yearly_rm, cost = 0)\n",
    "\n",
    "returns = []\n",
    "\n",
    "\n",
    "\n",
    "seeds_to_sim = list(range(100))\n",
    "\n",
    "# multiprocessing\n",
    "p = Pool()\n",
    "\n",
    "# saving the restaurant information in a variable\n",
    "res = p.apply(sim_market, seeds_to_sim)\n",
    "\n",
    "p.close()\n",
    "p.join()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "returns = pd.DataFrame(returns, columns = ['tv_u', '100tv_u', '9050tv_u'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize = (15, 15))\n",
    "vars_to_plot = ['9050tv_u', '100tv_u', 'tv_u']\n",
    "\n",
    "bin_num = 20\n",
    "cum = True\n",
    "alpha = 0.7\n",
    "bin_width = 5e6\n",
    "max_return = 3e8\n",
    "\n",
    "ax.hist(x = returns['9050tv_u'], bins = int(returns['9050tv_u'].max()/bin_width), cumulative = cum, alpha = alpha)\n",
    "ax.hist(x = returns['100tv_u'], bins = int(returns['100tv_u'].max()/bin_width), cumulative = cum, alpha = alpha)\n",
    "ax.hist(x = returns['tv_u'], bins = int(returns['tv_u'].max()/bin_width), cumulative = cum, alpha = alpha)\n",
    "\n",
    "\n",
    "\n",
    "ax.set_xlim([0, max_return])\n",
    "ax.legend(vars_to_plot)\n",
    "#vars_to_plot.append('dst')\n",
    "#ax.legend(vars_to_plot, loc = 'upper left', frameon=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}