Tennis_match_simulator.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Tennis_match_simulator.ipynb",
      "version": "0.3.2",
      "views": {},
      "default_view": {},
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "metadata": {
        "id": "1OuxDx4DJuZF",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "# Tennis Match Simulation Problem"
      ]
    },
    {
      "metadata": {
        "id": "Omx6W2fmJ16y",
        "colab_type": "toc"
      },
      "cell_type": "markdown",
      "source": [
        ">[Tennis Match Simulation Problem](#updateTitle=true&folderId=1I6abHxBfYUvjHkeR_NTOIAxOrl74iEy2&scrollTo=1OuxDx4DJuZF)\n",
        "\n",
        ">>>[Theoretical Probability of winning a single game](#updateTitle=true&folderId=1I6abHxBfYUvjHkeR_NTOIAxOrl74iEy2&scrollTo=RHP2gBkgIbeW)\n",
        "\n",
        ">>>[Let's simulate and check if the result is correct](#updateTitle=true&folderId=1I6abHxBfYUvjHkeR_NTOIAxOrl74iEy2&scrollTo=mA-gKU3SIeij)\n",
        "\n",
        ">>[Simulate who wins a tie-breaker](#updateTitle=true&folderId=1I6abHxBfYUvjHkeR_NTOIAxOrl74iEy2&scrollTo=OGM6KgDzIlRN)\n",
        "\n",
        ">>[Simulate who wins a single set](#updateTitle=true&folderId=1I6abHxBfYUvjHkeR_NTOIAxOrl74iEy2&scrollTo=DR5AruJ3I2wF)\n",
        "\n",
        ">>[Simulate the result of a match](#updateTitle=true&folderId=1I6abHxBfYUvjHkeR_NTOIAxOrl74iEy2&scrollTo=Pohk0_zwJGLb)\n",
        "\n",
        ">>>[Simulate the probability of player winning a match and its confidence interval](#updateTitle=true&folderId=1I6abHxBfYUvjHkeR_NTOIAxOrl74iEy2&scrollTo=xCt_8tSsJao9)\n",
        "\n"
      ]
    },
    {
      "metadata": {
        "id": "wceUg-31IHBp",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "We are interested in predicting tennis matches. While there are several approaches to do this, we want to take a point-by-point approach. Assume that a player's serve is iid. Let $p_{s1}$ be the probability that a player 1 will win a point on his serve and $p_{s2}$ the probability that player 2 will win a point on his serve. If one player wins a point, the other player has to lose a point so the probability of winning a return for player 1 is just $p_{r1} = 1 - p_{s2}$. We can therefore forget about return probabilities. While you can work out the probability of winning a match with recursive equation and a bit of combinatorics, we want to simulate this instead. We will that all sets at 6 games each end in tiebreaks and we play best of 3 sets. If you are less familiar with tennis, you can find the rules here : https://en.wikipedia.org/wiki/Tennis_scoring_system\n",
        "\n",
        "1. Write an algorithm to simulate the probability of winning the match for probabilities $p_{s1}$ and $p_{s2}$. You should have a function addPoint(player) that adds one point for a player. You could use an integer for player and just let `'1'` designate player 1 and `'2'` player 2. You should have a function addPoints(points) that takes an array/vector of points and adds them in sequence. You can follow the above format. Finally you should have a function getScore() that prints the score. It should be in the format 40-15 | 6:3 6:7 3:3, i.e. for games in progress and tiebreaks, list the player serving first. For sets ( whether in progress or completed), list player 1 first and then player 2. \n",
        "\n",
        "2. What are the probabilities of winning the match with $p_{s1} = 0.64$ and $p_{s2} = 0.62$? How many runs do you need? What is your confidence interval?\n",
        "\n",
        "3. Let's expand the simulation. Assume the probability of winning the point changes on `'big points'`. A `'big point'` is defined as a point that can win you a game or set (so includes set points in tie breaks). So we add the probabilities $p_{s1, B}$ and $p_{s2, B}$ as the probability that a player will win his point on serve on big point. Otherwise the probabilities remain $p_{s1}$ and $p_{s2}$. \n"
      ]
    },
    {
      "metadata": {
        "id": "zLtEloLkIFnx",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "import random\n",
        "import numpy as np\n",
        "\n",
        "def play_a_single_game(ps, psB = None):\n",
        "  \"\"\"\n",
        "  Function to check if a given player with 'ps' chances of winning a \n",
        "  given point wins a single game. \n",
        "  \n",
        "  Input : \n",
        "  ----------------\n",
        "  ps - probability of server winning a single point \n",
        "  psB - probability of winning a big point with default None\n",
        "  \n",
        "  Output : \n",
        "  ----------------\n",
        "  a list of list like [1, [40,30]] where\n",
        "  \n",
        "  first element --- whether she wins a single game or not\n",
        "  second element --- score of the current game \n",
        "  \"\"\"\n",
        "  # set their respective points to zero; here we will \n",
        "  # represent 0 by 0, 15 by 1, 30 by 2 and 40 by 3 and 40+ by 4. \n",
        "  # I store this dictionary for finally returning the score of the game\n",
        "  # note that I denote 40+ score by 4 as well \n",
        "  score_dict = {0:0, 1:15, 2:30, 3:40, 4:40} \n",
        "  score1 = 0 \n",
        "  score2 = 0\n",
        "  # set the big point probabilities to original if not provided\n",
        "  psB = ps if psB is None else psB\n",
        "  \n",
        "  while True:\n",
        "    # change the original probability to big point probability \n",
        "    # if it is the game point i.e 40 for the server\n",
        "    ps = psB if score1 == 3 else ps \n",
        "    # simulate the bernoulli trial for the given player \n",
        "    # and check if she wins a point or not\n",
        "    if random.random() < ps:\n",
        "      # if she wins a point increment her score by 1\n",
        "      score1 += 1\n",
        "    else:\n",
        "      # otherwise increment the score of her opponent\n",
        "      score2 += 1\n",
        "    # print score1,'-', score2\n",
        "    # winning condition for the given player \n",
        "    if score1 >= 4 and (score1-score2) >= 2: \n",
        "      # if the score of first player is 4 and the difference \n",
        "      # between the score of two players \n",
        "      return [1, [score_dict[score1], score_dict[score2]]]\n",
        "    # winning condition for the opponent of the given player\n",
        "    elif score2 >= 4 and (score2-score1) >= 2:\n",
        "      return [0, [score_dict[score1], score_dict[score2]]]\n",
        "   # if there is deuce or advantage score e.g. 6-5,\n",
        "  # we bring it to a score like 3-2 since this is equivalent\n",
        "    while True:\n",
        "      if (score1 + score2) > 6:\n",
        "        # we set the original probability to big point prob\n",
        "          ps = psB\n",
        "          score1 -= 1\n",
        "          score2 -= 1\n",
        "      else:   \n",
        "        break"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "EX4-SCuNIUPc",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "random.seed(100)\n",
        "play_a_single_game(0.64)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "RHP2gBkgIbeW",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Theoretical Probability of winning a single game"
      ]
    },
    {
      "metadata": {
        "id": "5CR0TwFjIZ9r",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "# I have created below function to check my above code \n",
        "\n",
        "def actual_probability_of_winning_game(ps):\n",
        "  \"\"\"\n",
        "  Function computes the actual probability of a server winning a game \n",
        "  if the probability of winning a single point is known.\n",
        "  \n",
        "  Input : ps - probability of server winning a single point \n",
        "  \n",
        "  Output : the probability of winning a game   \n",
        "  \n",
        "  citation \n",
        "  ---------------------------\n",
        "  https://pdfs.semanticscholar.org/e870/8ca24b8f67476b3284ec22ccb689dc6229be.pdf\n",
        "  \n",
        "  Probability of Winning at Tennis I. Theory and Data\n",
        "  By Paul K. Newton and Joseph B. Keller\n",
        "  \"\"\"\n",
        "  result = ps**4 + 4*(ps**4)*(1-ps) + 10*(ps**4)*(1-ps)**2 + 20*(ps**5)*((1-ps)**3)/(1-2*ps*(1-ps))\n",
        "  return result"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "mA-gKU3SIeij",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Let's simulate and check if the result is correct"
      ]
    },
    {
      "metadata": {
        "id": "QPgCokUXIhTM",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "# Lets do some simulations and check if the simulated result is close to the \n",
        "# theoretical probability\n",
        "n = 10000000\n",
        "x = range(n)\n",
        "for i in range(n):\n",
        "  x[i] = play_a_single_game(0.9)[0]\n",
        "\n",
        "# calculate the empirical probability of winning a single game \n",
        "p_hat = sum(x)/float(n)\n",
        "# calculate the corresponding standard deviation\n",
        "sd = np.sqrt(p_hat*(1-p_hat)/float(n))\n",
        "\n",
        "print 'The simulated probability is ', p_hat ,' with standard error ', sd, '\\n'\n",
        "\n",
        "print \"The 95 percent confidence interval for the true value of p is (%5f, %5f)\" %(p_hat - 1.96*sd, p_hat + 1.96*sd),'\\n'\n",
        "\n",
        "print 'The actual probability is ', actual_probability_of_winning_game(0.9)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "OGM6KgDzIlRN",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "> We can observe from the above empirical finding that the 95% confidence interval contains the true value of probability of winning a game. This empirical evidence suggests that the above simulation of a game is correct.\n",
        "\n",
        "## Simulate who wins a tie-breaker"
      ]
    },
    {
      "metadata": {
        "id": "Adl2tx-ZIoYo",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "def play_a_tiebreaker(ps1, ps2, server = 1):\n",
        "  \"\"\"\n",
        "  Function simulates the result of a tie-breaker game and returns if\n",
        "  player 1 has won the tie-breaker or not. Here I am assuming that a\n",
        "  tie-breaker consists of 7-points and a player wins a tie-breaker if \n",
        "  she wins by a difference of 2 points. Here points are counted as 0,\n",
        "  1,2,3,4,5,6,7.\n",
        "  \n",
        "  Input : \n",
        "  --------------------\n",
        "  ps1 - probability of player 1 winning a single point if she serves\n",
        "  ps2 - probability of player 2 winning a single point if she serves \n",
        "  server - a bool representing who is serving at the start of the tie breaker.\n",
        "  \n",
        "  Output :\n",
        "  --------------------\n",
        "  Returns 1/0 representing if player 1 wins a given tie breaker. \n",
        "  \n",
        "  \"\"\"\n",
        "  # set \n",
        "  next_set_server = 2 if server == 1 else 1\n",
        "  # set their respective points to zero;  \n",
        "  tiebreaker_score1 = 0 \n",
        "  tiebreaker_score2 = 0\n",
        "  while True:\n",
        "    if server == 1: \n",
        "      # check if player 1 is serving and \n",
        "      # next check if she won the game \n",
        "      if random.random() < ps1:\n",
        "        # increment her score by 1 \n",
        "        tiebreaker_score1 += 1\n",
        "        # and change the server to player 2\n",
        "        server = 2\n",
        "      else:\n",
        "        # if player 1 did not win the game then increment player 2 score\n",
        "        tiebreaker_score2 += 1\n",
        "        # since player 1 was serving, we allot serve to player 2\n",
        "        server = 2\n",
        "    else:\n",
        "      # if player 2 is serving then check if she won the game and store the \n",
        "      if random.random() < ps2:\n",
        "        # if she won the game then increment her score by 1\n",
        "        tiebreaker_score2 += 1\n",
        "        # change the server to player 1\n",
        "        server = 1\n",
        "      else:\n",
        "        # if player 2 did not win the game then increment the score of player 2\n",
        "        tiebreaker_score1 += 1\n",
        "        # allot serve to player 1\n",
        "        server = 1\n",
        "    # print tiebreaker_score1, '-', tiebreaker_score2\n",
        "    if tiebreaker_score1 >= 7 and (tiebreaker_score1-tiebreaker_score2) >= 2:\n",
        "        return 1\n",
        "    elif tiebreaker_score2 >= 7 and (tiebreaker_score2-tiebreaker_score1) >= 2:\n",
        "        return 0\n",
        "    # if the tie breaker score become something like 8:7 then we bring it back\n",
        "    # to 6:5 for simplicity. These two scores are equivalent.\n",
        "    while True:\n",
        "        if (tiebreaker_score1+tiebreaker_score2) > 12:\n",
        "            tiebreaker_score1 -= 1\n",
        "            tiebreaker_score2 -= 1\n",
        "        else:   \n",
        "          break"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "ncpYcSIYI2GU",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "# play a tie-breaker game \n",
        "play_a_tiebreaker(0.64, 0.62, server=1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "DR5AruJ3I2wF",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Simulate who wins a single set"
      ]
    },
    {
      "metadata": {
        "id": "lfriiMubI5bp",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "def play_a_single_set(ps1, ps2, ps1B = None, ps2B = None, server = 1):\n",
        "  \"\"\"\n",
        "  Function checks if a server wins a given set. \n",
        "  \n",
        "  Input : \n",
        "  --------------------\n",
        "  ps1 - probability of player 1 winning a single point if she serves\n",
        "  ps2 - probability of player 2 winning a single point if she serves \n",
        "  ps1B - probability of player 1 winning a big point with default None\n",
        "  ps2B - probability of player 2 winning a big point with default None\n",
        "  server - a bool representing who is serving at the start of the set.\n",
        "  \n",
        "  Output : a list of lists consisting like [0, [40, 30], [6, 7], 1]\n",
        "  --------------------\n",
        "  first element  : outcome of the set if first player wins or not\n",
        "  second element : score of the last game played \n",
        "  third element  : score of the current set \n",
        "  fourth element : who will be serving next 1 for player 1 and 2 for player 2.\n",
        "  --------------------\n",
        "  Therefore [0, [40, 30], [6, 7], 1] means that first player lost current set \n",
        "  to player 2 with a score of 6-7 while in the last game they played, the score\n",
        "  was 40:30 which was won by player 2, therefore next turn to serve is of player 1.\n",
        "  \"\"\"\n",
        "  # set big point probabilities if not provided \n",
        "  ps1B = ps1 if ps1B is None else ps1B\n",
        "  ps2B = ps2 if ps2B is None else ps2B\n",
        "  \n",
        "  # set the initial set score of each player to zero\n",
        "  set_score1 = 0\n",
        "  set_score2 = 0\n",
        "  # repeat until a result is obtained \n",
        "  while True:\n",
        "    if server == 1: \n",
        "      # check if player 1 is serving and save the outcome of her game\n",
        "      check_if_won_game = play_a_single_game(ps1, ps1B)\n",
        "      # print check_if_won_game[1]\n",
        "      # next check if she won the game \n",
        "      if check_if_won_game[0] == 1:\n",
        "        # increment her score by 1 \n",
        "        set_score1 += 1\n",
        "        # and change the server to player 2\n",
        "        server = 2\n",
        "      else:\n",
        "        # if player 1 did not win the game then increment player 2 score\n",
        "        set_score2 += 1\n",
        "        # since player 1 was serving, we allot serve to player 2\n",
        "        server = 2\n",
        "    else:\n",
        "      # if player 2 is serving then check if she won the game and store the \n",
        "      # result of the game if she is serving\n",
        "      check_if_won_game = play_a_single_game(ps2, ps2B)\n",
        "      # print check_if_won_game[1]\n",
        "      # check if she won the game \n",
        "      if check_if_won_game[0] == 1:\n",
        "        # if she won the game then increment her score by 1\n",
        "        set_score2 += 1\n",
        "        # change the server to player 1\n",
        "        server = 1\n",
        "      else:\n",
        "        # if player 2 did not win the game then increment the score of player 2\n",
        "        set_score1 += 1\n",
        "        # allot serve to player 1\n",
        "        server = 1\n",
        "    # print set_score1,'-', set_score2\n",
        "    # check if a tie break has occurred \n",
        "    if set_score1 == 6 and set_score2 == 6:\n",
        "      # if it is a tie break then play a tie break with big point probabilities\n",
        "      result_tiebreaker = play_a_tiebreaker(ps1B, ps2B, server)\n",
        "      # change the server after the tie breaker is over \n",
        "      server = 2 if server == 1 else 1\n",
        "      # if player 1 has won the tie breaker then increment her score by 1 and\n",
        "      # return 1\n",
        "      if result_tiebreaker == 1:\n",
        "        set_score1 += 1\n",
        "        # return player 1 won the set together with score of last game played\n",
        "        # set scores of two players and whose turn is it to serve next\n",
        "        return [1, check_if_won_game[1],[set_score1, set_score2], server]\n",
        "      # if player 1 did not win then increment score of player 2 and return 0\n",
        "      # together with set scores, and the next server\n",
        "      else:\n",
        "        set_score2 += 1\n",
        "        return [0,check_if_won_game[1], [set_score1, set_score2], server]\n",
        "    # check if the game is already over and player 1 has won it then \n",
        "    # return 1 together with scores mentioned above.\n",
        "    if set_score1 >= 6 and (set_score1-set_score2) >= 2:\n",
        "      return [1, check_if_won_game[1], [set_score1, set_score2], server]\n",
        "    # if player 2 won it then do similarly \n",
        "    elif set_score2 >= 6 and (set_score2-set_score1) >= 2:\n",
        "      return [0,check_if_won_game[1], [set_score1, set_score2], server]\n",
        "    # if score becomes something like 8:7 then bring it back to 6:5 since the \n",
        "    # two scores are equivalent\n",
        "    while True:\n",
        "      if (set_score1 + set_score2) > 12:\n",
        "        # since this must have been a tie-breaker situation therefore we turn on\n",
        "        # the big probabilities namely \n",
        "        ps1 =  ps1B \n",
        "        ps2 =  ps2B\n",
        "        # decrement the scores of 8:7 to 6:5 which is equivalent\n",
        "        set_score1 -= 1\n",
        "        set_score2 -= 1\n",
        "      else:\n",
        "        break         "
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "FuyhVQTLJCaR",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "> In the result below we simulate a set where player 1 lost the set 4-6 to player 2 while it is player 2 turn to serve next. The result of their last game where player 1 was serving was 15:40 where player 1 lost to player 2."
      ]
    },
    {
      "metadata": {
        "id": "ieQsFXfqJDQj",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "random.seed(100)\n",
        "play_a_single_set(0.64,0.62,2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "Pohk0_zwJGLb",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "## Simulate the result of a match"
      ]
    },
    {
      "metadata": {
        "id": "gBkZFI9-JJt6",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "def play_a_match(ps1, ps2, ps1B = None, ps2B = None, server = 1, no_of_sets = 3):\n",
        "  \"\"\"\n",
        "  Function simulates a match and returns if player 1 won the match or not\n",
        "  \n",
        "  Input : \n",
        "  --------------------\n",
        "  ps1 - probability of player 1 winning a single point if she serves\n",
        "  ps2 - probability of player 2 winning a single point if she serves \n",
        "  ps1B - probability of player 1 winning a big point with default None\n",
        "  ps2B - probability of player 2 winning a big point with default None\n",
        "  server - a bool representing who is serving at the start of the match.\n",
        "  no_of_sets - total number of sets in the match default value 3.\n",
        "  \n",
        "  Output :\n",
        "  --------------------\n",
        "  Returns a list of list consisting of the following :\n",
        "  first element  : 1/0 representing if player 1 wins this match or not. \n",
        "  second element : the result of last game where current server is listed first\n",
        "  next element   : the scores of the sets played between them [score1, score2]\n",
        "  \"\"\"\n",
        "  # set the big probabilities to original prob if not supplied\n",
        "  ps1B = ps1 if ps1B is None else ps1B\n",
        "  ps2B = ps2 if ps2B is None else ps2B\n",
        "  # set the number of sets won by each player to 0\n",
        "  no_of_sets_won1 = 0\n",
        "  no_of_sets_won2 = 0\n",
        "  # container to store the result of each set.\n",
        "  sets = []\n",
        "  # container to store the result of last game \n",
        "  last_game_result = []\n",
        "  # loop over all number of sets until a player has won the match\n",
        "  for i in range(no_of_sets):\n",
        "    # play individual sets and store the result \n",
        "    set_result = play_a_single_set(ps1, ps2, ps1B, ps2B, server)\n",
        "    # store the result of last set played \n",
        "    sets.append(set_result[2])\n",
        "    # store the result of the last game played \n",
        "    last_game_result = set_result[1]\n",
        "    # set who will be serving next \n",
        "    server = set_result[3]\n",
        "    # increase the counter of number of sets won by each player \n",
        "    no_of_sets_won1 += set_result[0]\n",
        "    # if player 1 wins a set then player 2 win 1-1 = 0 set \n",
        "    no_of_sets_won2 += 1-set_result[0]\n",
        "    # exit if one of them reaches to 2 sets win\n",
        "    if(no_of_sets_won1==2 or no_of_sets_won2==2):\n",
        "      break\n",
        "  match_result = (no_of_sets_won1 > no_of_sets_won2)*1\n",
        "  return [match_result, last_game_result, sets]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "zeae1G4-JRw1",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        ">The output below is a simulated match between player 1 and player 2 where player 1 won that match with scores of 6:2, 2:6 and 6:3 while the result of the last game between then was 40-15."
      ]
    },
    {
      "metadata": {
        "id": "Eo9qRg4nJPZL",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "random.seed(100)\n",
        "play_a_match(0.64,0.62, 0.64,0.62)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "RWx-DsVgJXBn",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "def get_score_of_match(ps1, ps2, ps1B = None, ps2B = None, server = 1, no_of_sets = 3):\n",
        "  \"\"\"\n",
        "  A wrapper function for play_a_match() which outputs the result of a tennis match in a nice fashion \n",
        "  \n",
        "  Input : similar to play_a_match (refer above for more details )\n",
        "  \n",
        "  Output : prints the result on screen for player 1\n",
        "  \"\"\"\n",
        "  # get the match result and store it \n",
        "  m = play_a_match(ps1,ps2,ps1B, ps2B, server, no_of_sets)\n",
        "  # extract the individual set scores \n",
        "  s = m[2]\n",
        "  if len(s)== no_of_sets -1:\n",
        "    print \"%d-%d | %d:%d %d:%d \" %(m[1][0], m[1][1],s[0][0], s[0][1], s[1][0], s[1][1] )\n",
        "  else:\n",
        "    print \"%d-%d | %d:%d %d:%d %d:%d\" %(m[1][0], m[1][1],s[0][0], s[0][1], s[1][0], s[1][1],s[2][0], s[2][1] )"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "rUys_oDEJYF8",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "# print the score in a nice fashion\n",
        "get_score_of_match(0.64,0.62)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "metadata": {
        "id": "xCt_8tSsJao9",
        "colab_type": "text"
      },
      "cell_type": "markdown",
      "source": [
        "### Simulate the probability of player winning a match and its confidence interval"
      ]
    },
    {
      "metadata": {
        "id": "Nw9hWtK6JeXO",
        "colab_type": "code",
        "colab": {
          "autoexec": {
            "startup": false,
            "wait_interval": 0
          }
        }
      },
      "cell_type": "code",
      "source": [
        "# We set the number of simulation to a large value for the central limit \n",
        "# theorem to hold\n",
        "n = 1000000\n",
        "x = [play_a_match(0.64, 0.62, 0.64,0.62)[0] for i in range(n)]\n",
        "\n",
        "# get the estimated value of the probability of winning a match \n",
        "p_hat = sum(x)/float(n)\n",
        "\n",
        "# calculate the standard error of p_hat\n",
        "sd = np.sqrt(p_hat*(1-p_hat)/float(n))\n",
        "\n",
        "print 'The simulated probability is ', p_hat ,' with standard error ', sd, '\\n'\n",
        "\n",
        "print 'The 95 percent confidence interval of the actual probability is (%5f, %5f)'%(p_hat - 1.96*sd, p_hat + 1.96*sd)"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}