Expectiminimax.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import itertools\n",
    "from operator import mul\n",
    "from functools import reduce\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import json\n",
    "import re\n",
    "import webbrowser\n",
    "import os\n",
    "import copy\n",
    "import math\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## CONSTANTS ##\n",
    "\n",
    "# POSSESSIONS\n",
    "OUR_POSS = 1\n",
    "OPP_POSS = 2\n",
    "\n",
    "# MOVE TYPES\n",
    "OFFENSIVE = 1\n",
    "DEFENSIVE = 2\n",
    "\n",
    "# LEAGUE AVERAGES\n",
    "LEAGUE_AVE_THREE_PERC = 0.362\n",
    "LEAGUE_AVE_TWO_PERC = 0.510\n",
    "LEAGUE_AVE_FT_PERC = 0.767\n",
    "\n",
    "# DECREASING FACTORS\n",
    "QUICK_PERC_DECREASE = 0.03 # 3% decrease in percentage if it is a quick shot\n",
    "\n",
    "# TIME CONSUMPTION OF MOVES (IN SECS)\n",
    "QUICK_TIME_CONS = (4 + 10) / 2 # The mean of the range of 4 to 10 we consider a quick shot \n",
    "SLOW_TIME_CONS = (11 + 24) / 2 # The mean of the range of 11 to 24 we consider a slow shot \n",
    "FOUL_TIME_CONS = 2\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                      Team    3P%    2P%    FT%  3P% Defense  2P% Defense\n",
      "0            Atlanta Hawks  0.360  0.495  0.785        0.377        0.520\n",
      "1           Boston Celtics  0.377  0.491  0.771        0.339        0.488\n",
      "2            Brooklyn Nets  0.356  0.500  0.772        0.369        0.503\n",
      "3        Charlotte Hornets  0.369  0.487  0.747        0.375        0.516\n",
      "4            Chicago Bulls  0.355  0.478  0.758        0.370        0.534\n",
      "5      Cleveland Cavaliers  0.372  0.540  0.779        0.368        0.533\n",
      "6         Dallas Mavericks  0.360  0.496  0.763        0.363        0.526\n",
      "7           Denver Nuggets  0.371  0.525  0.766        0.378        0.525\n",
      "8          Detroit Pistons  0.373  0.488  0.745        0.359        0.515\n",
      "9    Golden State Warriors  0.391  0.560  0.815        0.357        0.490\n",
      "10         Houston Rockets  0.362  0.558  0.781        0.351        0.519\n",
      "11          Indiana Pacers  0.369  0.513  0.779        0.349        0.530\n",
      "12    Los Angeles Clippers  0.354  0.525  0.743        0.356        0.512\n",
      "13      Los Angeles Lakers  0.345  0.517  0.714        0.346        0.512\n",
      "14       Memphis Grizzlies  0.352  0.486  0.786        0.368        0.516\n",
      "15              Miami Heat  0.360  0.508  0.755        0.360        0.491\n",
      "16         Milwaukee Bucks  0.355  0.531  0.782        0.372        0.513\n",
      "17  Minnesota Timberwolves  0.357  0.519  0.804        0.366        0.534\n",
      "18    New Orleans Pelicans  0.362  0.540  0.772        0.355        0.503\n",
      "19         New York Knicks  0.352  0.504  0.787        0.368        0.505\n",
      "20   Oklahoma City Thunder  0.354  0.505  0.715        0.367        0.511\n",
      "21           Orlando Magic  0.351  0.504  0.757        0.362        0.516\n",
      "22      Philadelphia 76ers  0.369  0.526  0.752        0.342        0.482\n",
      "23            Phoenix Suns  0.334  0.492  0.740        0.373        0.519\n",
      "24  Portland Trail Blazers  0.366  0.493  0.800        0.364        0.484\n",
      "25        Sacramento Kings  0.375  0.479  0.735        0.377        0.527\n",
      "26       San Antonio Spurs  0.352  0.499  0.772        0.348        0.501\n",
      "27         Toronto Raptors  0.358  0.541  0.794        0.357        0.486\n",
      "28               Utah Jazz  0.366  0.515  0.779        0.365        0.488\n",
      "29      Washington Wizards  0.375  0.508  0.772        0.349        0.522\n"
     ]
    }
   ],
   "source": [
    "## IMPORT NBA LEAGUE DATA ##\n",
    "\n",
    "team_stats = pd.read_csv('data/teamstats.csv')\n",
    "team_names = team_stats[\"Team\"]\n",
    "print(team_stats)\n",
    "\n",
    "def create_team(team_name):\n",
    "    '''Given the team name it returns a Team object'''\n",
    "    stats = team_stats.loc[team_stats['Team'] == team_name]\n",
    "    \n",
    "    three_perc = stats.iloc[0][\"3P%\"]\n",
    "    two_perc = stats.iloc[0][\"2P%\"]\n",
    "    ft_perc = stats.iloc[0][\"FT%\"]\n",
    "    three_defen_perc = stats.iloc[0][\"3P% Defense\"]\n",
    "    two_defen_perc = stats.iloc[0][\"2P% Defense\"]\n",
    "    return Team(three_perc, two_perc, ft_perc, three_defen_perc, two_defen_perc)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Tree and Visualization Code ##\n",
    "\n",
    "class Node:\n",
    "    def __init__(self, name, parent=None):\n",
    "        self.name = name\n",
    "        self.parent = parent\n",
    "        self.children = []\n",
    "        self.optimal = False\n",
    "\n",
    "        if parent:\n",
    "            self.parent.children.append(self)\n",
    "            \n",
    "def convert_tree_to_dict(root, depth=8):\n",
    "    '''Given the root node, converts the tree into a dictionary. Depth is the maximum depth it can get.'''\n",
    "    \n",
    "    d = {\"name\": root.name, \"children\": [], \"optimal\": root.optimal}\n",
    "    if depth > 0:\n",
    "        for i, child in enumerate(root.children):\n",
    "            d[\"children\"].append(convert_tree_to_dict(child, depth-1))\n",
    "    return d\n",
    "\n",
    "def show_tree(tree_root, depth=8):\n",
    "    '''Given the root node, and maximum depth show the tree as an interactive webpage.'''\n",
    "    \n",
    "    f = open(\"tree.json\", \"w\")\n",
    "    f.write(json.dumps(convert_tree_to_dict(tree_root, depth)))\n",
    "    f.close()\n",
    "    webbrowser.open('file://' + os.path.realpath(\"index.html\"))\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## TEAM CLASS ##\n",
    "\n",
    "class Team:\n",
    "\n",
    "    def __init__(self, three_perc, two_perc, ft_perc, three_defen_perc, two_defen_perc):\n",
    "        self.three_perc = three_perc\n",
    "        self.two_perc = two_perc\n",
    "        self.ft_perc = ft_perc\n",
    "        self.three_defen_perc = three_defen_perc\n",
    "        self.two_defen_perc = two_defen_perc\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"3P%: \" + str(self.three_perc) + \", 2P%: \" + str(self.two_perc) + \", FT%: \" + str(self.ft_perc) + \", 3P% Def: \" + str(self.three_defen_perc) + \", 2P% Def: \" + str(self.two_defen_perc) \n",
    "\n",
    "    def get_two_perc_against(self, team2):\n",
    "        '''Given another team calculates the two point percentage of the team.'''\n",
    "        return self.two_perc * team2.two_defen_perc / LEAGUE_AVE_TWO_PERC\n",
    "\n",
    "    def get_three_perc_against(self, team2):\n",
    "        '''Given another team calculates the three point percentage of the team.'''\n",
    "        return self.three_perc * team2.three_defen_perc / LEAGUE_AVE_THREE_PERC\n",
    "\n",
    "    def get_ft_perc_against(self, team2):\n",
    "        '''Given another team calculates the two point percentage of the team.'''\n",
    "        return team2.ft_perc\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## PARENT CLASS OF STATES -> CHANCE AND GAME STATES ##\n",
    "\n",
    "class State:\n",
    "    def __init__(self):\n",
    "        \n",
    "        # Used in Chance State\n",
    "        self.probs = []\n",
    "        self.states = []\n",
    "        \n",
    "        # Used in Game State\n",
    "        self.team1 = None\n",
    "        self.team2 = None\n",
    "        self.score_diff = -1\n",
    "        self.time = -1\n",
    "        self.pos = -1\n",
    "        self.pos_type = -1\n",
    "        self.last_move = None\n",
    "\n",
    "    def is_chance_state(self):\n",
    "        pass\n",
    "\n",
    "    def is_gameover(self):\n",
    "        return False\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Chance State ##\n",
    "\n",
    "# Chance States contains all the undeterministic outtcomes of a move.\n",
    "# For example, if your move is to take a free throw, the chance state would contain all the Game States\n",
    "# where you { make first, miss second }, { miss first, miss second }, { miss first, make second }, \n",
    "# { make first, make second } and their corresponding probabilities.\n",
    "\n",
    "class ChanceState(State):\n",
    "    def __init__(self, probs, states, move=None):\n",
    "        self.probs = probs\n",
    "        self.states = states\n",
    "\n",
    "        # Initialized to dummy values (These are used in only Game State)\n",
    "        self.team1 = -1\n",
    "        self.team2 = -1\n",
    "        self.score_diff = -1\n",
    "        self.time = -1\n",
    "        self.pos = -1\n",
    "        self.pos_type = -1\n",
    "        self.last_move = move\n",
    "        \n",
    "    def __str__(self):\n",
    "        return str(self.last_move)\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return self.probs == other.probs and self.states == other.states\n",
    "\n",
    "    def __ne__(self, other):\n",
    "        return not self.__eq__(other)\n",
    "\n",
    "    def __hash__(self):\n",
    "        return sum(map(lambda state: hash(state), self.states)) * 3 + int(sum(self.probs) * 5)\n",
    "\n",
    "    def is_chance_state(self):\n",
    "        return True\n",
    "\n",
    "    def is_gameover(self):\n",
    "        return False\n",
    "\n",
    "    def get_state_prob(self, index):\n",
    "        return self.probs[index]\n",
    "\n",
    "    def get_child_states(self):\n",
    "        return  self.states\n",
    "    \n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Game State ##\n",
    "\n",
    "# Game States contains all the deterministic information of the state of the game.\n",
    "# It stores the two teams, score difference, time, possession, possession_type and\n",
    "# the last move that lead to this state.\n",
    "\n",
    "class GameState(State):\n",
    "\n",
    "    def __init__(self, team1, team2, score_diff, time, pos, pos_type=OFFENSIVE, move=None):\n",
    "        self.team1 = team1\n",
    "        self.team2 = team2\n",
    "        self.score_diff = score_diff\n",
    "        self.time = time\n",
    "        self.pos = pos\n",
    "        self.pos_type = pos_type\n",
    "        self.last_move = move\n",
    "        \n",
    "        # Initialized to dummy values\n",
    "        self.probs = []\n",
    "        self.states = []\n",
    "\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return self.team1 == other.team1 and self.team2 == other.team2 and self.score_diff == other.score_diff and self.time == other.time and self.pos == other.pos  and self.pos_type == other.pos_type\n",
    "\n",
    "    def __ne__(self, other):\n",
    "        return not self.__eq__(other)\n",
    "\n",
    "    def __str__(self):\n",
    "        '''String representation of the state that is shown in the interactive tree visualization.'''\n",
    "        \n",
    "        if self.is_gameover():\n",
    "            if self.score_diff > 0:\n",
    "                return \"We won by \" + str(self.score_diff)\n",
    "            elif self.score_diff == 0:\n",
    "                return \"We tied\"\n",
    "            else:\n",
    "                return \"We lost by \" + str(-1 * self.score_diff)\n",
    "        else:\n",
    "            if self.score_diff > 0:\n",
    "                score_text = \"up by \" + str(self.score_diff)\n",
    "            elif self.score_diff == 0:\n",
    "                score_text = \"tied\"\n",
    "            else:\n",
    "                score_text = \"down by \" + str(-1 * self.score_diff)\n",
    "                \n",
    "            if self.pos == 1:\n",
    "                pos_text = \"our\"\n",
    "            else:\n",
    "                pos_text = \"their\"\n",
    "            \n",
    "          \n",
    "            if self.pos_type == OFFENSIVE:\n",
    "                 pos_text += \" off.\"\n",
    "            else:\n",
    "                 pos_text += \" def.\"\n",
    "            \n",
    "            return str(self.time) + \" secs, \" + score_text + \", \" + pos_text + \" poss.\"\n",
    "    \n",
    "    def __hash__(self):\n",
    "        return self.score_diff * 3 + self.time * 5 + self.pos * 7\n",
    "\n",
    "    def get_heuristic_score(self):\n",
    "        '''Heuristic value given to the tree leaf.'''\n",
    "        \n",
    "        if self.score_diff <= 0:\n",
    "            return 0.0\n",
    "        else:\n",
    "            return 1.0\n",
    "\n",
    "    def is_gameover(self):\n",
    "        return self.time <= 0\n",
    "\n",
    "    def get_child_states(self):\n",
    "        return list(map(lambda move: move.get_chance_child(), self.get_available_moves()))\n",
    "\n",
    "    def get_available_moves(self):\n",
    "        \n",
    "        if self.pos_type == OFFENSIVE:\n",
    "            quick_three = ThreePointer(True, self)\n",
    "            slow_three = ThreePointer(False, self)\n",
    "            quick_two = TwoPointer(True, self)\n",
    "            slow_two = TwoPointer(False, self)\n",
    "            moves = [quick_three, slow_three, quick_two, slow_two]\n",
    "        elif self.pos_type == DEFENSIVE:  \n",
    "            not_foul = NotFoul(self)\n",
    "            foul = Foul(self)\n",
    "            moves = [foul, not_foul]\n",
    "        else:\n",
    "            print(\"SHOULDN'T BE HERE!\")\n",
    "        \n",
    "        return list(filter(lambda move: move.is_applyable(), moves))\n",
    "\n",
    "    def is_chance_state(self):\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Move Class ##\n",
    "\n",
    "# Move gets a Game State and outputs a Chance State.\n",
    "# It contains numeric information that corresponds to each type of move.\n",
    "# When apply is called, the Chance State is created according to these numeric description.\n",
    "# time_consump : The time it takes to execute the move.\n",
    "# occ_count: The number of occurance. (Free throw occurs two times for example.)\n",
    "# score_change : The ammount of score change when the move deterministically occurs.\n",
    "# type : Move type -> Offensive or Defensive move.\n",
    "# prob_func : A function that return the prob of this move to be occured given the two teams in the Game State.\n",
    "# pos_change : Bool value that the possession will change after the move.\n",
    "# pos_type_change : Bool value that the possession type will change after the move.\n",
    "\n",
    "class Move:\n",
    "\n",
    "    def __init__(self, game_state):\n",
    "        self.pos_change = True\n",
    "        self.pos_type_change = True\n",
    "        self.time_consump = 0\n",
    "        self.score_change = 0\n",
    "        self.occ_count = 0\n",
    "        self.prob_func = lambda x, y: x\n",
    "        self.game_state = game_state\n",
    "        self.type = OFFENSIVE\n",
    "\n",
    "    def __str__(self):\n",
    "        '''String representation of the move that is shown in the interactive tree visualization.'''\n",
    "        \n",
    "        if (self.game_state.pos == 2 and self.score_change < 0) or (self.game_state.pos == 1 and self.score_change > 0):\n",
    "            t1 = self.game_state.team1\n",
    "            t2 = self.game_state.team2\n",
    "        else:\n",
    "            t1 = self.game_state.team2\n",
    "            t2 = self.game_state.team1\n",
    "        return re.sub(r\"(\\w)([A-Z])\", r\"\\1 \\2\", self.__class__.__name__) + \" (\" + str(round(100 * self.prob_func(t1, t2),2)) + \"%) \" + \" in \" + str(self.time_consump) + \" secs\" \n",
    "\n",
    "    def is_applyable(self):\n",
    "        '''Checks if a move can be applied.'''\n",
    "        \n",
    "        time = self.game_state.time - self.time_consump\n",
    "        return time >= -4\n",
    "\n",
    "    def get_chance_child(self):\n",
    "        '''Applies the move to Game State and produces a Chance State'''\n",
    "        \n",
    "        team1 = self.game_state.team1\n",
    "        team2 = self.game_state.team2\n",
    "\n",
    "        # Possession Change\n",
    "        if self.pos_change:\n",
    "            new_pos = 1 if self.game_state.pos == 2 else 2\n",
    "        else:\n",
    "            new_pos = self.game_state.pos\n",
    "\n",
    "        # Time Consumption\n",
    "        time = self.game_state.time - self.time_consump\n",
    "\n",
    "        score_diff = self.game_state.score_diff\n",
    "        \n",
    "        # Possession Type Change\n",
    "        if self.pos_type_change:\n",
    "            if self.type == DEFENSIVE:\n",
    "                pos_type = OFFENSIVE\n",
    "            else:\n",
    "                pos_type = DEFENSIVE\n",
    "        else:\n",
    "            pos_type = self.type\n",
    "\n",
    "        \n",
    "        states = []\n",
    "        probs = []\n",
    "\n",
    "        # Picks the correct order of the teams for the score change\n",
    "        if (self.game_state.pos == 2 and self.score_change < 0) or (self.game_state.pos == 1 and self.score_change > 0):\n",
    "            t1 = team1\n",
    "            t2 = team2\n",
    "        else:\n",
    "            t1 = team2\n",
    "            t2 = team1\n",
    "            \n",
    "        prec = self.prob_func(t1, t2)\n",
    "        \n",
    "        # Find all combinations of make and miss\n",
    "        for make_comb in itertools.product([1, 0] if prec != 1 else [1], repeat=self.occ_count):\n",
    "            if self.game_state.pos == 1:\n",
    "                score_diff = self.game_state.score_diff + self.score_change * sum(make_comb)\n",
    "            else:\n",
    "                score_diff = self.game_state.score_diff - self.score_change * sum(make_comb)\n",
    "\n",
    "            \n",
    "            # Map the binary make/miss  values to their corresponding probabilities\n",
    "            prob_comb = list(map(lambda score_chan: prec if score_chan == 1 else 1.0 - prec, make_comb))\n",
    "            gs = GameState(team1, team2, score_diff, time, new_pos, pos_type, self)\n",
    "            states.append(gs)\n",
    "            \n",
    "            # Multiply the probibilities and append to the list\n",
    "            probs.append(reduce(mul, prob_comb, 1))\n",
    "        return ChanceState(probs, states, self)\n",
    "\n",
    "\n",
    "class TwoPointer(Move):\n",
    "\n",
    "    def __init__(self, quick, game_state):\n",
    "        self.pos_change = False\n",
    "        self.pos_type_change = True\n",
    "        self.time_consump = QUICK_TIME_CONS if quick else SLOW_TIME_CONS\n",
    "        self.score_change = 2\n",
    "        self.occ_count = 1\n",
    "        if quick:\n",
    "            self.prob_func = lambda x, y: Team.get_two_perc_against(x,y) - QUICK_PERC_DECREASE\n",
    "        else:\n",
    "            self.prob_func = Team.get_two_perc_against\n",
    "        self.game_state = game_state\n",
    "        self.type = OFFENSIVE\n",
    "\n",
    "\n",
    "class ThreePointer(Move):\n",
    "\n",
    "    def __init__(self, quick, game_state):\n",
    "        self.pos_change = False\n",
    "        self.pos_type_change = True\n",
    "        self.time_consump = QUICK_TIME_CONS if quick else SLOW_TIME_CONS\n",
    "        self.score_change = 3\n",
    "        self.occ_count = 1\n",
    "        if quick:\n",
    "            self.prob_func = lambda x, y: Team.get_three_perc_against(x,y) - QUICK_PERC_DECREASE\n",
    "        else:\n",
    "            self.prob_func = Team.get_three_perc_against\n",
    "        self.game_state = game_state\n",
    "        self.type = OFFENSIVE\n",
    "\n",
    "class Foul(Move):\n",
    "\n",
    "    def __init__(self, game_state):\n",
    "        self.pos_change = True\n",
    "        self.pos_type_change = False\n",
    "        self.time_consump =  FOUL_TIME_CONS\n",
    "        self.score_change = -1\n",
    "        self.occ_count = 2\n",
    "        self.prob_func = Team.get_ft_perc_against\n",
    "        self.game_state = game_state\n",
    "        self.type = DEFENSIVE\n",
    "        \n",
    "class NotFoul(Move):\n",
    "\n",
    "    def __init__(self, game_state):\n",
    "        self.pos_change = True\n",
    "        self.pos_type_change = True\n",
    "        self.time_consump =  0\n",
    "        self.score_change = 0\n",
    "        self.occ_count = 1\n",
    "        self.prob_func = lambda x, y: 1\n",
    "        self.game_state = game_state\n",
    "        self.type = DEFENSIVE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## EXPECTIMINIMAX ALGORITHM ##\n",
    "\n",
    "# ALGORITHM OUTLINE:\n",
    "#\n",
    "#\n",
    "# function expectiminimax(node, depth)\n",
    "#     if node is a terminal node or depth = 0\n",
    "#         return the heuristic value of node\n",
    "#     if the adversary is to play at node\n",
    "#         // Return value of minimum-valued child node\n",
    "#         let α := +∞\n",
    "#         foreach child of node\n",
    "#             α := min(α, expectiminimax(child, depth-1))\n",
    "#     else if we are to play at node\n",
    "#         // Return value of maximum-valued child node\n",
    "#         let α := -∞\n",
    "#         foreach child of node\n",
    "#             α := max(α, expectiminimax(child, depth-1))\n",
    "#     else if random event at node\n",
    "#         // Return weighted average of all child nodes' values\n",
    "#         let α := 0\n",
    "#         foreach child of node\n",
    "#             α := α + (Probability[child] * expectiminimax(child, depth-1))\n",
    "#     return α\n",
    "\n",
    "def run_expectiminimax(start_state, max_depth):\n",
    "\n",
    "    dp = {}\n",
    "    dp_tree = {}\n",
    "    tree_root = Node(str(start_state))\n",
    "    ideal_move = [\"\"]\n",
    "\n",
    "    \n",
    "    def expectiminimax(state, depth, parent):\n",
    "\n",
    "        if not state.is_chance_state() and (state.is_gameover() or depth == 0):\n",
    "            return state.get_heuristic_score()\n",
    "        nodes = []\n",
    "        optimal_node_index = None\n",
    "        \n",
    "        if state.pos == 1:\n",
    "            alpha = float('-inf')\n",
    "            alpha_child = None\n",
    "            for i, child in enumerate(state.get_child_states()):\n",
    "                \n",
    "                if child in dp:\n",
    "                    # If we saw this exact node before, don't calculate it.\n",
    "                    # Use the values we have saved.\n",
    "                    cur_node = dp_tree[child]\n",
    "                    cur_node.optimal = False\n",
    "                    cur_node.parent = parent\n",
    "                    parent.children.append(cur_node)\n",
    "                    val = dp[child]\n",
    "                else:\n",
    "                    cur_node = Node(str(child), parent)\n",
    "                    val = expectiminimax(child, depth - 1, cur_node)\n",
    "                    dp_tree[child] = cur_node\n",
    "                    dp[child] = val\n",
    "                    \n",
    "                nodes.append(cur_node)\n",
    "                if val > alpha:\n",
    "                    optimal_node_index = i\n",
    "                    alpha = val\n",
    "                    alpha_child = child\n",
    "                    \n",
    "            if optimal_node_index != None: \n",
    "                nodes[optimal_node_index].optimal = True\n",
    "                \n",
    "            if state == start_state:\n",
    "                ideal_move[0] = str(alpha_child.last_move)\n",
    "                \n",
    "        elif state.pos == 2:\n",
    "            alpha = float('inf')\n",
    "            for i, child in enumerate(state.get_child_states()):\n",
    "                \n",
    "                if child in dp:\n",
    "                    # If we saw this exact node before, don't calculate it.\n",
    "                    # Use the values we have saved.\n",
    "                    \n",
    "                    cur_node = dp_tree[child]\n",
    "                    cur_node.parent = parent\n",
    "                    cur_node.optimal = False\n",
    "                    parent.children.append(cur_node)\n",
    "                    val = dp[child]\n",
    "                else:\n",
    "                    cur_node = Node(str(child), parent)\n",
    "                    val = expectiminimax(child, depth - 1, cur_node)\n",
    "                    dp_tree[child] = cur_node\n",
    "                    dp[child] = val\n",
    "                \n",
    "                nodes.append(cur_node)\n",
    "                if val < alpha:\n",
    "                    optimal_node_index = i\n",
    "                    alpha = val\n",
    "            if optimal_node_index != None:        \n",
    "                nodes[optimal_node_index].optimal = True\n",
    "                    \n",
    "        elif state.is_chance_state():\n",
    "            alpha = 0\n",
    "           \n",
    "            for i, child in enumerate(state.get_child_states()):\n",
    "                if child in dp:\n",
    "                    cur_node = dp_tree[child]\n",
    "                    cur_node.parent = parent\n",
    "                    parent.children.append(cur_node)\n",
    "                    val = dp[child]\n",
    "                else:\n",
    "                    cur_node = Node(str(child), parent)\n",
    "                    val = expectiminimax(child, depth, cur_node)\n",
    "                    dp_tree[child] = cur_node\n",
    "                    dp[child] = val\n",
    "                alpha += state.get_state_prob(i) * val\n",
    "        else:\n",
    "            print(\"SHOULDN'T BE HERE!\")\n",
    "\n",
    "        return alpha\n",
    "    \n",
    "    \n",
    "    max_prob = expectiminimax(start_state, max_depth, tree_root)\n",
    "    return ideal_move[0], max_prob, tree_root\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum expected win probability is 0.46683359562. The ideal move is to take a Two Pointer (66.11%)  in 7 secs.\n"
     ]
    }
   ],
   "source": [
    "cur_three_perc = .391\n",
    "cur_two_perc = .660\n",
    "cur_ft_perc = .75\n",
    "cur_three_defen_perc = .357\n",
    "cur_two_defen_perc = .490\n",
    "opp_three_perc = 0.357\n",
    "opp_two_perc = 0.519\n",
    "opp_ft_perc = 0.804\n",
    "opp_three_defen_perc = 0.366\n",
    "opp_two_defen_perc = 0.534\n",
    "\n",
    "score_diff = -1 # Points\n",
    "time = 30 # Seconds left\n",
    "pos = 1 # We have the ball\n",
    "depth = float(\"inf\") # Max depth the tree can go\n",
    "\n",
    "team1 = Team(cur_three_perc, cur_two_perc, cur_ft_perc, cur_three_defen_perc, cur_two_defen_perc)\n",
    "team2 = Team(opp_three_perc, opp_two_perc, opp_ft_perc, opp_three_defen_perc, opp_two_defen_perc)\n",
    "\n",
    "game_state = GameState(team1, team2, score_diff, time, pos)\n",
    "ideal_move, max_prob, tree_root = run_expectiminimax(game_state, depth)\n",
    "print(\"The maximum expected win probability is \" + str(max_prob) + \". The ideal move is to take a \" + ideal_move + \".\")\n",
    "\n",
    "show_tree(tree_root, depth=15)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def run_expectiminimax_with_teams(team1_name, team2_name, score_diff=-1, time=30, pos=1, depth=float(\"inf\")):\n",
    "    team1 = create_team(team1_name)\n",
    "    team2 = create_team(team2_name)\n",
    "    start_state = GameState(team1, team2, score_diff, time, pos)\n",
    "    return run_expectiminimax(start_state, depth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done with Atlanta Hawks at 2018-05-15 14:34:06\n",
      "Done with Boston Celtics at 2018-05-15 14:34:07\n",
      "Done with Brooklyn Nets at 2018-05-15 14:34:09\n",
      "Done with Charlotte Hornets at 2018-05-15 14:34:11\n",
      "                                                Atlanta Hawks  \\\n",
      "Opposing Team                                                   \n",
      "Atlanta Hawks      33% with Three Pointer (34.49%)  in 7 secs   \n",
      "Boston Celtics     30% with Three Pointer (30.71%)  in 7 secs   \n",
      "Brooklyn Nets       32% with Three Pointer (33.7%)  in 7 secs   \n",
      "Charlotte Hornets  31% with Three Pointer (34.29%)  in 7 secs   \n",
      "\n",
      "                                               Boston Celtics  \\\n",
      "Opposing Team                                                   \n",
      "Atlanta Hawks      36% with Three Pointer (36.26%)  in 7 secs   \n",
      "Boston Celtics      33% with Three Pointer (32.3%)  in 7 secs   \n",
      "Brooklyn Nets      34% with Three Pointer (35.43%)  in 7 secs   \n",
      "Charlotte Hornets  35% with Three Pointer (36.05%)  in 7 secs   \n",
      "\n",
      "                                                Brooklyn Nets  \\\n",
      "Opposing Team                                                   \n",
      "Atlanta Hawks      34% with Three Pointer (34.08%)  in 7 secs   \n",
      "Boston Celtics     31% with Three Pointer (30.34%)  in 7 secs   \n",
      "Brooklyn Nets      32% with Three Pointer (33.29%)  in 7 secs   \n",
      "Charlotte Hornets  32% with Three Pointer (33.88%)  in 7 secs   \n",
      "\n",
      "                                            Charlotte Hornets  \n",
      "Opposing Team                                                  \n",
      "Atlanta Hawks      35% with Three Pointer (35.43%)  in 7 secs  \n",
      "Boston Celtics     31% with Three Pointer (31.56%)  in 7 secs  \n",
      "Brooklyn Nets      34% with Three Pointer (34.61%)  in 7 secs  \n",
      "Charlotte Hornets  34% with Three Pointer (35.23%)  in 7 secs  \n"
     ]
    }
   ],
   "source": [
    "# Takes 8.5 minutes to run\n",
    "from time import gmtime, strftime\n",
    "team_names = team_names[:4]\n",
    "team_probs = {\"Opposing Team\": team_names}\n",
    "for i in xrange(len(team_names)):\n",
    "    team1_name = team_names[i]\n",
    "    for j in xrange(len(team_names)):\n",
    "        team2_name = team_names[j]\n",
    "        if team1_name not in team_probs:\n",
    "            team_probs[team1_name] = []\n",
    "        ideal_move, max_prob, tree_root = run_expectiminimax_with_teams(team1_name, team2_name, score_diff=-1)\n",
    "        team_probs[team1_name].append(str(int(100* max_prob)) + \"% with \" + ideal_move)\n",
    "    print(\"Done with \" + team1_name + \" at \" + strftime(\"%Y-%m-%d %H:%M:%S\", gmtime()))\n",
    "            \n",
    "team_prob_matrix = pd.DataFrame(team_probs)\n",
    "team_prob_matrix = team_prob_matrix.set_index(\"Opposing Team\")\n",
    "print(team_prob_matrix)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SENSITIVITY TABLE OF QUICK SHOT TIME\n",
      "                                        Optimal Move  Time Consumption (secs)\n",
      "0     40% to win with Two Pointer (48.0%)  in 4 secs                        4\n",
      "1     33% to win with Two Pointer (48.0%)  in 5 secs                        5\n",
      "2     42% to win with Two Pointer (48.0%)  in 6 secs                        6\n",
      "3   32% to win with Three Pointer (33.2%)  in 7 secs                        7\n",
      "4     42% to win with Two Pointer (48.0%)  in 8 secs                        8\n",
      "5   25% to win with Three Pointer (33.2%)  in 9 secs                        9\n",
      "6  37% to win with Three Pointer (36.2%)  in 17 secs                       10\n",
      "\n",
      "\n",
      "\n",
      "SENSITIVITY TABLE OF SLOW SHOT TIME\n",
      "                                         Optimal Move  Time Consumption (secs)\n",
      "0     46% to win with Two Pointer (51.0%)  in 11 secs                       11\n",
      "1    35% to win with Three Pointer (33.2%)  in 7 secs                       12\n",
      "2   32% to win with Three Pointer (36.2%)  in 13 secs                       13\n",
      "3    34% to win with Three Pointer (33.2%)  in 7 secs                       14\n",
      "4      44% to win with Two Pointer (48.0%)  in 7 secs                       15\n",
      "5      42% to win with Two Pointer (48.0%)  in 7 secs                       16\n",
      "6    32% to win with Three Pointer (33.2%)  in 7 secs                       17\n",
      "7   34% to win with Three Pointer (36.2%)  in 18 secs                       18\n",
      "8     50% to win with Two Pointer (51.0%)  in 19 secs                       19\n",
      "9     50% to win with Two Pointer (51.0%)  in 20 secs                       20\n",
      "10     36% to win with Two Pointer (48.0%)  in 7 secs                       21\n",
      "11     35% to win with Two Pointer (48.0%)  in 7 secs                       22\n",
      "12     35% to win with Two Pointer (48.0%)  in 7 secs                       23\n",
      "13     36% to win with Two Pointer (48.0%)  in 7 secs                       24\n"
     ]
    }
   ],
   "source": [
    "# ## SENSITIVITY ANALYSIS ON TIME CONSUMPS ##\n",
    "\n",
    "\n",
    "cur_three_perc = LEAGUE_AVE_THREE_PERC\n",
    "cur_two_perc = LEAGUE_AVE_TWO_PERC\n",
    "cur_ft_perc = LEAGUE_AVE_FT_PERC\n",
    "cur_three_defen_perc = LEAGUE_AVE_THREE_PERC\n",
    "cur_two_defen_perc = LEAGUE_AVE_TWO_PERC\n",
    "opp_three_perc = LEAGUE_AVE_THREE_PERC\n",
    "opp_two_perc = LEAGUE_AVE_TWO_PERC\n",
    "opp_ft_perc = LEAGUE_AVE_FT_PERC\n",
    "opp_three_defen_perc = LEAGUE_AVE_THREE_PERC\n",
    "opp_two_defen_perc = LEAGUE_AVE_TWO_PERC\n",
    "\n",
    "score_diff = -1 # Points\n",
    "time = 30 # Seconds left\n",
    "pos = 1 # We have the ball\n",
    "depth = float(\"inf\") # Max depth the tree can go\n",
    "\n",
    "\n",
    "team1 = Team(cur_three_perc, cur_two_perc, cur_ft_perc, cur_three_defen_perc, cur_two_defen_perc)\n",
    "team2 = Team(opp_three_perc, opp_two_perc, opp_ft_perc, opp_three_defen_perc, opp_two_defen_perc)\n",
    "\n",
    "game_state = GameState(team1, team2, score_diff, time, pos)\n",
    "\n",
    "quick_time_range = range(4,11)\n",
    "slow_time_range = range(11,25)\n",
    "\n",
    "quick_sensitivity_dict = {'''Time Consumption (secs)''': list(quick_time_range), \"Optimal Move\": []}\n",
    "\n",
    "for quick_time in quick_time_range:\n",
    "    QUICK_TIME_CONS = quick_time\n",
    "    SLOW_TIME_CONS = (11 + 24) / 2\n",
    "    optimal_move, max_prob, tree_root = run_expectiminimax(game_state, depth)\n",
    "    quick_sensitivity_dict[\"Optimal Move\"].append(str(int(100 * max_prob)) + \"% to win with \" + optimal_move)\n",
    "\n",
    "quick_sensitivity_table = pd.DataFrame(quick_sensitivity_dict)\n",
    "quick_sensitivity_table.set_index(\"Time Consumption (secs)\")\n",
    "print(\"SENSITIVITY TABLE OF QUICK SHOT TIME\")\n",
    "print(quick_sensitivity_table)\n",
    "\n",
    "print(\"\\n\\n\")\n",
    "\n",
    "\n",
    "slow_sensitivity_dict = {'''Time Consumption (secs)''': list(slow_time_range), \"Optimal Move\": []}\n",
    "\n",
    "for slow_time in slow_time_range:\n",
    "    SLOW_TIME_CONS = slow_time\n",
    "    QUICK_TIME_CONS = (10 + 4) / 2\n",
    "    optimal_move, max_prob, tree_root = run_expectiminimax(game_state, depth)\n",
    "    slow_sensitivity_dict[\"Optimal Move\"].append(str(int(100 * max_prob)) + \"% to win with \" + optimal_move)\n",
    "\n",
    "slow_sensitivity_table = pd.DataFrame(slow_sensitivity_dict)\n",
    "slow_sensitivity_table.set_index(\"Time Consumption (secs)\")\n",
    "print(\"SENSITIVITY TABLE OF SLOW SHOT TIME\")\n",
    "print(slow_sensitivity_table)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SENSITIVITY TABLE OF START TIME\n",
      "                                         Optimal Move  Start Time (secs)\n",
      "0   19.3187897993% to win with Two Pointer (48.0%)...                 15\n",
      "1   48.9984% to win with Two Pointer (48.0%)  in 7...                 18\n",
      "2   51.0% to win with Two Pointer (51.0%)  in 24 secs                 21\n",
      "3   51.0% to win with Two Pointer (51.0%)  in 24 secs                 24\n",
      "4   32.9724581064% to win with Two Pointer (48.0%)...                 27\n",
      "5   36.2017724345% to win with Two Pointer (48.0%)...                 30\n",
      "6   31.3878586328% to win with Three Pointer (36.2...                 33\n",
      "7   34.5074021176% to win with Three Pointer (36.2...                 36\n",
      "8   47.7755733839% to win with Two Pointer (51.0%)...                 39\n",
      "9   31.5969503112% to win with Three Pointer (36.2...                 42\n",
      "10  30.0721431514% to win with Two Pointer (48.0%)...                 45\n",
      "11  46.2935783933% to win with Two Pointer (48.0%)...                 48\n",
      "12  39.6820926651% to win with Three Pointer (36.2...                 51\n",
      "13  35.900558588% to win with Three Pointer (33.2%...                 54\n",
      "14  40.9785323222% to win with Two Pointer (48.0%)...                 57\n",
      "15  40.1213125587% to win with Two Pointer (51.0%)...                 60\n",
      "\n",
      "\n",
      "\n",
      "SENSITIVITY TABLE OF SCORE DIFFERENCE\n",
      "                                         Optimal Move  Score Difference\n",
      "0   0.11% to win with Three Pointer (33.2%)  in 7 ...               -10\n",
      "1   0.3% to win with Three Pointer (33.2%)  in 7 secs                -9\n",
      "2   0.73% to win with Three Pointer (33.2%)  in 7 ...                -8\n",
      "3   1.59% to win with Three Pointer (33.2%)  in 7 ...                -7\n",
      "4   3.27% to win with Three Pointer (33.2%)  in 7 ...                -6\n",
      "5   6.13% to win with Three Pointer (33.2%)  in 7 ...                -5\n",
      "6   11.22% to win with Three Pointer (36.2%)  in 2...                -4\n",
      "7   19.78% to win with Three Pointer (36.2%)  in 2...                -3\n",
      "8   28.59% to win with Three Pointer (36.2%)  in 2...                -2\n",
      "9   40.12% to win with Two Pointer (51.0%)  in 24 ...                -1\n",
      "10  56.38% to win with Three Pointer (36.2%)  in 2...                 0\n",
      "11  68.18% to win with Two Pointer (51.0%)  in 24 ...                 1\n",
      "12  77.54% to win with Two Pointer (51.0%)  in 24 ...                 2\n",
      "13  88.14% to win with Two Pointer (51.0%)  in 24 ...                 3\n",
      "14  93.31% to win with Two Pointer (51.0%)  in 24 ...                 4\n",
      "15  96.63% to win with Two Pointer (51.0%)  in 24 ...                 5\n",
      "16  98.51% to win with Two Pointer (51.0%)  in 24 ...                 6\n",
      "17  99.43% to win with Two Pointer (51.0%)  in 24 ...                 7\n",
      "18  99.82% to win with Two Pointer (51.0%)  in 24 ...                 8\n",
      "19  99.96% to win with Two Pointer (51.0%)  in 24 ...                 9\n",
      "20  99.99% to win with Two Pointer (51.0%)  in 24 ...                10\n"
     ]
    }
   ],
   "source": [
    "# ## SENSITIVITY ANALYSIS ON GAME STARTS ##\n",
    "\n",
    "cur_three_perc = LEAGUE_AVE_THREE_PERC\n",
    "cur_two_perc = LEAGUE_AVE_TWO_PERC\n",
    "cur_ft_perc = LEAGUE_AVE_FT_PERC\n",
    "cur_three_defen_perc = LEAGUE_AVE_THREE_PERC\n",
    "cur_two_defen_perc = LEAGUE_AVE_TWO_PERC\n",
    "opp_three_perc = LEAGUE_AVE_THREE_PERC\n",
    "opp_two_perc = LEAGUE_AVE_TWO_PERC\n",
    "opp_ft_perc = LEAGUE_AVE_FT_PERC\n",
    "opp_three_defen_perc = LEAGUE_AVE_THREE_PERC\n",
    "opp_two_defen_perc = LEAGUE_AVE_TWO_PERC\n",
    "\n",
    "score_diff = -1 # Points\n",
    "time = 30 # Seconds left\n",
    "pos = 1 # We have the ball\n",
    "depth = float(\"inf\") # Max depth the tree can go\n",
    "\n",
    "\n",
    "team1 = Team(cur_three_perc, cur_two_perc, cur_ft_perc, cur_three_defen_perc, cur_two_defen_perc)\n",
    "team2 = Team(opp_three_perc, opp_two_perc, opp_ft_perc, opp_three_defen_perc, opp_two_defen_perc)\n",
    "\n",
    "start_time_range = range(15, 61, 3)\n",
    "\n",
    "start_time_sensitivity_dict = {'''Start Time (secs)''': list(start_time_range), \"Optimal Move\": []}\n",
    "\n",
    "for start_time in start_time_range:\n",
    "    time = start_time # Seconds left\n",
    "    game_state = GameState(team1, team2, score_diff, time, pos)\n",
    "    optimal_move, max_prob, tree_root = run_expectiminimax(game_state, depth)\n",
    "    start_time_sensitivity_dict[\"Optimal Move\"].append(str(100 * max_prob) + \"% to win with \" + optimal_move)\n",
    "\n",
    "start_time_sensitivity_table = pd.DataFrame(start_time_sensitivity_dict)\n",
    "start_time_sensitivity_table.set_index(\"Start Time (secs)\")\n",
    "print(\"SENSITIVITY TABLE OF START TIME\")\n",
    "print(start_time_sensitivity_table)\n",
    "\n",
    "print(\"\\n\\n\")\n",
    "\n",
    "\n",
    "score_dif_time_range = range(-10,11)\n",
    "\n",
    "score_dif_sensitivity_dict = {'''Score Difference''': list(score_dif_time_range), \"Optimal Move\": []}\n",
    "\n",
    "for score in score_dif_time_range:\n",
    "    score_diff = score # Seconds left\n",
    "    game_state = GameState(team1, team2, score_diff, time, pos)\n",
    "    optimal_move, max_prob, tree_root = run_expectiminimax(game_state, depth)\n",
    "    score_dif_sensitivity_dict[\"Optimal Move\"].append(str(round(100 * max_prob, 2)) + \"% to win with \" + optimal_move)\n",
    "\n",
    "score_dif_sensitivity_table = pd.DataFrame(score_dif_sensitivity_dict)\n",
    "score_dif_sensitivity_table.set_index(\"Score Difference\")\n",
    "print(\"SENSITIVITY TABLE OF SCORE DIFFERENCE\")\n",
    "print(score_dif_sensitivity_table)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SENSITIVITY TABLE OF THREE PERCENTAGE\n",
      "                                         Optimal Move  Three Percentage\n",
      "0   31.94% to win with Two Pointer (48.0%)  in 7 secs             0.212\n",
      "1   32.22% to win with Two Pointer (48.0%)  in 7 secs             0.222\n",
      "2   32.53% to win with Two Pointer (48.0%)  in 7 secs             0.232\n",
      "3   32.85% to win with Two Pointer (48.0%)  in 7 secs             0.242\n",
      "4   33.18% to win with Two Pointer (48.0%)  in 7 secs             0.252\n",
      "5    33.5% to win with Two Pointer (48.0%)  in 7 secs             0.262\n",
      "6   33.82% to win with Two Pointer (48.0%)  in 7 secs             0.272\n",
      "7   34.14% to win with Two Pointer (48.0%)  in 7 secs             0.282\n",
      "8   34.46% to win with Two Pointer (48.0%)  in 7 secs             0.292\n",
      "9   34.77% to win with Two Pointer (48.0%)  in 7 secs             0.302\n",
      "10  35.08% to win with Two Pointer (48.0%)  in 7 secs             0.312\n",
      "11   35.3% to win with Two Pointer (48.0%)  in 7 secs             0.322\n",
      "12  35.52% to win with Two Pointer (48.0%)  in 7 secs             0.332\n",
      "13  35.74% to win with Two Pointer (48.0%)  in 7 secs             0.342\n",
      "14  35.95% to win with Two Pointer (48.0%)  in 7 secs             0.352\n",
      "15   36.2% to win with Two Pointer (48.0%)  in 7 secs             0.362\n",
      "16  36.45% to win with Three Pointer (34.2%)  in 7...             0.372\n",
      "17  37.14% to win with Three Pointer (35.2%)  in 7...             0.382\n",
      "18  37.82% to win with Three Pointer (36.2%)  in 7...             0.392\n",
      "19  38.55% to win with Three Pointer (37.2%)  in 7...             0.402\n",
      "20  39.29% to win with Three Pointer (38.2%)  in 7...             0.412\n",
      "21  40.0% to win with Three Pointer (39.2%)  in 7 ...             0.422\n",
      "22  40.74% to win with Three Pointer (40.2%)  in 7...             0.432\n",
      "23  41.55% to win with Three Pointer (41.2%)  in 7...             0.442\n",
      "24  42.36% to win with Three Pointer (42.2%)  in 7...             0.452\n",
      "25  43.18% to win with Three Pointer (43.2%)  in 7...             0.462\n",
      "26  44.15% to win with Three Pointer (44.2%)  in 7...             0.472\n",
      "27  45.13% to win with Three Pointer (45.2%)  in 7...             0.482\n",
      "28  46.1% to win with Three Pointer (46.2%)  in 7 ...             0.492\n",
      "29  47.06% to win with Three Pointer (47.2%)  in 7...             0.502\n",
      "30  48.06% to win with Three Pointer (48.2%)  in 7...             0.512\n",
      "31  49.17% to win with Three Pointer (49.2%)  in 7...             0.522\n",
      "32  50.42% to win with Three Pointer (50.2%)  in 7...             0.532\n",
      "33  51.68% to win with Three Pointer (51.2%)  in 7...             0.542\n",
      "34  52.94% to win with Three Pointer (52.2%)  in 7...             0.552\n",
      "35  54.2% to win with Three Pointer (53.2%)  in 7 ...             0.562\n",
      "36  55.47% to win with Three Pointer (54.2%)  in 7...             0.572\n",
      "37  56.74% to win with Three Pointer (55.2%)  in 7...             0.582\n",
      "38  58.01% to win with Three Pointer (56.2%)  in 7...             0.592\n",
      "39  59.31% to win with Three Pointer (57.2%)  in 7...             0.602\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## SENSITIVITY ANALYSIS ON THREE POINT SHOOTING PERCENTAGE ##\n",
    "\n",
    "cur_three_perc = LEAGUE_AVE_THREE_PERC\n",
    "cur_two_perc = LEAGUE_AVE_TWO_PERC\n",
    "cur_ft_perc = LEAGUE_AVE_FT_PERC\n",
    "cur_three_defen_perc = LEAGUE_AVE_THREE_PERC\n",
    "cur_two_defen_perc = LEAGUE_AVE_TWO_PERC\n",
    "opp_three_perc = LEAGUE_AVE_THREE_PERC\n",
    "opp_two_perc = LEAGUE_AVE_TWO_PERC\n",
    "opp_ft_perc = LEAGUE_AVE_FT_PERC\n",
    "opp_three_defen_perc = LEAGUE_AVE_THREE_PERC\n",
    "opp_two_defen_perc = LEAGUE_AVE_TWO_PERC\n",
    "\n",
    "three_perc_change_range = range(-15, 25)\n",
    "three_percs = [(delta / 100.0) + LEAGUE_AVE_THREE_PERC for delta in three_perc_change_range]\n",
    "three_perc_sensitivity_dict = {'''Three Percentage''': three_percs, \"Optimal Move\": []}\n",
    "\n",
    "score_diff = -1 # Points\n",
    "time = 30 # Seconds left\n",
    "pos = 1 # We have the ball\n",
    "depth = float(\"inf\") # Max depth the tree can go\n",
    "\n",
    "for three_perc in three_percs:\n",
    "    cur_three_perc = math.sqrt(three_perc)\n",
    "    opp_three_defen_perc = math.sqrt(three_perc) * LEAGUE_AVE_THREE_PERC\n",
    "    team1 = Team(cur_three_perc, cur_two_perc, cur_ft_perc, cur_three_defen_perc, cur_two_defen_perc)\n",
    "    team2 = Team(opp_three_perc, opp_two_perc, opp_ft_perc, opp_three_defen_perc, opp_two_defen_perc)\n",
    "\n",
    "    game_state = GameState(team1, team2, score_diff, time, pos)\n",
    "    optimal_move, max_prob, tree_root = run_expectiminimax(game_state, depth)\n",
    "    three_perc_sensitivity_dict[\"Optimal Move\"].append(str(round(100 * max_prob, 2)) + \"% to win with \" + optimal_move)\n",
    "\n",
    "three_perc_sensitivity_table = pd.DataFrame(three_perc_sensitivity_dict)\n",
    "three_perc_sensitivity_table.set_index(\"Three Percentage\")\n",
    "print(\"SENSITIVITY TABLE OF THREE PERCENTAGE\")\n",
    "print(three_perc_sensitivity_table)\n",
    "\n",
    "print(\"\\n\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SENSITIVITY TABLE OF TWO PERCENTAGE\n",
      "                                         Optimal Move  Two Percentage\n",
      "0   30.98% to win with Three Pointer (33.2%)  in 7...            0.36\n",
      "1   31.11% to win with Three Pointer (33.2%)  in 7...            0.37\n",
      "2   31.27% to win with Three Pointer (33.2%)  in 7...            0.38\n",
      "3   31.42% to win with Three Pointer (33.2%)  in 7...            0.39\n",
      "4   31.64% to win with Three Pointer (36.2%)  in 2...            0.40\n",
      "5   31.88% to win with Three Pointer (36.2%)  in 2...            0.41\n",
      "6   32.17% to win with Three Pointer (33.2%)  in 7...            0.42\n",
      "7   32.46% to win with Three Pointer (33.2%)  in 7...            0.43\n",
      "8   32.79% to win with Three Pointer (33.2%)  in 7...            0.44\n",
      "9   33.2% to win with Three Pointer (33.2%)  in 7 ...            0.45\n",
      "10  33.63% to win with Three Pointer (33.2%)  in 7...            0.46\n",
      "11  34.07% to win with Three Pointer (33.2%)  in 7...            0.47\n",
      "12  34.56% to win with Three Pointer (33.2%)  in 7...            0.48\n",
      "13  34.97% to win with Three Pointer (33.2%)  in 7...            0.49\n",
      "14  35.47% to win with Two Pointer (47.0%)  in 7 secs            0.50\n",
      "15   36.2% to win with Two Pointer (48.0%)  in 7 secs            0.51\n",
      "16  36.95% to win with Two Pointer (49.0%)  in 7 secs            0.52\n",
      "17  37.83% to win with Two Pointer (50.0%)  in 7 secs            0.53\n",
      "18  38.77% to win with Two Pointer (51.0%)  in 7 secs            0.54\n",
      "19  39.72% to win with Two Pointer (52.0%)  in 7 secs            0.55\n",
      "20  40.68% to win with Two Pointer (53.0%)  in 7 secs            0.56\n",
      "21  41.59% to win with Two Pointer (54.0%)  in 7 secs            0.57\n",
      "22  42.46% to win with Two Pointer (55.0%)  in 7 secs            0.58\n",
      "23  43.34% to win with Two Pointer (56.0%)  in 7 secs            0.59\n",
      "24  44.23% to win with Two Pointer (57.0%)  in 7 secs            0.60\n",
      "25  45.14% to win with Two Pointer (58.0%)  in 7 secs            0.61\n",
      "26  46.05% to win with Two Pointer (59.0%)  in 7 secs            0.62\n",
      "27  46.97% to win with Two Pointer (60.0%)  in 7 secs            0.63\n",
      "28   47.9% to win with Two Pointer (61.0%)  in 7 secs            0.64\n",
      "29   48.9% to win with Two Pointer (62.0%)  in 7 secs            0.65\n",
      "30  49.91% to win with Two Pointer (63.0%)  in 7 secs            0.66\n",
      "31  50.94% to win with Two Pointer (64.0%)  in 7 secs            0.67\n",
      "32  51.94% to win with Two Pointer (65.0%)  in 7 secs            0.68\n",
      "33  52.94% to win with Two Pointer (66.0%)  in 7 secs            0.69\n",
      "34  53.95% to win with Two Pointer (67.0%)  in 7 secs            0.70\n",
      "35  54.95% to win with Two Pointer (68.0%)  in 7 secs            0.71\n",
      "36  55.96% to win with Two Pointer (69.0%)  in 7 secs            0.72\n",
      "37  56.99% to win with Two Pointer (70.0%)  in 7 secs            0.73\n",
      "38  58.02% to win with Two Pointer (71.0%)  in 7 secs            0.74\n",
      "39  59.08% to win with Two Pointer (75.0%)  in 24 ...            0.75\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "## SENSITIVITY ANALYSIS ON TWO POINT SHOOTING PERCENTAGE ##\n",
    "\n",
    "cur_three_perc = LEAGUE_AVE_THREE_PERC\n",
    "cur_two_perc = LEAGUE_AVE_TWO_PERC\n",
    "cur_ft_perc = LEAGUE_AVE_FT_PERC\n",
    "cur_three_defen_perc = LEAGUE_AVE_THREE_PERC\n",
    "cur_two_defen_perc = LEAGUE_AVE_TWO_PERC\n",
    "opp_three_perc = LEAGUE_AVE_THREE_PERC\n",
    "opp_two_perc = LEAGUE_AVE_TWO_PERC\n",
    "opp_ft_perc = LEAGUE_AVE_FT_PERC\n",
    "opp_three_defen_perc = LEAGUE_AVE_THREE_PERC\n",
    "opp_two_defen_perc = LEAGUE_AVE_TWO_PERC\n",
    "\n",
    "two_perc_change_range = range(-15, 25)\n",
    "two_percs = [(delta / 100.0) + LEAGUE_AVE_TWO_PERC for delta in two_perc_change_range]\n",
    "two_perc_sensitivity_dict = {'''Two Percentage''': two_percs, \"Optimal Move\": []}\n",
    "\n",
    "score_diff = -1 # Points\n",
    "time = 30 # Seconds left\n",
    "pos = 1 # We have the ball\n",
    "depth = float(\"inf\") # Max depth the tree can go\n",
    "\n",
    "for two_perc in two_percs:\n",
    "    cur_two_perc = math.sqrt(two_perc)\n",
    "    opp_two_defen_perc = math.sqrt(two_perc) * LEAGUE_AVE_TWO_PERC\n",
    "    team1 = Team(cur_three_perc, cur_two_perc, cur_ft_perc, cur_three_defen_perc, cur_two_defen_perc)\n",
    "    team2 = Team(opp_three_perc, opp_two_perc, opp_ft_perc, opp_three_defen_perc, opp_two_defen_perc)\n",
    "\n",
    "    game_state = GameState(team1, team2, score_diff, time, pos)\n",
    "    optimal_move, max_prob, tree_root = run_expectiminimax(game_state, depth)\n",
    "    two_perc_sensitivity_dict[\"Optimal Move\"].append(str(round(100 * max_prob, 2)) + \"% to win with \" + optimal_move)\n",
    "\n",
    "two_perc_sensitivity_table = pd.DataFrame(two_perc_sensitivity_dict)\n",
    "two_perc_sensitivity_table.set_index(\"Two Percentage\")\n",
    "print(\"SENSITIVITY TABLE OF TWO PERCENTAGE\")\n",
    "print(two_perc_sensitivity_table)\n",
    "\n",
    "print(\"\\n\\n\")\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}