notebooks/python/Lab_3_Bond_Pricing.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/CBravoR/AdvancedAnalyticsLabs/blob/master/notebooks/python/Lab_3_Bond_Pricing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RoDTAKe3eWDE"
      },
      "source": [
        "# Lab 3 - Bond Pricing\n",
        "\n",
        "In this lab, we will study implementations of the bond pricing structures we have discussed in the lectures. Since we will be using a lot of numerical methods, we would need to program a large set of mathematical functions and other mathematical quantities. Luckily for us, this has already been done.\n",
        "\n",
        "A **package** is a set of functions, constants, and other data that comes pre-packaged and can be used once installed locally. Many packages are available (exactly [431,218](https://pypi.python.org/pypi) at the time of writing), but we will focus only on a set of them of course.\n",
        "\n",
        "The fist one is [Numpy](http://www.numpy.org/), self-described as \"the fundamental package for scientific computing with Python\". It comes with a very large number of scientific functions. These range from simply implementing mathetical constants (such as $\\pi$ or $e$), to mathematical functions (such as the logistic functions), random number generators, and much, much, more. As we move along with the activities of the module, we will use many of Numpy's functions, but the packages that we will use will most certainly be using Numpy under the hood.\n",
        "\n",
        "## Loading packages\n",
        "\n",
        "To load a package so it can be used in your terminal, write the following line:\n",
        "\n",
        "```\n",
        "import PACKAGE as SHORT_NAME\n",
        "```\n",
        "\n",
        "For example, to load Numpy and assign it the (well-known) alias \"np\" we run"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FxPqqILaeWva"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3WV0FYJReqOH"
      },
      "source": [
        "With this, all of numpy is available by calling ```np.NAME```. For example, to check the value of $\\pi$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DhBKYRSAencB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "313af195-2b5b-4aea-da10-66a090ad1905"
      },
      "source": [
        "np.pi"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.141592653589793"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "geCgr2iGezDN"
      },
      "source": [
        "... or to calculate the value of $e^4$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FEFFkAOveyVG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ffb9ca3f-443c-47e0-9e07-b6f08b12a48b"
      },
      "source": [
        "np.round(np.e ** 4, 16) == np.round(np.exp(4), 16)"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mEQ9jjbve4dV"
      },
      "source": [
        "Note that the power function is two asterisks, so for example $4^2$ would require this line of code:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2Dhr4EPYe15k",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "16263bf3-17a6-49a8-b24e-ad78975209d0"
      },
      "source": [
        "4 ** 2"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oO40Wo37fBEi"
      },
      "source": [
        "Numpy is a **very** extensive package. You can explore the details of it [here](https://docs.scipy.org/doc/numpy-dev/user/quickstart.html). We will now apply it in order to calculate the functions we need."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XAjSuJzFsEjo"
      },
      "source": [
        "## Interest rate conventions.\n",
        "\n",
        "Let's consider a bond with principal  Y loaned out for 1 year and repaid at the end of the year with no intermediate coupons (0-coupon bond). How much is repaid?\n",
        "\n",
        "1. Simple interest: Assume an annual rate of $r_s = 2\\%$. How much is the bond valued at?\n",
        "\n",
        "It is a really simple problem, but we can write it more generally by using a **function**. A function is simply an algorithm we predefined for ease of calling. As you studied last week (right????), a function is defined following this convention:\n",
        "\n",
        "```\n",
        "def NAME(PARAMS):\n",
        "    FUNCTION CODE\n",
        "    MORE CODE\n",
        "    return OUT\n",
        "```\n",
        "\n",
        "Remember that in Python blocks are marked by indented text. Be consistent with your indentations, either use tabs or spaces - not both - in a single cell.\n",
        "\n",
        "So, let's define the function \"bond_pay_simple_interest\" which will receive the bond principal and an interest rate, and will return the payment."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2AFXpYXVfAUb"
      },
      "source": [
        "def bond_pay_simple_interest(Y, rs = 0.02):\n",
        "    out = Y * (1 + rs)\n",
        "    return(out)"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aligxYJEfU52"
      },
      "source": [
        "Now our function is ready to use! See how we give a value to the interest rate ```rs```? This is an **optional variable**. By saying ```rs = 0.02```, we are allowing the function to receive one or two parameters.\n",
        "\n",
        "1. Calling ```bond_pay_simple_interest(100000, 0.05)``` will calculate the value of the bond payment using ```Y = 100000, rs = 0.05```.\n",
        "2. Calling ```bond_pay_simple_interest(100000)``` will calculate the value of the demand using ```rs = 0.02```.\n",
        "3. Calling ```bond_pay_simple_interest()``` will fail. It requires the input of the first parameter Y (it is not an optional parameter).\n",
        "4. Calling ```bond_pay_simple_interest(rs = 0.05, Y = 1000000)``` (or any other order) also works as long as all the inputs are named!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rVAbSsKWfO6H",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "379df4f2-72ad-4b86-8ef6-9dc08b34833a"
      },
      "source": [
        "bond_pay_simple_interest(100000, 0.05)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "105000.0"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xb48cR4ffkgy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cd0efeee-2414-4ef3-a31e-c233d69cb6d6"
      },
      "source": [
        "bond_pay_simple_interest(rs = 0.05, Y = 100000)"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "105000.0"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YGz38n4aflwD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "234ba955-e50f-4352-d2f2-f5c22e15a043"
      },
      "source": [
        "bond_pay_simple_interest(100000)"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "102000.0"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IP1lN79xwlMt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c425ef7-e835-49e6-b4ad-7d6d81e55735"
      },
      "source": [
        "bond_pay_simple_interest(100000, rs = 0.02)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "102000.0"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oyJJB7Aefm3q",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 166
        },
        "outputId": "7ccb4834-9662-4bbb-8803-9c62c618c6b1"
      },
      "source": [
        "bond_pay_simple_interest()"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-17-d92ea5e63702>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mbond_pay_simple_interest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: bond_pay_simple_interest() missing 1 required positional argument: 'Y'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ReeFaGS3yoYu"
      },
      "source": [
        "The last commands fails because the argument Y is **not** an optional argument.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sN7wwR-kyrhH"
      },
      "source": [
        "2. Compound interest\n",
        "\n",
        "Now the bond pays at fixed intervals $m$ during the year. We get an interest rate $r_m$ on each of $m$ periods (each period lasting $1/m$ years for example). Now the formula is:\n",
        "\n",
        "$$\n",
        "X_m=Y \\cdot (1 + r_m)^m \n",
        "$$\n",
        "\n",
        "Let's write a function for it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L_lGrTRdzDrQ"
      },
      "source": [
        "def bond_pay_compound_interest(Y, rm = 0.01, m = 2):\n",
        "    out = Y * (1 + rm) ** m\n",
        "    return(out)"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GUfyyEdTzV96"
      },
      "source": [
        "Let's compare the payment for one year between the two. We use a rate given by $r_m = r_s  / m$ to show the difference between methods."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AGMRRlXjzZ39",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3fe5048f-daca-4f4f-9959-6ce5950e3d30"
      },
      "source": [
        "print(f'Simple interest payment (one year): {bond_pay_simple_interest(100000)}')\n",
        "print(f'Compound interest payment (one year, two payments): {bond_pay_compound_interest(100000)}')"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Simple interest payment (one year): 102000.0\n",
            "Compound interest payment (one year, two payments): 102010.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ll_6nJU7zppj"
      },
      "source": [
        "There is a $10 difference arising from the compound interest.\n",
        "\n",
        "3. Continous interest: The last way commonly used way to calculate interest is to use continous interest. A continous interest bond pays every fraction of a second. It is usually used for callable bonds or other bonds with an undefined maturity. This method pays continously a certain rate. The formula is now\n",
        "\n",
        "$$\n",
        "X_c = Y \\cdot exp(r_c * t)\n",
        "$$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ywmDxTi2oN_"
      },
      "source": [
        "def bond_pay_continous_interest(Y, rc = 0.02, m = 1):\n",
        "    out = Y * np.exp(rc * m)\n",
        "    return(out)"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "usyQftg727Wp"
      },
      "source": [
        "Comparing all three now."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GlXZWuwr26V9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4faea6a1-64b0-4f82-f0b2-699a5a463fb3"
      },
      "source": [
        "print(f'Simple interest payment (one year): {bond_pay_simple_interest(100000)}')\n",
        "print(f'Compound interest payment (one year, two payments): {bond_pay_compound_interest(100000)}')\n",
        "print(f'Continous interest (one year): {bond_pay_continous_interest(100000):.2f}')"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Simple interest payment (one year): 102000.0\n",
            "Compound interest payment (one year, two payments): 102010.0\n",
            "Continous interest (one year): 102020.13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1mvijZPk3y_7"
      },
      "source": [
        "Of course, continous interest gives a much higher payment rate. Which products do you think use continous interest?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tIw9LnGDfpRS"
      },
      "source": [
        "\n",
        "## Basic plotting\n",
        "\n",
        "The above examples are for one-year bonds, but bonds can also have multiple periods. How do the different interest convention look like in this case?\n",
        "\n",
        "To do this we will first extend our functions to consider multiple payments periods. Assuming $N$ is the number of years the bond is offered, then:\n",
        "\n",
        "$$\n",
        "X_s = Y \\cdot (1+N \\cdot r_s) \\\\\n",
        "X_m = Y \\cdot (1+r_m)^{N \\cdot m} \\\\\n",
        "X_c = Y \\cdot \\exp(r_c \\cdot N)\n",
        "$$\n",
        "\n",
        "We can extend our original functions to include the **maturity** $N$."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "453gRwHA4iMm"
      },
      "source": [
        "def bond_pay_simple_interest(Y, rs = 0.02, N = 1):\n",
        "    out = Y * (1 + N * rs)\n",
        "    return(out)\n",
        "\n",
        "def bond_pay_compound_interest(Y, rm = 0.01, m = 2, N = 1):\n",
        "    out = Y * (1 + rm) ** (N * m)\n",
        "    return(out)\n",
        "\n",
        "def bond_pay_continous_interest(Y, rc = 0.02, N = 1):\n",
        "    out = Y * np.exp(N  * rc)\n",
        "    return(out)"
      ],
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hUgjmQhC4i60"
      },
      "source": [
        "To compare these functions, let's plot them.  We will do so using the extremely powerful package ```matplotlib```, in particular the python implementation ```pyplot```.  We will use the common alias ```plt```."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VlK7Afshfofi"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WeSkUb3Of24_"
      },
      "source": [
        "The line ```%matplotlib inline``` is called a \"magic\", and is a command that tells Jupyter to do something specific. This commands tells Jupyter to plot inline (i.e. in this notebook directly), instead of saving the image elsewhere. A list of all magic commands is available [here](http://ipython.readthedocs.io/en/stable/interactive/magics.html).\n",
        "\n",
        "We can now plot a function with a constant elasticity over the range [1, 100] with the following functions:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mm4KTO16f0w_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "30b777d9-137b-482f-ed8f-21fb9ef5a03a"
      },
      "source": [
        "Nseries = np.arange(0, 100.01, 0.05) # Calculates evenly spaced points in the interval 1 to 100.\n",
        "\n",
        "plt.plot(Nseries, bond_pay_simple_interest(100000, N = Nseries)) # Applies the vector p to the d_const_elast function using elast = 1\n",
        "plt.title('Simple interest')\n",
        "plt.xlabel('Period')\n",
        "plt.ylabel('Value')\n",
        "plt.show()"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "30iAu5rEgAGl"
      },
      "source": [
        "We can even compare multiple functions. For example, the following code compares multiple compounding options."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C_mL5D03f7VW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "outputId": "5ed2fdb4-94af-422a-8979-c44a45e24292"
      },
      "source": [
        "# Each call to plt.plot generates a new part of the plot.\n",
        "plt.plot(Nseries, bond_pay_simple_interest(100000, N = Nseries))\n",
        "plt.plot(Nseries, bond_pay_compound_interest(100000, N = Nseries))\n",
        "plt.plot(Nseries, bond_pay_continous_interest(100000, N = Nseries))\n",
        "\n",
        "# Add a legend. Note the square brackets.\n",
        "plt.legend(['Simple Interest', 'Compound Interest', 'Continous Interest'])\n",
        "\n",
        "# Titles and labels\n",
        "plt.title('Comparison of interest types')\n",
        "plt.xlabel('Period')\n",
        "plt.ylabel('Value')\n",
        "\n",
        "# What if you want to save the output? This code, called BEFORE the plt.show(), saves\n",
        "# as an image. You can also save in other formats changing the extension\n",
        "plt.savefig('RateComparison.jpg', dpi = 300)\n",
        "plt.savefig('RateComparison.pdf')\n",
        "\n",
        "# Generates the plot with everything we have added so far since last call to plt.show\n",
        "plt.show()"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v-PkqmeUgFFU"
      },
      "source": [
        "## Bond pricing\n",
        "\n",
        "We can now calculate the value of a bond. Think about it this way: How much are you willing to pay for each bond we saw above?\n",
        "\n",
        "- The simple interest bond has a much reduced payment value across time.\n",
        "- The compound and continous one have a much higher payment.\n",
        "- What about coupons? What happens after each coupon is charged? Does value decrease or increase?\n",
        "\n",
        "Thus, we need an efficient way to **price** a bond so it reflects how much we expect it to be valued. This will depend on the expected interest rate and returns on the market, so **the value of a bond can vary even though payments are fixed**.\n",
        "\n",
        "See this [ETF return](https://ca.finance.yahoo.com/quote/VAB.TO/) composed of a mix of different canadian bonds.\n",
        "\n",
        "How do we price bonds? We need to consider the yearly rate for different instruments (risk-free in this case) and use those. We can get this from the market. Then we can value the bond discounting the payments:\n",
        "\n",
        "$$\n",
        "P(0) = \\sum_{t=1}^M \\frac{c}{(1+r_t)^t} + \\frac{1}{(1+r_M)^M}\n",
        "$$\n",
        "\n",
        "If you have a non-risk-free-bond, then $r_t = r_{f,t} + s_t$. The final price of the bond is $P \\times FV$ with $FV$ the face value of the bond.\n",
        "\n",
        "If $r$ is constant, then the extension package to numpy, [numpy_financial](https://pypi.org/project/numpy-financial/) offers the function Net Present Value, [```npf.npv```](https://numpy.org/numpy-financial/latest/npv.html), which allows for simple net present value calculations when the rate is fixed and the time periods are equidistant.\n",
        "\n",
        "Let's calculate the value of a bond under the following conditions:\n",
        "\n",
        "- Principal \\$100,000.\n",
        "- Yearly coupons, coupon rate $c = 5\\%$.\n",
        "- Market Interest rate $r = 3\\%$.\n",
        "- Maturity = 10 years.\n",
        "\n",
        "The ```numpy_financial``` package is not part of the standard python installation, so we must install it ourselves. For this, we use Python's package manager ```pip``` (a command line argument). To install a package simply run\n",
        "\n",
        "```\n",
        "!pip install PACKAGE_NAME\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BjDj4iCVsTEF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "50d38c22-3e28-4b6f-b882-7ffc3c6a82cd"
      },
      "source": [
        "# Install numpy_financial\n",
        "!pip install numpy_financial"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting numpy_financial\n",
            "  Downloading numpy_financial-1.0.0-py3-none-any.whl (14 kB)\n",
            "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.8/dist-packages (from numpy_financial) (1.21.6)\n",
            "Installing collected packages: numpy_financial\n",
            "Successfully installed numpy_financial-1.0.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rSI_-aj12AKZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fd59c220-0717-4a96-c071-9efcc58a41a5"
      },
      "source": [
        "# Import numpy_financial\n",
        "import numpy_financial as npf\n",
        "\n",
        "# Parameters\n",
        "X = 100000\n",
        "C = 0.05 * 100000\n",
        "r = 0.03\n",
        "\n",
        "# Payment sequence\n",
        "payment_series = np.repeat(C, 11)\n",
        "payment_series[0] -= C # At t = 0 no payment is made. (What do we get if we write -100000?)\n",
        "payment_series[10]  += X # Last payment with principal\n",
        "\n",
        "# Show the payment sequence\n",
        "print(payment_series)\n",
        "\n",
        "# PV calculation. Note payments are at end of period in this case.\n",
        "bond_price = npf.npv(r, payment_series)\n",
        "print(f'The price of the bond is: {bond_price:.2f}')"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[     0.   5000.   5000.   5000.   5000.   5000.   5000.   5000.   5000.\n",
            "   5000. 105000.]\n",
            "The price of the bond is: 117060.41\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Normally you see the price of the bond expressed in a percentage of the face value."
      ],
      "metadata": {
        "id": "3JCmNWpYSkWe"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BHBdn21G6tsu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b3ab7cab-9d37-4467-bfa4-e5944eea99b1"
      },
      "source": [
        "print(f'Price as a percentage of the face value: {100 * bond_price / X:.2f}%')"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Price as a percentage of the face value: 117.06%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YX_Uqd7X3Qh-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "78f11c56-0a28-4cde-b840-40522814c99c"
      },
      "source": [
        "payment_series"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([     0.,   5000.,   5000.,   5000.,   5000.,   5000.,   5000.,\n",
              "         5000.,   5000.,   5000., 105000.])"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ShQGcRze8pCW"
      },
      "source": [
        "The interest rate $r$ is also known as the **yield** of the bond. There is an inverse relation between yield and price! Why?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Pricing with variable rates\n",
        "\n",
        "So far we have seen payment series when the interest rate is fixed. However, in real life the discount rate we use is related to the bond rate of the Canadian sovereign, or another type of discount factor. For this, we must use a pricing function that takes into account the interest rate series.\n",
        "\n",
        "Let's consider an annual bond with the following characteristics:\n",
        "\n",
        "- Principal \\$100,000.\n",
        "- Yearly coupons, coupon rate $c = 5\\%$.\n",
        "- Spread $s = 2\\%$.\n",
        "- Sovereign rate: random value between 1% and 3%.\n",
        "- Maturity = 10 years\n",
        "\n",
        "Let's price this bond with a general function."
      ],
      "metadata": {
        "id": "9beFZeOGTmRg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def bond_price_variable_rate(coupon_rate, discount_rates, time_to_maturity):\n",
        "  import numpy_financial as npf\n",
        "  import numpy as np\n",
        "\n",
        "  # Payment sequence\n",
        "  payment_series = np.repeat(1, time_to_maturity + 1) # Coupon payments\n",
        "  payment_series[0] = 0 # no payment at first.\n",
        "  payment_series = payment_series* coupon_rate # Every payment date you get the coupon\n",
        "  payment_series[time_to_maturity]  += 1 # Last payment includes the principal.\n",
        "\n",
        "  # Calculate NPV\n",
        "  discounted_series = [x / (1 + y) ** i for i, [x, y] in enumerate(zip(payment_series, discount_rates))]  \n",
        "  #print(discounted_series)\n",
        "\n",
        "  # Calculate price\n",
        "  price = np.sum(discounted_series)\n",
        "  return price"
      ],
      "metadata": {
        "id": "_4bUl05aU-hX"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we can calculate our bond price. First, let's calculate the rates under the conditions that we decided."
      ],
      "metadata": {
        "id": "gBwpYfwSaqG2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "coupon_rate = 0.05\n",
        "spread = 0.02\n",
        "maturity = 10\n",
        "sovereign_low = 0.01\n",
        "sovereign_high = 0.03\n",
        "sovereign_series = np.random.uniform(low=sovereign_low,\n",
        "                                     high=sovereign_high,\n",
        "                                     size=maturity + 1)\n",
        "discount_rates = sovereign_series + spread\n",
        "discount_rates[0] = 0\n",
        "discount_rates"
      ],
      "metadata": {
        "id": "3Y5lDNbzXelm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4b69f3b6-75c6-4069-e532-48005016a67d"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.        , 0.04951595, 0.03595393, 0.0350134 , 0.04217286,\n",
              "       0.03665193, 0.03110246, 0.04846811, 0.04818509, 0.04463943,\n",
              "       0.03708346])"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "And finally, we can call our function to price the bond."
      ],
      "metadata": {
        "id": "ZEzbGrPVaxLy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bond_price_variable_rate(coupon_rate, discount_rates, maturity)"
      ],
      "metadata": {
        "id": "0e606Z88Y3FA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1d71bf18-3ff9-4b91-a7f2-a02710fbcde7"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.098589273594758"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The price obtained (which will change as the sovereign rates are random) is a percentage of the face value. The final price is this value multiplied by the face value. Can you calculate the price after 3 years have passed? How does it change?"
      ],
      "metadata": {
        "id": "2cJtS1A5aezd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Yield-to-maturity\n",
        "\n",
        "A useful measure is the yield to maturity of the bond, or the maximum interest rate which we should get in order to have a net present value of 0. This is the same as the Internal Return Rate. Again, if the time between payments is fixed, we can use numpy's [```npf.irr```](https://numpy.org/doc/1.17/reference/generated/numpy.irr.html) function. This function simply receives payments, but we need to add the original investment.\n",
        "\n",
        "A general way to solve this is to solve the equation behind the YTM. The equation is:\n",
        "\n",
        "$$\n",
        "P_{0,paid} - P_{0,CurrentRates} = 0\n",
        "$$\n",
        "\n",
        "To solve the equation we will use Scipy's [```fsolve```](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fsolve.html) function from the subpackage ```optimize```. This requires we first code the function we want to give to the package to solve (always in the form $f(x) = 0$ and then give a first guess on where the solution is. Let's assume the bond traded at an original price of \\$95,000."
      ],
      "metadata": {
        "id": "nohHa89cTj9A"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wGUpcoEA9rAR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2106e807-f63e-4b7b-9ad7-3356176dc686"
      },
      "source": [
        "from scipy.optimize import fsolve\n",
        "\n",
        "# Function to solve \n",
        "def YTM_equation(Porig, r, c, FV, M):\n",
        "  # Payment sequence\n",
        "  payment_series = np.repeat(c * FV, M + 1) # Coupon payments\n",
        "  payment_series[0] = -1 * Porig # At t = 0 we buy the bond.\n",
        "  payment_series[M]  += FV # Last payment includes the principal.\n",
        "\n",
        "  sol = npf.npv(r, payment_series)\n",
        "  return(sol)\n",
        "\n",
        "# Solve the equation\n",
        "ytm_bond = fsolve(lambda x : YTM_equation(r = x, Porig = 95000, FV = 100000, c = 0.05, M = 10), # Lambda function to give other arguments. \n",
        "           x0 = 0, # Initial guess\n",
        "           xtol=1.49012e-08 # Tolerance. If failing to converge play around with this\n",
        "           )\n",
        "\n",
        "# Print the value. the '.item()' is needed as the fsolve function delivers an array\n",
        "print(f'The yield to maturity is equal to {100 * ytm_bond.item():.2f}%')\n"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The yield to maturity is equal to 5.67%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dt9lYSvP-fcb"
      },
      "source": [
        "Our YTM is higher than the coupon rate of the bond (5.67% vs 5%). Why? Play around with these quantities to observe the relationship between prices and yields."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zh3KOmK72A-K"
      },
      "source": [
        "### Clean and dirty bond prices\n",
        "\n",
        "The final step in this bond price section is to get the **clean price** of the bond. A coupon-based bond will have different price as coupons are repaid, so large drops in value are expected after each payment.\n",
        "\n",
        "Let's plot the different bond values as time advances, for a 10-year bond with principal 100000 and yearly coupons with rate 5%, in a market with rate 3%. We need to calculate the bond price as we receive payments, and we will interpolate the value between different payment periods using a monthly base."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "obbCbMCJ5x7I",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 267
        },
        "outputId": "d0daa67f-8185-4b2f-fcaa-ca7d354fc4e4"
      },
      "source": [
        "# Payment sequence\n",
        "payment_series = np.repeat(0.0, 12*11) # First year no payments.\n",
        "payment_series[0] = 0 # At t = 0 we buy the bond.\n",
        "payment_series[131]  += 100000 # Last payment with principal.\n",
        "\n",
        "# Change only every 12th value, starting from the 12th.\n",
        "payment_series[11::12] += 100000*0.05\n",
        "\n",
        "# Calculate the value series. We to apply the npv function moving each starting point one month.\n",
        "# We will use a list comprehension.\n",
        "value_series = [npf.npv(0.03/12, payment_series[i:]) / (1 + 0.03 / 12) ** i for i in range(0, 131)]\n",
        "\n",
        "# Finally we plot the bond value\n",
        "plt.plot(value_series)\n",
        "plt.show()"
      ],
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BKrOLYQcBE8i"
      },
      "source": [
        "Note the ```(start):(end):(step)``` notation for indexing, and the use of [list comprehensions](https://www.programiz.com/python-programming/list-comprehension), a very powerful Python notation system."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uxbz7jH_DYK7"
      },
      "source": [
        "What's happening here? Why does the price move up and down like this?\n",
        "\n",
        "This series is the **dirty price** of the bond, and is the price you would pay if you were to buy it in the market.\n",
        "\n",
        "We would like to discount this value so we get a flat price. This is the **clean price** of the bond. The movements occur due to the next coupon, so we will eliminate the proportion of the coupon already earned. Considering coupons with $M$ months already gone by, then:\n",
        "\n",
        "$$\n",
        "P_{clean}  = P_{dirty} - \\frac{C * M}{12}\n",
        "$$\n",
        "\n",
        "Let's calculate the clean series and then recalculate the bond price. We can again use a list comprehension in a more complex format.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z-KubHfvEvOX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 266
        },
        "outputId": "af808f80-2c8a-4edc-a6a4-7f077d0f8f80"
      },
      "source": [
        "C = 100000*0.05\n",
        "clean_price = [w - (C * (i % 12)) / 12 for i, w in enumerate(value_series)]\n",
        "\n",
        "plt.plot(clean_price)\n",
        "plt.plot(value_series)\n",
        "plt.legend(['Clean price', 'Dirty price'])\n",
        "plt.show()"
      ],
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fvIhhPhAFi39"
      },
      "source": [
        "Several new concepts here:\n",
        "\n",
        "- The [```enumerate```](https://docs.python.org/3/library/functions.html#enumerate) function turns a series into an *iterable* (an object we can iterate through) with the format (index, value). So each element of the series is split into an index (the position) and the value of the element. We then assign this to i and w when we write ```i,w in enumerate(value_series)```.\n",
        "\n",
        "- We add a [modulo](https://python-reference.readthedocs.io/en/latest/docs/operators/modulus.html) function, which gives us the reminder of the division between i and 12. It is represented by a percentage in Python.\n",
        "\n",
        "And this gives us the clean price, which represents a simplified way to assign the value of the coupon between buyer and seller. We do this for simplicity."
      ]
    }
  ]
}