Ch01_Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basics\n",
    "\n",
    "of return calculations: returns, average returns and volatilities of portfolios."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Packages and Extra Functions\n",
    "\n",
    "The notebook uses the functions `printmat()` and `printlnPs()` for formatted printing of matrices and numbers. These functions are in the included `src/printmat.jl` file and call on the `Printf` package. \n",
    "\n",
    "Also, the `lag()` function (from `src/lag.jl`) lags a vector/matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Printf\n",
    "\n",
    "include(\"src/printmat.jl\")\n",
    "include(\"src/lag.jl\");       #; to suppress printing of last command in cell"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Return Calculations\n",
    "\n",
    "The return of holding the asset between $t-1$ and $t$ is\n",
    "\n",
    "$\n",
    "R_t = (P_t+D_t)/P_{t-1} - 1,\n",
    "$\n",
    "\n",
    "where $P_t$ is the price (measured after dividends) and $D_t$ is the dividend.\n",
    "\n",
    "We can calculate the returns by a loop or by a more compact notation, see below.\n",
    "\n",
    "### A Remark on the Code\n",
    "For the vectorized version, notice that\n",
    "- `lag(P)` creates a vector `[NaN,P[1],...,P[end-1]`, that is, the previous (lagged) value of `P`.\n",
    "- use `[a,b]./[c,d]` to do element-by-element division. Also, use `[a,b] .- 1` to subtract 1 from each element. In contrast, `[a,b]-[c,d]` (or `+`) needs no dot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "period      return, %return (alt), %\n",
      "2              10.000         10.000\n",
      "3               0.926          0.926\n",
      "\n"
     ]
    }
   ],
   "source": [
    "P = [100,108,109]                     #prices (after dividends) for t=1,2,3\n",
    "D = [0,2,0]                           #dividends, could also use [0;2;0]\n",
    "\n",
    "R = zeros(length(P))                  #where to store the results\n",
    "for t in 2:length(P)                   #P[2] is the 2nd element of P  \n",
    "    R[t] = (P[t] + D[t])/P[t-1] - 1\n",
    "end\n",
    "R = R[2:end]                          #get rid of R[1] since we have no return there\n",
    "\n",
    "R_alt = (P + D)./lag(P) .- 1          #vectorized alternative, notice the ./ and .- 1\n",
    "\n",
    "printmat(R*100,R_alt[2:end]*100,colNames=[\"return, %\",\"return (alt), %\"],rowNames=2:3,cell00=\"period\",width=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cumulating Returns\n",
    "\n",
    "Net returns can be cumulated to calculate portfolio values as \n",
    "\n",
    "$\n",
    "V_t = V_{t-1}(1+R_t)\n",
    "$\n",
    "\n",
    "where we need a starting value (initial investment) for the portfolio (a common choice is to normalise to $V_0=1$).\n",
    "\n",
    "With log returns, $r_t=\\log(1+R_t)$, we instead do \n",
    "\n",
    "$\n",
    "\\ln V_t = \\ln V_{t-1} + r_t\n",
    "$\n",
    "\n",
    "If the return series is an excess return, add the riskfree rate to convert it to get net returns - and then cumulate as described above.\n",
    "\n",
    "### A Remark on the Code\n",
    "- Use `cumprod([a,b]` to calculate `[a,a*b]` and `cumsum([a,b]` to calculate `[a,a+b]`.\n",
    "- To add 1 to each element of an array `R`, do `1 .+ R` (Notice the dot and the space before the dot.)\n",
    "- To calculate the logarithm of each value in a matrix `X`, do `log.(X)` Again, notice the dot. In general, a function that is defined for a scalar can be called like that to do the calculation for each element in an array (vector, matrix,...)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "period         R         V       lnV\n",
      "1          0.200     1.200     0.182\n",
      "2         -0.350     0.780    -0.248\n",
      "3          0.250     0.975    -0.025\n",
      "\n",
      "\u001b[31m\u001b[1mCheck that lnV really equals log.(V). Also, try a loop instead\u001b[22m\u001b[39m\n"
     ]
    }
   ],
   "source": [
    "R   = [20,-35,25]/100                #returns for t=1,2,3\n",
    "V   = cumprod(1 .+ R)                #V(t) = V(t-1)*(1+R(t)), starting at 1 in t=0\n",
    "r   = log.(1 .+ R)                   #log returns\n",
    "lnV = cumsum(r)                      #lnV(t) = lnV(t-1) + r(t) \n",
    "\n",
    "printmat(R,V,lnV,colNames=[\"R\",\"V\",\"lnV\"],rowNames=1:3,cell00=\"period\")\n",
    "\n",
    "printred(\"Check that lnV really equals log.(V). Also, try a loop instead\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Portfolio Return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We form a portfolio by combining $n$ assets: $v$ is the vector of $n$ portfolio weights. The portfolio return is\n",
    "\n",
    "$R_v = v'R,$\n",
    "\n",
    "where $R$ is a vector of returns of the $n$ assets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34m\u001b[1mPortfolio weights:\u001b[22m\u001b[39m\n",
      "asset 1     0.800\n",
      "asset 2     0.200\n",
      "\n",
      "\u001b[34m\u001b[1mReturns:\u001b[22m\u001b[39m\n",
      "asset 1     0.100\n",
      "asset 2     0.050\n",
      "\n",
      "\u001b[34m\u001b[1mPortfolio return: \u001b[22m\u001b[39m\n",
      "     0.090\n"
     ]
    }
   ],
   "source": [
    "v = [0.8,0.2]\n",
    "R = [10,5]/100          #returns of asset 1 and 2\n",
    "Rᵥ = v'R                #R\\_v[TAB] to get Rᵥ\n",
    "\n",
    "printblue(\"Portfolio weights:\")\n",
    "printmat(v;rowNames=[\"asset 1\",\"asset 2\"])\n",
    "\n",
    "printblue(\"Returns:\")\n",
    "printmat(R;rowNames=[\"asset 1\",\"asset 2\"])\n",
    "\n",
    "printblue(\"Portfolio return: \")\n",
    "printlnPs(Rᵥ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Julia 1.11.2",
   "language": "julia",
   "name": "julia-1.11"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}