CQF-Assignment-1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using matplotlib backend: MacOSX\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import os.path\n",
    "from matplotlib import pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy.stats import norm\n",
    "import math\n",
    "%matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Portfolio Optimization\n",
    "### Minumum variance portfolio with a target return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q1, bp 2: compute optimal allocations and stress correlation matrix with 1.25 and 1.5 factors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(2020)\n",
    "\n",
    "R = np.array([[1, 0.3, 0.3, 0.3], \n",
    "              [0.3, 1, 0.6, 0.6],\n",
    "              [0.3, 0.6, 1, 0.6],\n",
    "              [0.3, 0.6, 0.6, 1]])\n",
    "\n",
    "mu = np.array([0.02, 0.07, 0.15, 0.20])\n",
    "\n",
    "sigma = np.array([0.05, 0.12, 0.17, 0.25])\n",
    "\n",
    "targetReturn = 0.045\n",
    "\n",
    "unitVector = np.repeat(1, len(mu))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "covMatrix = np.dot(np.dot(np.diag(sigma), R), np.diag(sigma))\n",
    "\n",
    "invCovMatrix = np.linalg.inv(covMatrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.dot(np.dot(unitVector, invCovMatrix), unitVector)\n",
    "\n",
    "B = np.dot(np.dot(mu, invCovMatrix), unitVector)\n",
    "\n",
    "C = np.dot(np.dot(mu, invCovMatrix), np.transpose(mu))\n",
    "\n",
    "lamdaVariable = (A*targetReturn - B)/(A*C-B**2)\n",
    "\n",
    "gammaVariable = (C-B*targetReturn)/(A*C-B**2)\n",
    "\n",
    "w1 = np.dot(invCovMatrix, (lamdaVariable*mu + gammaVariable*unitVector))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "sigmaPortfolios = np.sqrt(np.dot(np.dot(w1, covMatrix), np.transpose(w1)))\n",
    "\n",
    "expectedReturnPortfolios = np.dot(np.transpose(w1), mu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.79'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(round(w1[0],2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "return_and_risk_standart = np.array([[expectedReturnPortfolios, sigmaPortfolios]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal allocations are Asset A: 0.785,  Asset B: 0.054,  Asset C: 0.134,  Asset D: 0.027\n"
     ]
    }
   ],
   "source": [
    "print('Optimal allocations are' + ' ' + 'Asset A: '+ str(round(w1[0],3)) + ', ' ' Asset B: '+ str(round(w1[1],3))+\n",
    "     ', ' + ' Asset C: ' + str(round(w1[2], 3)) + ', ' + ' Asset D: '+ str(round(w1[3], 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Volatility of the portfolio is 0.0584\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print('Volatility of the portfolio is ' + str(round(sigmaPortfolios, 4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### stress correlation matrix with coefficient 1.25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "R_stress125= np.array([[1, 0.3*1.25, 0.3*1.25, 0.3*1.25], \n",
    "                      [0.3*1.25, 1, 0.6*1.25, 0.6*1.25],\n",
    "                      [0.3*1.25, 0.6*1.25, 1, 0.6*1.25],\n",
    "                      [0.3*1.25, 0.6*1.25, 0.6*1.25, 1]])\n",
    "\n",
    "covMatrix_stress125 = np.dot(np.dot(np.diag(sigma), R_stress125), np.diag(sigma))\n",
    "\n",
    "invCovMatrix_stress125 = np.linalg.inv(covMatrix_stress125)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "As125 = np.dot(np.dot(unitVector, invCovMatrix_stress125), unitVector)\n",
    "\n",
    "Bs125 = np.dot(np.dot(mu, invCovMatrix_stress125), unitVector)\n",
    "\n",
    "Cs125 = np.dot(np.dot(mu, invCovMatrix_stress125), np.transpose(mu))\n",
    "\n",
    "lamdaVariables125 = (As125*targetReturn - Bs125)/(As125*Cs125-Bs125**2)\n",
    "\n",
    "gammaVariables125 = (Cs125-Bs125*targetReturn)/(As125*Cs125-Bs125**2)\n",
    "\n",
    "w1s125 = np.dot(invCovMatrix_stress125, (lamdaVariables125*mu + gammaVariables125*unitVector))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "sigmaPortfolios125 = np.sqrt(np.dot(np.dot(w1s125, covMatrix_stress125), np.transpose(w1s125)))\n",
    "\n",
    "expectedReturnPortfolios125 = np.dot(np.transpose(w1s125), mu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "return_and_risk_stress_125 = np.array([[expectedReturnPortfolios125, sigmaPortfolios125]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal allocations of the stressed portfolio (1.25) are Asset A: 0.818,  Asset B: -0.009,  Asset C: 0.179,  Asset D: 0.012\n"
     ]
    }
   ],
   "source": [
    "print('Optimal allocations of the stressed portfolio (1.25) are' + ' ' + 'Asset A: '+ str(round(w1s125[0],3)) \n",
    "      + ', ' ' Asset B: '+ str(round(w1s125[1],3)) + ', ' + ' Asset C: ' + str(round(w1s125[2], 3)) \n",
    "      + ', ' + ' Asset D: ' + str(round(w1s125[3], 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Volatility of the stressed portfolio (1.25) portfolio is 0.0607\n"
     ]
    }
   ],
   "source": [
    "print('Volatility of the stressed portfolio (1.25) portfolio is ' + str(round(sigmaPortfolios125, 4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### stress correlation matrix with coefficient 1.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "R_stress15= np.array([[1, 0.3*1.5, 0.3*1.5, 0.3*1.5], \n",
    "                      [0.3*1.5, 1, 0.6*1.5, 0.6*1.5],\n",
    "                      [0.3*1.5, 0.6*1.5, 1, 0.6*1.5],\n",
    "                      [0.3*1.5, 0.6*1.5, 0.6*1.5, 1]])\n",
    "\n",
    "covMatrix_stress15 = np.dot(np.dot(np.diag(sigma), R_stress15), np.diag(sigma))\n",
    "\n",
    "invCovMatrix_stress15 = np.linalg.inv(covMatrix_stress15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "As15 = np.dot(np.dot(unitVector, invCovMatrix_stress15), unitVector)\n",
    "\n",
    "Bs15 = np.dot(np.dot(mu, invCovMatrix_stress15), unitVector)\n",
    "\n",
    "Cs15 = np.dot(np.dot(mu, invCovMatrix_stress15), np.transpose(mu))\n",
    "\n",
    "lamdaVariables15 = (As15*targetReturn - Bs15)/(As15*Cs15-Bs15**2)\n",
    "\n",
    "gammaVariables15 = (Cs15-Bs15*targetReturn)/(As15*Cs15-Bs15**2)\n",
    "\n",
    "w1s15 = np.dot(invCovMatrix_stress15, (lamdaVariables15*mu + gammaVariables15*unitVector))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "sigmaPortfolios15 = np.sqrt(np.dot(np.dot(w1s15, covMatrix_stress15), np.transpose(w1s15)))\n",
    "\n",
    "expectedReturnPortfolios15 = np.dot(np.transpose(w1s15), mu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "return_and_risk_stress_15 = np.array([[expectedReturnPortfolios15, sigmaPortfolios15]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimal allocations of the stressed portfolio (1.5) are Asset A: 0.876,  Asset B: -0.146,  Asset C: 0.326,  Asset D: -0.056\n"
     ]
    }
   ],
   "source": [
    "print('Optimal allocations of the stressed portfolio (1.5) are' + ' ' + 'Asset A: '+ str(round(w1s15[0],3)) \n",
    "      + ', ' ' Asset B: '+ str(round(w1s15[1],3)) + ', ' + ' Asset C: ' + str(round(w1s15[2], 3)) \n",
    "      + ', ' + ' Asset D: ' + str(round(w1s15[3], 3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Volatility of the stressed portfolio (1.5) portfolio is 0.0611\n"
     ]
    }
   ],
   "source": [
    "print('Volatility of the stressed portfolio (1.5) portfolio is ' + str(round(sigmaPortfolios15, 4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Q1, bp3 1: compute optimal allocations using invesrse optimizaton"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "stNormalNumbers = np.random.normal(0, 1, size=(10000,4))\n",
    "\n",
    "randomWeightsSet = np.array([])\n",
    "\n",
    "randomExpReturnsSet = []\n",
    "\n",
    "randomPortfolioVolatilitySet = []\n",
    "\n",
    "w1 = np.dot(invCovMatrix, (lamdaVariable*mu + gammaVariable*unitVector))\n",
    "\n",
    "for i in range(0, len(stNormalNumbers)):\n",
    "    \n",
    "    normilizedRandomWeights = stNormalNumbers[i]/sum(stNormalNumbers[i])\n",
    "    \n",
    "    expectedReturnRandomPortfolio = np.dot(np.transpose(normilizedRandomWeights), mu)\n",
    "    \n",
    "    randomExpReturnsSet.append(expectedReturnRandomPortfolio)\n",
    "    \n",
    "    sigmaRandomPortfolio = np.sqrt(np.dot(np.dot(normilizedRandomWeights, \n",
    "                                           covMatrix), \n",
    "                                    np.transpose(normilizedRandomWeights)))\n",
    "    \n",
    "    randomPortfolioVolatilitySet.append(sigmaRandomPortfolio)\n",
    "\n",
    "randomExpReturnsSet = np.array(randomExpReturnsSet)\n",
    "\n",
    "randomPortfolioVolatilitySet = np.array(randomPortfolioVolatilitySet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "# indexReturns = np.logical_and(randomPortfolioVolatilitySet<0.50, randomPortfolioVolatilitySet>-0.50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "params = pd.DataFrame(np.column_stack((randomExpReturnsSet,randomPortfolioVolatilitySet)))\n",
    "params.columns = ['Expected Return', 'Volatility']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Efficient Frontier (inverse optimization, 10000 simulations)')"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plt.plot(params['Volatility']*100, params['Expected Return']*100, 'ro', alpha=0.1,\n",
    "        markersize=5)\n",
    "plt.xlabel('Volatility, %')\n",
    "plt.ylabel('Expected Return, %')\n",
    "plt.ylim(-20, 20)\n",
    "plt.xlim(0,20)\n",
    "\n",
    "plt.title('Efficient Frontier (inverse optimization, 10000 simulations)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tangency Portfolio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "riskFreeRates = np.array([0.005, 0.010, 0.015, 0.0175]) #0.0175,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "weightsMatrix = np.zeros(shape=(4,len(riskFreeRates)))\n",
    "meansMatrix = np.zeros(shape=(len(riskFreeRates),1))\n",
    "volsMatrix = np.zeros(shape=(len(riskFreeRates),1))\n",
    "sharpeRatioMatrix = np.zeros(shape=(len(riskFreeRates),1))\n",
    "\n",
    "for i in range(0, len(riskFreeRates)):\n",
    "    weightsTanPortfolio = np.dot(invCovMatrix, (mu - np.dot(riskFreeRates[i], unitVector)))/(B - A*riskFreeRates[i])\n",
    "    \n",
    "    weightsMatrix[:,i] = weightsTanPortfolio\n",
    "    \n",
    "    meanTanPortfolio = (C-B*riskFreeRates[i])/(B-A*riskFreeRates[i])\n",
    "    \n",
    "    meansMatrix[i,:] = meanTanPortfolio\n",
    "    \n",
    "    volTanPortfolio = np.sqrt((C-2*B*riskFreeRates[i] + A*riskFreeRates[i]**2)/((B-A*riskFreeRates[i])**2))\n",
    "    \n",
    "    volsMatrix[i,:] = volTanPortfolio\n",
    "    \n",
    "    sharpeRatio = (meanTanPortfolio - riskFreeRates[i])/volTanPortfolio\n",
    "\n",
    "    sharpeRatioMatrix[i,:] = sharpeRatio\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "weightsDf = pd.DataFrame(weightsMatrix)\n",
    "weightsDf.columns = [0.005, 0.010, 0.015, 0.0175]\n",
    "weightsDf.index = ['w1', 'w2', 'w3', 'w4']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "volsDf = pd.DataFrame(volsMatrix)\n",
    "volsDf.index = [0.005, 0.010, 0.015, 0.0175]\n",
    "volsDf.columns = ['Sigma']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "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.0050</th>\n",
       "      <th>0.0100</th>\n",
       "      <th>0.0150</th>\n",
       "      <th>0.0175</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>w1</th>\n",
       "      <td>0.016835</td>\n",
       "      <td>-0.745937</td>\n",
       "      <td>-8.644854</td>\n",
       "      <td>8.103502</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>w2</th>\n",
       "      <td>-0.229367</td>\n",
       "      <td>-0.510569</td>\n",
       "      <td>-3.422571</td>\n",
       "      <td>2.751851</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>w3</th>\n",
       "      <td>0.814340</td>\n",
       "      <td>1.490249</td>\n",
       "      <td>8.489651</td>\n",
       "      <td>-6.351431</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>w4</th>\n",
       "      <td>0.398192</td>\n",
       "      <td>0.766257</td>\n",
       "      <td>4.577774</td>\n",
       "      <td>-3.503922</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0.0050    0.0100    0.0150    0.0175\n",
       "w1  0.016835 -0.745937 -8.644854  8.103502\n",
       "w2 -0.229367 -0.510569 -3.422571  2.751851\n",
       "w3  0.814340  1.490249  8.489651 -6.351431\n",
       "w4  0.398192  0.766257  4.577774 -3.503922"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weightsDf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.92142775],\n",
       "       [ 0.9015154 ],\n",
       "       [ 0.89309108],\n",
       "       [-0.89330582]])"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sharpeRatioMatrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### plot the efficient frontier for rf = 100 bps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "volValues = np.linspace(0,0.10,100)*100\n",
    "mu = riskFreeRates[1]*100 + sharpeRatioMatrix[1]*volValues\n",
    "plt.plot(volValues, mu, '-r', label = 'risk-free asset with 1.0 %')\n",
    "plt.xlabel('Volatility, %')\n",
    "plt.ylabel('Expected Return, %');\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### plot the efficient frontier for rf = 175 bps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "volValues = np.linspace(0,0.10,100)*100\n",
    "mu = riskFreeRates[3]*100 + sharpeRatioMatrix[3]*volValues\n",
    "plt.plot(volValues, mu, '-b', label = 'risk-free asset with 1.75 %')\n",
    "plt.xlabel('Volatility, %')\n",
    "plt.ylabel('Expected Return, %');\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1, 'Efficient frontiers in the presence of risk-free assets  rf=1.0 % (red line) and  rf=1.75 % (blue line)')"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plt.title('Efficient frontiers in the presence of risk-free assets' + ' ' + ' ' + 'rf=' + str(riskFreeRates[1]*100)  \n",
    "          + ' % (red line)' +' '+ 'and' + ' ' + ' ' + 'rf=' + str(round(riskFreeRates[3]*100,2)) \n",
    "          + ' % (blue line)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EDA: Q-Q plot and statistical tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "returns = priceDf['logReturn'].dropna()\n",
    "meanReturns = np.mean(returns)\n",
    "sdReturns = np.std(returns)\n",
    "nrOfObsr = len(returns)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "returnsNormalized = (returns - meanReturn)/sdReturn\n",
    "sorted_data =  returnsNormalized.sort_values(axis=0, ascending=True)\n",
    "sorted_data = sorted_data.reset_index()\n",
    "sorted_data = sorted_data.iloc[:, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "stNormalData = np.random.normal(loc = 0, scale = 1, size = len(sorted_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "probabilities = [i/nrOfObsr for i in range(1, nrOfObsr+1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in log\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "theoreticalReturns = np.log(np.array(norm.ppf(probabilities,\n",
    "                         loc=meanReturns, scale=sdReturns)))\n",
    "\n",
    "sorted_dataArray = np.array(sorted_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([        nan,         nan,         nan, ..., -3.79063254,\n",
       "       -3.72384416,         inf])"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theoreticalReturns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1, 'Q-Q plot for standartized returns')"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "plt.plot(theoreticalReturns, sorted_dataArray, 'o', alpha=0.5, markersize=4)\n",
    "plt.xlabel('Theoretical Quantiles')\n",
    "plt.ylabel('Sample Quantiles')\n",
    "plt.title('Q-Q plot for standartized returns')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.clf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Statistics=0.961, p=0.000\n",
      "Sample does not look Gaussian (reject H0)\n"
     ]
    }
   ],
   "source": [
    "# Shapiro-Wilk Test\n",
    "from numpy.random import seed\n",
    "from numpy.random import randn\n",
    "from scipy.stats import shapiro\n",
    "\n",
    "data = sorted_dataArray\n",
    "# normality test\n",
    "stat, p = shapiro(data)\n",
    "print('Statistics=%.3f, p=%.3f' % (stat, p))\n",
    "# interpret\n",
    "alpha = 0.05\n",
    "if p > alpha:\n",
    "    print('Sample looks Gaussian (fail to reject H0)')\n",
    "else:\n",
    "    print('Sample does not look Gaussian (reject H0)')"
   ]
  },
  {
   "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": 2
}