Vayner Box.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mean-Variance Optimisation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\HP\\Anaconda3\\lib\\site-packages\\statsmodels\\tools\\_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
      "  import pandas.util.testing as tm\n"
     ]
    }
   ],
   "source": [
    "# Import the required libraries and packages\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import seaborn as sns\n",
    "import itertools\n",
    "import math\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "import datetime as dt\n",
    "from datetime import datetime\n",
    "from scipy import stats\n",
    "from scipy.stats import norm\n",
    "import statsmodels.api as sm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# read the datasets into the jupyter notebook\n",
    "\n",
    "fund_prices = pd.read_csv(r'C:\\Users\\HP\\Python University\\fund_prices (version 1).csv')\n",
    "axa_mmf_ = pd.read_csv(r'C:\\Users\\HP\\Python University\\axa_mmf1.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "fund_prices['Date'] = pd.to_datetime(fund_prices.Date, format = '%Y-%m-%d') \n",
    "axa_mmf_['Date'] = pd.to_datetime(axa_mmf_.Date, format = '%Y-%m-%d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "axa_mmf_['AXA Money Market Fund Yield'] = (1 + axa_mmf_['AXA Money Market Fund Yield']) ** (1/365) - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "axa_mmf_['month year'] = axa_mmf_['Date'].apply(lambda x: x.strftime('%Y-%m'))\n",
    "axa_mmf_ = axa_mmf_.drop(columns = ['Date'], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "axa_mmf_ = axa_mmf_.groupby('month year')['AXA Money Market Fund Yield'].sum().reset_index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monthly Returns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "fund_prices = fund_prices.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extract some date information\n",
    "\n",
    "fund_prices['year'] = fund_prices['Date'].dt.year\n",
    "fund_prices['month'] = fund_prices['Date'].dt.month\n",
    "fund_prices['day'] = fund_prices['Date'].dt.day\n",
    "fund_prices['day of month'] = fund_prices['Date'].dt.daysinmonth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_day28 = fund_prices[(fund_prices['day'] == 1) & (fund_prices['day of month'] == 28)]\n",
    "last_day28 = fund_prices[(fund_prices['day'] == 28) & (fund_prices['day of month'] == 28)]\n",
    "first_day30 = fund_prices[(fund_prices['day'] == 1) & (fund_prices['day of month'] == 30)]\n",
    "last_day30 = fund_prices[(fund_prices['day'] == 30) & (fund_prices['day of month'] == 30)]\n",
    "first_day31 = fund_prices[(fund_prices['day'] == 1) & (fund_prices['day of month'] == 31)]\n",
    "last_day31 = fund_prices[(fund_prices['day'] == 31) & (fund_prices['day of month'] == 31)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_prices = pd.concat([first_day28, last_day28, first_day30, last_day30, \n",
    "                        first_day31, last_day31], axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_prices['month year'] = new_prices['Date'].apply(lambda x: x.strftime('%Y-%m'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_prices = new_prices.sort_index(ascending = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_returns = new_prices['Stanbic ETF 30'].div(new_prices.groupby('month year')['Stanbic ETF 30'].shift(1)) - 1\n",
    "stb_abs_returns = new_prices['Stanbic Absolute Fund'].div(new_prices.groupby('month year')['Stanbic Absolute Fund'].shift(1)) - 1\n",
    "stb_gtd_returns = new_prices['Stanbic Guaranteed Income Fund'].div(new_prices.groupby('month year')['Stanbic Guaranteed Income Fund'].shift(1)) - 1\n",
    "stb_euro_returns = new_prices['Stanbic Eurobond Fund'].div(new_prices.groupby('month year')['Stanbic Eurobond Fund'].shift(1)) - 1\n",
    "fbn_euro_returns = new_prices['FBN Eurobond Fund'].div(new_prices.groupby('month year')['FBN Eurobond Fund'].shift(1)) - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthly_returns = pd.DataFrame()\n",
    "\n",
    "monthly_returns['Date'] = new_prices['month year']\n",
    "monthly_returns['Stanbic ETF 30'] = stb_etf_returns\n",
    "monthly_returns['Stanbic Absolute Fund'] = stb_abs_returns\n",
    "monthly_returns['Stanbic Guaranteed Income Fund'] = stb_gtd_returns\n",
    "monthly_returns['Stanbic Eurobond Fund'] = stb_euro_returns\n",
    "monthly_returns['FBN Eurobond Fund'] = fbn_euro_returns\n",
    "#monthly_returns['AXA Money Market Fund Yield'] = axa_mmf_['AXA Money Market Fund Yield']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthly_returns = monthly_returns.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "monthly_returns = monthly_returns.reset_index(drop = True, inplace = False )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "month_returns = pd.concat([monthly_returns, axa_mmf_['AXA Money Market Fund Yield']], axis = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Portfolio Return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "returns1 = month_returns[['Stanbic Absolute Fund', 'AXA Money Market Fund Yield']]\n",
    "returns2 = month_returns[['Stanbic Absolute Fund', 'Stanbic Guaranteed Income Fund', 'AXA Money Market Fund Yield']]            \n",
    "returns3 = month_returns[['Stanbic Absolute Fund', 'Stanbic ETF 30']]\n",
    "returns4 = month_returns[['Stanbic Eurobond Fund', 'FBN Eurobond Fund']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "axa_mmf1, axa_mmf2, axa_mmf3 = [0.9, 0.72, 0.13]\n",
    "stb_abs1, stb_abs2, stb_abs3, stb_abs4, stb_abs5 = [0.1, 0.24, 0.87, 0.73, 0.51]\n",
    "stb_GI = 0.04\n",
    "stb_etf1, stb_etf2 = [0.27, 0.49]\n",
    "stb_euro, fbn_euro = [0.5, 0.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "conserv = np.array([stb_abs1, axa_mmf1])\n",
    "caut = np.array([stb_abs2, stb_GI, axa_mmf2])\n",
    "bal = np.array([stb_abs3, axa_mmf3])\n",
    "grow = np.array([stb_abs4, stb_etf1])\n",
    "aggres = np.array([stb_abs5, stb_etf2])\n",
    "doll = np.array([stb_euro, fbn_euro])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "conservative = np.dot(returns1, conserv)\n",
    "cautious = np.dot(returns2, caut)\n",
    "balanced = np.dot(returns1, bal)\n",
    "growth = np.dot(returns3, grow)\n",
    "aggressive = np.dot(returns3, aggres)\n",
    "dollar = np.dot(returns4, doll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "portfolios = pd.DataFrame()\n",
    "\n",
    "portfolios['Date'] = month_returns['Date']\n",
    "portfolios['Conservative'] = conservative\n",
    "portfolios['Cautious'] = cautious\n",
    "portfolios['Balanced'] = balanced\n",
    "portfolios['Growth'] = growth\n",
    "portfolios['Aggressive'] = aggressive\n",
    "portfolios['Dollar'] = dollar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "portfolios.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "col_names = ['Oil Prices', 'Inflation', 'NSE ASI', 'FX Reserves', 'USD/NGN (BDC)', \n",
    "             'USD/NGN (I&E)', '91-Day Yield', '182-Day Yield', '364-Day Yield', \n",
    "             '2yr-Bond Yield', '3yr-Bond Yield', '5-yr-Bond Yield', '7yr-Bond Yield', \n",
    "             '10yr-Bond Yield', '12yr-Bond Yield', '15yr-Bond Yield', '20yr-Bond Yield']\n",
    "\n",
    "macro_data = pd.read_csv(r'C:\\Users\\HP\\Python University\\Portfolios & Macro Data.csv', usecols = col_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.concat([portfolios, macro_data], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the correlation each macro data variable with the  conservative portfolio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conservative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Independent Variables\n",
    "X1 = data[['Oil Prices', 'Inflation', 'NSE ASI', 'FX Reserves',\n",
    "       'USD/NGN (BDC)', 'USD/NGN (I&E)', '91-Day Yield', '182-Day Yield',\n",
    "       '364-Day Yield', '2yr-Bond Yield', '3yr-Bond Yield', '5-yr-Bond Yield',\n",
    "       '7yr-Bond Yield', '10yr-Bond Yield', '12yr-Bond Yield',\n",
    "       '15yr-Bond Yield', '20yr-Bond Yield']]\n",
    "\n",
    "# Dependent Variable\n",
    "Y1 = data['Conservative']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "X1a = sm.add_constant(X1)\n",
    "reg1 = sm.OLS(Y1, X1a).fit()\n",
    "#prediction1 = reg1.predict(X1)\n",
    "\n",
    "reg1.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Independent Variables\n",
    "X1_conserv = data[['NSE ASI', 'FX Reserves']]\n",
    "\n",
    "# Dependent Variable\n",
    "Y1_conserv = data['Conservative']\n",
    "\n",
    "X1a_conserv = sm.add_constant(X1_conserv)\n",
    "reg1_conserv = sm.OLS(Y1_conserv, X1a_conserv).fit()\n",
    "#prediction1 = reg1.predict(X1)\n",
    "\n",
    "reg1_conserv.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cautious"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y2 = data['Cautious']\n",
    "\n",
    "X1b = sm.add_constant(X1)\n",
    "reg2 = sm.OLS(Y2, X1b).fit()\n",
    "#prediction1 = reg1.predict(X1)\n",
    "\n",
    "reg2.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Independent Variables\n",
    "X1_caut = data[['NSE ASI', 'FX Reserves']]\n",
    "\n",
    "# Dependent Variable\n",
    "Y2_caut = data['Cautious']\n",
    "\n",
    "\n",
    "X1b_caut = sm.add_constant(X1_caut)\n",
    "reg2_caut = sm.OLS(Y2_caut, X1b_caut).fit()\n",
    "#prediction1 = reg1.predict(X1)\n",
    "\n",
    "reg2_caut.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Balanced"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y3 = data['Balanced']\n",
    "\n",
    "\n",
    "X1c = sm.add_constant(X1)\n",
    "reg3 = sm.OLS(Y3, X1c).fit()\n",
    "#prediction1 = reg1.predict(X1)\n",
    "\n",
    "reg3.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Independent Variables\n",
    "X1_bal = data[['NSE ASI', 'USD/NGN (BDC)']]\n",
    "\n",
    "# Dependent Variable\n",
    "Y2_bal = data['Balanced']\n",
    "\n",
    "\n",
    "X1b_bal = sm.add_constant(X1_bal)\n",
    "reg2_bal = sm.OLS(Y2_bal, X1b_bal).fit()\n",
    "#prediction1 = reg1.predict(X1)\n",
    "\n",
    "reg2_bal.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Growth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y4 = data['Growth']\n",
    "\n",
    "\n",
    "X1d = sm.add_constant(X1)\n",
    "reg4 = sm.OLS(Y4, X1d).fit()\n",
    "#prediction1 = reg1.predict(X1)\n",
    "\n",
    "reg4.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Aggressive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y5 = data['Aggressive']\n",
    "\n",
    "\n",
    "X1e = sm.add_constant(X1)\n",
    "reg5 = sm.OLS(Y5, X1e).fit()\n",
    "#prediction1 = reg1.predict(X1)\n",
    "\n",
    "reg5.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dollar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y6 = data['Dollar']\n",
    "\n",
    "\n",
    "X1f = sm.add_constant(X1)\n",
    "reg6 = sm.OLS(Y6, X1f).fit()\n",
    "#prediction1 = reg1.predict(X1)\n",
    "\n",
    "reg6.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monte-Carlo Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_returns1 = (new_prices['Stanbic ETF 30'].div(new_prices.groupby('month year')['Stanbic ETF 30'].shift(1)) - 1).dropna().reset_index(drop = True)\n",
    "stb_abs_returns1 = (new_prices['Stanbic Absolute Fund'].div(new_prices.groupby('month year')['Stanbic Absolute Fund'].shift(1)) - 1).dropna().reset_index(drop = True)\n",
    "stb_gtd_returns1 = (new_prices['Stanbic Guaranteed Income Fund'].div(new_prices.groupby('month year')['Stanbic Guaranteed Income Fund'].shift(1)) - 1).dropna().reset_index(drop = True)\n",
    "stb_euro_returns1 = (new_prices['Stanbic Eurobond Fund'].div(new_prices.groupby('month year')['Stanbic Eurobond Fund'].shift(1)) - 1).dropna().reset_index(drop = True)\n",
    "fbn_euro_returns1 = (new_prices['FBN Eurobond Fund'].div(new_prices.groupby('month year')['FBN Eurobond Fund'].shift(1)) - 1).dropna().reset_index(drop = True)\n",
    "axa_mmf_returns1 = axa_mmf_['AXA Money Market Fund Yield'].reset_index(drop = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "month_returns_log = pd.DataFrame({'Date': month_returns['Date'], \n",
    "                                  'Stanbic ETF 30': stb_etf_returns1, \n",
    "                                  'Stanbic Absolute Fund': stb_abs_returns1, \n",
    "                                  'Stanbic Guaranteed Income Fund': stb_gtd_returns1, \n",
    "                                  'Stanbic Eurobond Fund': stb_euro_returns1, \n",
    "                                  'FBN Eurobond Fund': fbn_euro_returns1, \n",
    "                                  'AXA Money Market Fund Yield': axa_mmf_returns1})                                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_mean = np.array(month_returns_log['Stanbic ETF 30'].mean())\n",
    "stb_abs_mean = np.array(month_returns_log['Stanbic Absolute Fund'].mean())\n",
    "stb_gtb_mean = np.array(month_returns_log['Stanbic Guaranteed Income Fund'].mean())\n",
    "stb_euro_mean = np.array(month_returns_log['Stanbic Eurobond Fund'].mean())\n",
    "fbn_euro_mean = np.array(month_returns_log['FBN Eurobond Fund'].mean())\n",
    "axa_mmf_mean = np.array(month_returns_log['AXA Money Market Fund Yield'].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_var = np.array(month_returns_log['Stanbic ETF 30'].var())\n",
    "stb_abs_var = np.array(month_returns_log['Stanbic Absolute Fund'].var())\n",
    "stb_gtb_var = np.array(month_returns_log['Stanbic Guaranteed Income Fund'].var())\n",
    "stb_euro_var = np.array(month_returns_log['Stanbic Eurobond Fund'].var())\n",
    "fbn_euro_var = np.array(month_returns_log['FBN Eurobond Fund'].var())\n",
    "axa_mmf_var = np.array(month_returns_log['AXA Money Market Fund Yield'].var())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_std = np.array(month_returns_log['Stanbic ETF 30'].std())\n",
    "stb_abs_std = np.array(month_returns_log['Stanbic Absolute Fund'].std())\n",
    "stb_gtb_std = np.array(month_returns_log['Stanbic Guaranteed Income Fund'].std())\n",
    "stb_euro_std = np.array(month_returns_log['Stanbic Eurobond Fund'].std())\n",
    "fbn_euro_std = np.array(month_returns_log['FBN Eurobond Fund'].std())\n",
    "axa_mmf_std = np.array(month_returns_log['AXA Money Market Fund Yield'].std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_drift = np.array(stb_etf_mean - ( 0.5 * stb_etf_var))\n",
    "stb_abs_drift = np.array(stb_abs_mean - ( 0.5 * stb_abs_var))\n",
    "stb_gtb_drift = np.array(stb_gtb_mean - ( 0.5 * stb_gtb_var))\n",
    "stb_euro_drift = np.array(stb_euro_mean - ( 0.5 * stb_euro_var))\n",
    "fbn_euro_drift = np.array(fbn_euro_mean - ( 0.5 * fbn_euro_var))\n",
    "axa_mmf_drift = np.array(axa_mmf_mean - ( 0.5 * axa_mmf_var))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "norm.ppf(0.95)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.rand(10, 2)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "norm.ppf(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = norm.ppf(np.random.rand(10, 2))\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_intervals = 1200\n",
    "n_iterations = 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_pred = np.exp(stb_etf_drift + stb_etf_std * norm.ppf(np.random.rand(t_intervals, n_iterations)))\n",
    "stb_abs_pred = np.exp(stb_abs_drift + stb_abs_std * norm.ppf(np.random.rand(t_intervals, n_iterations)))\n",
    "stb_gtb_pred = np.exp(stb_gtb_drift + stb_gtb_std * norm.ppf(np.random.rand(t_intervals, n_iterations)))\n",
    "stb_euro_pred = np.exp(stb_euro_drift + stb_euro_std * norm.ppf(np.random.rand(t_intervals, n_iterations)))\n",
    "fbn_euro_pred = np.exp(fbn_euro_drift + fbn_euro_std * norm.ppf(np.random.rand(t_intervals, n_iterations)))\n",
    "axa_mmf_pred = np.exp(axa_mmf_drift + axa_mmf_std * norm.ppf(np.random.rand(t_intervals, n_iterations)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_returns_list = np.zeros_like(stb_etf_pred)\n",
    "stb_abs_returns_list = np.zeros_like(stb_abs_pred)\n",
    "stb_gtb_returns_list = np.zeros_like(stb_gtb_pred)\n",
    "stb_euro_returns_list = np.zeros_like(stb_euro_pred)\n",
    "fbn_euro_returns_list = np.zeros_like(fbn_euro_pred)\n",
    "axa_mmf_returns_list = np.zeros_like(axa_mmf_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_returns_list[0] = month_returns_log['Stanbic ETF 30'].iloc[-1]\n",
    "stb_abs_returns_list[0] = month_returns_log['Stanbic Absolute Fund'].iloc[-1]\n",
    "stb_gtb_returns_list[0] = month_returns_log['Stanbic Guaranteed Income Fund'].iloc[-1]\n",
    "stb_euro_returns_list[0] = month_returns_log['Stanbic Eurobond Fund'].iloc[-1]\n",
    "fbn_euro_returns_list[0] = month_returns_log['FBN Eurobond Fund'].iloc[-1]\n",
    "axa_mmf_returns_list[0] = month_returns_log['AXA Money Market Fund Yield'].iloc[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for t in range(1, t_intervals):\n",
    "    stb_etf_returns_list[t] = stb_etf_returns_list[t - 1] * stb_etf_pred[t]\n",
    "    stb_abs_returns_list[t] = stb_abs_returns_list[t - 1] * stb_abs_pred[t]\n",
    "    stb_gtb_returns_list[t] = stb_gtb_returns_list[t - 1] * stb_gtb_pred[t]\n",
    "    stb_euro_returns_list[t] = stb_euro_returns_list[t - 1] * stb_euro_pred[t]\n",
    "    fbn_euro_returns_list[t] = fbn_euro_returns_list[t - 1] * fbn_euro_pred[t]\n",
    "    axa_mmf_returns_list[t] = axa_mmf_returns_list[t - 1] * axa_mmf_pred[t]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_etf_returns_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axa_mmf1, axa_mmf2, axa_mmf3 = [0.9, 0.72, 0.13]\n",
    "stb_abs1, stb_abs2, stb_abs3, stb_abs4, stb_abs5 = [0.1, 0.24, 0.87, 0.73, 0.51]\n",
    "stb_GI = 0.04\n",
    "stb_etf1, stb_etf2 = [0.27, 0.49]\n",
    "fbn_euro, stb_euro = [0.5, 0.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "future_dates = pd.date_range(start = '2018-12', periods = 1200, freq = 'M')\n",
    "future_dates.strftime('%Y-%m')\n",
    "index = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Conservative Portfolio Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_a = stb_abs_returns_list * stb_abs1\n",
    "axa_a = axa_mmf_returns_list * axa_mmf1\n",
    "\n",
    "conserv = np.sum([stb_a, axa_a], axis = 0)\n",
    "conservative = np.round(100000 + (conserv * 100000), 3)\n",
    "\n",
    "conservative = pd.DataFrame(data = conservative[:, :])\n",
    "conservative.insert(loc = index, column = 'Date', value = future_dates.strftime('%Y-%m'))\n",
    "\n",
    "conservative.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cautious Portfolio Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_b = stb_abs_returns_list * stb_abs2\n",
    "stb_g = stb_gtb_returns_list * stb_GI\n",
    "axa_b = axa_mmf_returns_list * axa_mmf2\n",
    "\n",
    "caut = np.sum([stb_b, stb_g, axa_b], axis = 0)\n",
    "cautious = np.round(100000 + (caut * 100000), 3)\n",
    "\n",
    "cautious = pd.DataFrame(data = cautious[:, :])\n",
    "cautious.insert(loc = index, column = 'Date', value = future_dates.strftime('%Y-%m'))\n",
    "\n",
    "cautious.tail()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Balanced Portfolio Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_c = stb_abs_returns_list * stb_abs3\n",
    "axa_c = axa_mmf_returns_list * axa_mmf3\n",
    "\n",
    "bal = np.sum([stb_c, axa_c], axis = 0)\n",
    "balanced = np.round(100000 + (bal * 100000), 3)\n",
    "\n",
    "balanced = pd.DataFrame(data = balanced[:, :])\n",
    "balanced.insert(loc = index, column = 'Date', value = future_dates.strftime('%Y-%m'))\n",
    "\n",
    "balanced.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Growth Portfolio Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_d1 = stb_abs_returns_list * stb_abs4\n",
    "stb_d2 = stb_etf_returns_list * stb_etf1\n",
    "\n",
    "grow = np.sum([stb_d1, stb_d2], axis = 0)\n",
    "growth = np.round(100000 + (grow * 100000), 3)\n",
    "\n",
    "growth = pd.DataFrame(data = growth[:, :])\n",
    "growth.insert(loc = index, column = 'Date', value = future_dates.strftime('%Y-%m'))\n",
    "\n",
    "growth.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Aggressive Portfolio Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_e1 = stb_abs_returns_list * stb_abs5\n",
    "stb_e2 = stb_etf_returns_list * stb_etf2\n",
    "\n",
    "aggres = np.sum([stb_e1, stb_e2], axis = 0)\n",
    "aggressive = np.round(100000 + (aggres * 100000), 3)\n",
    "\n",
    "aggressive = pd.DataFrame(data = aggressive[:, :])\n",
    "aggressive.insert(loc = index, column = 'Date', value = future_dates.strftime('%Y-%m'))\n",
    "\n",
    "aggressive.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dollar Portfolio Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_f = stb_euro_returns_list * stb_euro\n",
    "fbn_a = fbn_euro_returns_list * fbn_euro\n",
    "\n",
    "doll = np.sum([stb_f, fbn_a], axis = 0)\n",
    "dollar = np.round(100000 + (doll * 100000), 3)\n",
    "\n",
    "dollar = pd.DataFrame(data = dollar[:, :])\n",
    "dollar.insert(loc = index, column = 'Date', value = future_dates.strftime('%Y-%m'))\n",
    "\n",
    "dollar.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.options.display.max_rows = None\n",
    "pd.options.display.max_columns = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stb_gtb_mean, stb_gtb_std"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = pd.DataFrame(data = stb_etf_returns_list[:, :])\n",
    "\n",
    "A = round((A * 100), 3)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}