commit 6356d6644e7b6c60044faf9d5becca81291d56d2 Author: unlockable Date: Sun Feb 4 09:09:01 2024 +0800 working m diff --git a/calc_momentum/calc.ipynb b/calc_momentum/calc.ipynb new file mode 100644 index 0000000..2cc0c4e --- /dev/null +++ b/calc_momentum/calc.ipynb @@ -0,0 +1,533 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import os.path as path\n", + "\n", + "# Data provided by github\n", + "point_by_point_file_name = \"D:/Documents/OneDrive/Documents/School/清华/大二/美赛/Report/calc_momentum/tennis_slam_pointbypoint/combined.csv\"\n", + "readin_filename = path.join(path.dirname(point_by_point_file_name), \"readin.csv\")\n", + "\n", + "# Data provided by competition\n", + "# point_by_point_file_name = \"D:\\Documents\\OneDrive\\Documents\\School\\清华\\大二\\美赛\\\\2024_MCM-ICM_Problems\\Wimbledon_featured_matches.csv\"\n", + "\n", + "point_data = pd.read_csv(point_by_point_file_name)\n", + "\n", + "# Remove lines of point 0X, 0Y\n", + "point_data.drop(point_data[(point_data.PointWinner == 0)].index, inplace = True)\n", + "\n", + "# point_data.to_csv(readin_filename, index=False)\n", + "\n", + "# Only preserve used cols\n", + "# point_data = pd.read_csv(readin_filename, usecols=['match_id', 'ElapsedTime', 'SetNo', 'P1GamesWon', 'P2GamesWon', 'SetWinner', 'GameNo', 'PointNumber', 'PointWinner', 'PointServer', 'P1Ace', 'P2Ace', 'P1DoubleFault', 'P2DoubleFault', 'P1UnfErr', 'P2UnfErr', 'P1NetPoint', 'P2NetPoint', 'P1DistanceRun', 'P2DistanceRun'])\n", + "point_data = point_data[['match_id', 'ElapsedTime', 'SetNo', 'P1GamesWon', 'P2GamesWon', 'SetWinner', 'GameNo', 'PointNumber', 'PointWinner', 'PointServer', 'P1Ace', 'P2Ace', 'P1DoubleFault', 'P2DoubleFault', 'P1UnfErr', 'P2UnfErr', 'P1NetPoint', 'P2NetPoint', 'P1DistanceRun', 'P2DistanceRun']]\n", + "point_data = point_data.reset_index(drop=True)\n", + "point_data.to_csv(readin_filename, index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from datetime import datetime\n", + "import math\n", + "from copy import deepcopy\n", + "\n", + "K_TIME_DECAY = 1e-3\n", + "K_SET_ENERGY_RECOVER = 0.8\n", + "\n", + "point_data = pd.read_csv(readin_filename)\n", + "# print(point_data)\n", + "\n", + "match_count = -1\n", + "cur_game_number = 0\n", + "player1_ahead_set_count = 0\n", + "current_time = datetime.strptime(\"00:00:00\", \"%H:%M:%S\")\n", + "\n", + "player1_memory = [0, 0, 0, 0, 0, np.zeros(4)]\n", + "player2_memory = [0, 0, 0, 0, 0, np.zeros(4)]\n", + "# continued victory, distance run, game score diff, set score diff, is serve, (ace, double fault, unforced error, net point)\n", + "\n", + "player1_stats = list()\n", + "player2_stats = list()\n", + "player1_got_point = list()\n", + "# list of rho of type numpy.matrix\n", + "# match_count, point_num\n", + "# print(player_stats)\n", + "\n", + "for index, record in point_data.to_dict(orient='index').items():\n", + " # print(index, record)\n", + " if (record['PointNumber'] == 1):\n", + " player1_stats.append(list())\n", + " player2_stats.append(list())\n", + " player1_got_point.append(list())\n", + " # Into a new match, clear all\n", + " match_count += 1\n", + " player1_ahead_set_count = 0\n", + " player1_memory = [0, 0, 0, 0, 0, np.zeros(4)]\n", + " player2_memory = [0, 0, 0, 0, 0, np.zeros(4)]\n", + " player1_stats[match_count].append(deepcopy(player1_memory))\n", + " player2_stats[match_count].append(deepcopy(player2_memory))\n", + " current_time = datetime.strptime(\"00:00:00\", \"%H:%M:%S\")\n", + " cur_game_number = 1\n", + " elif(record['GameNo'] != cur_game_number):\n", + " # into a new game\n", + " cur_game_number = record['GameNo']\n", + " # reset server\n", + " player1_memory[4] = 0\n", + " player2_memory[4] = 0\n", + " \n", + " # game diff\n", + " player1_memory[2] = record['P1GamesWon'] - record['P2GamesWon']\n", + " player2_memory[2] = record['P2GamesWon'] - record['P1GamesWon']\n", + " \n", + " # continued victory\n", + " if (record['PointWinner'] == 1):\n", + " player1_memory[0] += 1\n", + " player2_memory[0] = 0\n", + " player1_got_point[match_count].append(1)\n", + " else:\n", + " player1_memory[0] = 0\n", + " player2_memory[0] += 1\n", + " player1_got_point[match_count].append(0)\n", + "\n", + " # running distance\n", + " player1_memory[1] += record['P1DistanceRun']\n", + " player2_memory[1] += record['P2DistanceRun']\n", + "\n", + " # decay\n", + " try:\n", + " new_time = datetime.strptime(record['ElapsedTime'], \"%H:%M:%S\")\n", + " except:\n", + " print(record)\n", + " raise ValueError\n", + " delta_t = new_time - current_time\n", + " current_time = new_time\n", + "\n", + " coeff = math.exp(-K_TIME_DECAY * delta_t.seconds)\n", + " player1_memory[5] *= coeff\n", + " player2_memory[5] *= coeff\n", + "\n", + " player1_new_effect = np.array([record['P1Ace'], record['P1DoubleFault'], record['P1UnfErr'], record['P1NetPoint']])\n", + " player2_new_effect = np.array([record['P2Ace'], record['P2DoubleFault'], record['P2UnfErr'], record['P2NetPoint']])\n", + "\n", + " player1_memory[5] += player1_new_effect\n", + " player2_memory[5] += player2_new_effect\n", + "\n", + " # serve\n", + " if (record['PointServer'] == 1):\n", + " player1_memory[4] += 1\n", + " else:\n", + " player2_memory[4] += 1\n", + "\n", + " player1_stats[match_count].append(deepcopy(player1_memory))\n", + " player2_stats[match_count].append(deepcopy(player2_memory))\n", + "\n", + " if (record['SetWinner'] != 0):\n", + " # end of set\n", + " if (record['SetWinner'] == 1):\n", + " player1_ahead_set_count += 1\n", + " elif (record['SetWinner'] == 2):\n", + " player1_ahead_set_count -= 1\n", + " else:\n", + " print(\"Nobody wins: %d\" % record['SetWinner'])\n", + " \n", + " # continued victory no longer have effect\n", + " player1_memory[0] = 0\n", + " player2_memory[0] = 0\n", + "\n", + " # recover some energy\n", + " player1_memory[1] *= K_SET_ENERGY_RECOVER\n", + " player2_memory[1] *= K_SET_ENERGY_RECOVER\n", + " # no need to update game diff, it will update on next iteration\n", + "\n", + " # update set diff\n", + " player1_memory[3] = player1_ahead_set_count\n", + " player2_memory[3] = -player1_ahead_set_count\n", + "\n", + "\n", + "\n", + "# print(player1_stats)\n", + "# print(player2_stats)" + ] + }, + { + "cell_type": "code", + "execution_count": 212, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.88799225 0.41208656 0.18467467 0.08688903]\n", + "[0.88799225 0.41208656 0.18467467 0.08688903]\n" + ] + } + ], + "source": [ + "# calculate the weights and calc m\n", + "# personal performance's importance\n", + "judgement_matrix = np.array([[1, 3, 5, 7], [1/3, 1, 3, 5], [1/5, 1/3, 1, 3], [1/7, 1/5, 1/3, 1]])\n", + "eigen_vals, eigen_vecs = np.linalg.eig(judgement_matrix)\n", + "wpp_weights = eigen_vecs[:,0].real\n", + "print(wpp_weights)\n", + "wpp_weights /= np.linalg.norm(wpp_weights) # possibly no use\n", + "print(wpp_weights)\n", + "\n", + "Rpp = np.array([[0.7, 0.2, 0.1], [0.3, 0.3, 0.4], [0.1, 0.45, 0.45], [0.8, 0.1, 0.1]])" + ] + }, + { + "cell_type": "code", + "execution_count": 213, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.9486833 0.31622777]\n" + ] + } + ], + "source": [ + "\n", + "# game and set\n", + "judgement_matrix = np.array([[1, 3], [1/3, 1]])\n", + "eigen_vals, eigen_vecs = np.linalg.eig(judgement_matrix)\n", + "wpd_weights = eigen_vecs[:,0].real\n", + "wpd_weights /= np.linalg.norm(wpd_weights) # possibly no use\n", + "print(wpd_weights)\n", + "\n", + "Rpd = np.array([[0.7, 0.2, 0.1], [0.5, 0.4, 0.1]])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 214, + "metadata": {}, + "outputs": [], + "source": [ + "Rserve = np.array([0.8, 0.1, 0.1])\n", + "Rcontinue_vic = np.array([0.7, 0.2, 0.1])\n", + "Rrun_dis = np.array([0.1, 0.2, 0.7])" + ] + }, + { + "cell_type": "code", + "execution_count": 215, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.8629722 0.44005612 0.21704424 0.10665135 0.05609714]\n" + ] + } + ], + "source": [ + "# overall AHD of personal performance, game and set, serve, continue_vic, run_dis\n", + "judgement_matrix = np.array([[1, 3, 5, 7, 9], [1/3, 1, 3, 5, 7], [1/5, 1/3, 1, 3, 5], [1/7, 1/5, 1/3, 1, 3], [1/9, 1/7, 1/5, 1/3, 1]])\n", + "eigen_vals, eigen_vecs = np.linalg.eig(judgement_matrix)\n", + "overall_weights = eigen_vecs[:,0].real\n", + "overall_weights /= np.linalg.norm(overall_weights) # possibly no use\n", + "print(overall_weights)" + ] + }, + { + "cell_type": "code", + "execution_count": 216, + "metadata": {}, + "outputs": [], + "source": [ + "# calculate m\n", + "player1_m = list()\n", + "player2_m = list()\n", + "\n", + "score_array = np.array([[1], [0], [-1]])\n", + "\n", + "# print(score_array)\n", + "# print(np.reshape(player1_stats[1][25][5], (-1, 1)))\n", + "# print(np.reshape(wpp_weights, (1, -1)))\n", + "# print(wpp_weights.dot(player1_stats[1][25][5]))\n", + "\n", + "for match in player1_stats:\n", + " player1_m.append(list())\n", + " for point in match[:-1]:\n", + " personal_performance = (wpp_weights.dot(point[5])) * (wpp_weights.dot(Rpp))# 1 * 3 array\n", + " point_diff = (wpd_weights.dot(np.array([point[2], point[3]]))) * (wpd_weights.dot(Rpd))\n", + " serve = point[4] * Rserve / 100\n", + " continue_vic = point[0] * Rcontinue_vic\n", + " run_dis = (-100 * math.tanh(point[1] / 1000)) * Rrun_dis\n", + "\n", + " # print(personal_performance, point_diff, serve, continue_vic, run_dis)\n", + "\n", + " score_distribute = overall_weights.dot(np.array([personal_performance, continue_vic, point_diff, serve, run_dis]))\n", + " m = score_distribute.dot(score_array).take(0)\n", + " # print(m)\n", + " player1_m[-1].append(m)\n", + "\n", + "for match in player2_stats:\n", + " player2_m.append(list())\n", + " for point in match[:-1]:\n", + " personal_performance = (wpp_weights.dot(point[5])) * (wpp_weights.dot(Rpp)) # 1 * 3 array\n", + " point_diff = (wpd_weights.dot(np.array([point[2], point[3]]))) * (wpd_weights.dot(Rpd))\n", + " serve = point[4] * Rserve / 100\n", + " continue_vic = point[0] * Rcontinue_vic\n", + " run_dis = (-100 * math.tanh(point[1] / 1000)) * Rrun_dis\n", + "\n", + " score_distribute = overall_weights.dot(np.array([personal_performance, continue_vic, point_diff, serve, run_dis]))\n", + " m = score_distribute.dot(score_array).take(0)\n", + " # print(m)\n", + " player2_m[-1].append(m)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 255, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5.996022180775009\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "# for i in range(len(player1_m)):\n", + "max_delta_m = 0\n", + "for i in range(len(player1_m)):\n", + " single_match_delta_m = list()\n", + " for j in range(len(player1_m[i])):\n", + " # print(j, player1_m[i][j] - player2_m[i][j])\n", + " single_match_delta_m.append(player1_m[i][j] - player2_m[i][j])\n", + " if (abs(player1_m[i][j] - player2_m[i][j]) > max_delta_m):\n", + " max_delta_m = abs(player1_m[i][j] - player2_m[i][j])\n", + " # plt.plot(range(len(player1_m[i])), player1_m[i], range(len(player2_m[i])), player2_m[i])\n", + " # plt.plot(range(len(player1_m[i])), single_match_delta_m)\n", + " # plt.title(\"Match %d\" % (i + 1))\n", + " # plt.show()\n", + "\n", + "print(max_delta_m)\n", + "max_delta_m = math.ceil(max_delta_m)\n", + "\n", + "\n", + "# i = 2\n", + "# single_match_delta_m = list()\n", + "# for j in range(len(player1_m[i])):\n", + "# # print(j, player1_m[i][j] - player2_m[i][j])\n", + "# single_match_delta_m.append(player1_m[i][j] - player2_m[i][j])\n", + "# plt.plot(range(len(player1_m[i])), single_match_delta_m)\n", + "# plt.title(\"Match %d\" % (i + 1))\n", + "# plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 289, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "88 88\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGiCAYAAADEJZ3cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABChElEQVR4nO3deXhV1aH38d/JdBIyQRIyYAYioxArEJAECl6hBmmpU1ui3he1deIqVsTeFl71QWi9VK9Frr5ipVW8qBe5V0TtFSuhBQFBVAiUQeYhISSEBDJCTpJz1vtHwpGTiZyQwE74fp5nPzlnn7VX1nYj58daa69tM8YYAQAAWJjP5W4AAADAhRBYAACA5RFYAACA5RFYAACA5RFYAACA5RFYAACA5RFYAACA5RFYAACA5RFYAACA5RFYAACA5bUpsCxcuFDJyckKDAxUamqq1q9f32J5h8Ohp556SklJSbLb7erTp4/efPNNjzLLly/XoEGDZLfbNWjQIK1YsaItTQMAAF2Q14Fl2bJlmj59up566illZ2drzJgxmjhxonJycpo9ZvLkyfrb3/6mN954Q3v37tXSpUs1cOBA9+ebNm1SZmampkyZou3bt2vKlCmaPHmyNm/e3LazAgAAXYrN24cfjhw5UsOGDdNrr73m3nfNNdfotttu07x58xqV/+tf/6o777xThw4dUkRERJN1ZmZmqqysTJ9++ql7380336wePXpo6dKl3jQPAAB0QX7eFK6urtaWLVs0c+ZMj/0ZGRnauHFjk8d8/PHHGj58uF544QW9/fbbCg4O1i233KLf/va3CgoKklTXw/LEE094HDdhwgQtWLCg2bY4HA45HA73e5fLpVOnTikyMlI2m82b0wIAAJeJMUbl5eXq1auXfHyaH/jxKrAUFRXJ6XQqJibGY39MTIwKCgqaPObQoUPasGGDAgMDtWLFChUVFemRRx7RqVOn3PNYCgoKvKpTkubNm6c5c+Z403wAAGBRubm5io+Pb/ZzrwLLOQ17MIwxzfZquFwu2Ww2vfvuuwoPD5ckzZ8/Xz/96U/16quvuntZvKlTkmbNmqUZM2a435eWlioxMVG5ubkKCwtry2kBAIBLrKysTAkJCQoNDW2xnFeBJSoqSr6+vo16PgoLCxv1kJwTFxenq666yh1WpLo5L8YYHTt2TP369VNsbKxXdUqS3W6X3W5vtD8sLIzAAgBAJ3Oh6Rxe3SUUEBCg1NRUZWVleezPysrSqFGjmjxm9OjROn78uCoqKtz79u3bJx8fH3fXT3p6eqM6V61a1WydAADgyuL1bc0zZszQn//8Z7355pv69ttv9cQTTygnJ0dTp06VVDdUc88997jL33333YqMjNTPf/5z7d69W+vWrdO//uu/6he/+IV7OOjxxx/XqlWr9Pzzz2vPnj16/vnntXr1ak2fPr19zhIAAHRqXs9hyczMVHFxsebOnav8/HylpKRo5cqVSkpKkiTl5+d7rMkSEhKirKwsPfbYYxo+fLgiIyM1efJk/e53v3OXGTVqlN577z09/fTTeuaZZ9SnTx8tW7ZMI0eObIdTBAAAnZ3X67BYVVlZmcLDw1VaWsocFgAAOonWfn/zLCEAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5BBYAAGB5bQosCxcuVHJysgIDA5Wamqr169c3W3bt2rWy2WyNtj179rjLvPXWW02WqaqqakvzAABAF+Pn7QHLli3T9OnTtXDhQo0ePVqvv/66Jk6cqN27dysxMbHZ4/bu3auwsDD3+549e3p8HhYWpr1793rsCwwM9LZ5AACgC/I6sMyfP1/333+/HnjgAUnSggUL9Nlnn+m1117TvHnzmj0uOjpa3bt3b/Zzm82m2NjYVrfD4XDI4XC435eVlbX6WAAA0Ll4NSRUXV2tLVu2KCMjw2N/RkaGNm7c2OKxQ4cOVVxcnMaPH681a9Y0+ryiokJJSUmKj4/XpEmTlJ2d3WJ98+bNU3h4uHtLSEjw5lQAAEAn4lVgKSoqktPpVExMjMf+mJgYFRQUNHlMXFycFi1apOXLl+uDDz7QgAEDNH78eK1bt85dZuDAgXrrrbf08ccfa+nSpQoMDNTo0aO1f//+Ztsya9YslZaWurfc3FxvTgUAAHQiXg8JSXXDN+czxjTad86AAQM0YMAA9/v09HTl5ubqxRdf1NixYyVJaWlpSktLc5cZPXq0hg0bpldeeUUvv/xyk/Xa7XbZ7fa2NB8AAHQyXvWwREVFydfXt1FvSmFhYaNel5akpaW12Hvi4+OjESNGtFgGAABcObwKLAEBAUpNTVVWVpbH/qysLI0aNarV9WRnZysuLq7Zz40x2rZtW4tlAADAlcPrIaEZM2ZoypQpGj58uNLT07Vo0SLl5ORo6tSpkurmluTl5WnJkiWS6u4i6t27twYPHqzq6mq98847Wr58uZYvX+6uc86cOUpLS1O/fv1UVlaml19+Wdu2bdOrr77aTqcJAAA6M68DS2ZmpoqLizV37lzl5+crJSVFK1euVFJSkiQpPz9fOTk57vLV1dX61a9+pby8PAUFBWnw4MH65JNP9MMf/tBdpqSkRA899JAKCgoUHh6uoUOHat26dbr++uvb4RQBAEBnZzPGmMvdiPZQVlam8PBwlZaWeixQBwAArKu13988SwgAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAALTIGKPCsqrL2ga/y/rbAQDogmqcLh0tPqMDheU6UFihA4UVyis5q3EDY/TQ2Kvl62O73E1stUpHrZ5asUNfHCzWyl+OUc9Q+2VpB4EFAIA2qqpx6tDJSu0vLNfBwgrtrw8nR4orVeM0jcp/feS0Nhw4qQWZQy/bF3+Lah1Seb5Uli+VH1dh3iF9/s0/9IOqQv0f22n9Y9erGp824rI0jcACAGgXxhgdO31WV3UPkk8n6kFojfKqGndPyYGTFTpwou5nzqkzMo1ziSSpW4Cv+kaHuDd/Hx/Nz9qnLw4U64cvr9d/3DlEo/pEXZoTMEaqKq0PI8frNo/Xx+tCypkij8OiJf1Mknzrd8RWX5r2NoHAAgC4aCfKqvTr9/+hz/edVO/IbpqS3ls/TY1XeJD/5W6aV05VVmv/iXIdOFmh/ScqdLD+Z0EL8ze6d/NXv/pQ0qdniPrFhKpvdIh6hQfKZvMMbjcO7KlH383W3hPl+j9/3qzHx/fXtHF9L26IyOWUKgrrQ8dxd++IZzDJl2oqW1Wd8bWr2CdSBx1hKjAR8u9+lW4Y/j0FRyVKPQe0vZ0XyWZMc9mwcykrK1N4eLhKS0sVFhZ2uZsDAFeMj7cf1zMf7lTp2RqP/d0CfHX70Kt0T3pvDYgNvUytu7CjxZVavjVPH2bnKefUmWbLRYfa1S8mRH17hqhvTKj69gxRv5gQRQYHNAomLTlb7dSzH+/Ssm9yJUmj+0Y2P0RUc7blHpGy41LFCck4W/fLA7tLYb2k0Li6n+7XV0lhcTpQFaapyw/rwMlK+dikJzMG6F9u6NOhPWat/f4msAAA2uR0ZbWe+Win/vcf+ZKklKvC9Nxt12rn8VL958Yj2neiwl027eoI3ZveWzcNipGf7+W/QbW8qkYrd+Rr+ZY8fXXklMdn8T2C3D0m/aJD1af+dbv2Fhmj/928S3/+ZIO6O4vUL6hc9wz2V4JvyXc9ImV5UlVJ6+qz+UghMY0CiEJ7eQaTgG7NVvE/3+TqmY92qqrGpehQu165a6hGXh3ZLqfbEgILAKDDrNlbqN+8/w8Vljvk62PTozf21WPj+sq/PowYY/TloVNasumIVu0+Iaer7qsmLjxQ/yctSZkjEhQVcmknnTpdRhsPFun9Lcf02a4CVdW4JEk2m/T9vlH6aWq8fnBNjILtFzlbwlkjlRd81yNSXh8+yvK/e11eINW28jZh/25N9Ig0CCbB0ZJv29p9ttqpZz7aqfe3HJMkjekXpZcyh1yy60NgAQC0u0pHrX73ybda+lWOJOnqnsF6afIQXZfQvdljjpec1bubj2rpV7k6VVk3aTPA10eTvhene0f1bvHY9nCgsELLtx7Tiq15HnNR+vQM1k9S43X70KsUFx7Uusoc5efNETkXPvI9X1cUSmrlV2u3SLlC4rT3TIiyS7qpwEQoJDpBk8eNVPfopLowEti9LlV1gAOF5Xrk3a3ad6JCPjbpiR/016M39r2kk6YJLACAdvX1kVN68r+3u+d5/Hx0b/3m5oEK9Pe9wJF1qmqcWrkjX/+56ai255a491+X0F33pifpR9+Lk92vdXVdSOmZGn38j+NavuWYtp33u8KD/HXLdb30k9R4XRcf/t3cE5er7g6Z5npEzr12lLWuAT5+DXpCmpg3Ehon+Qe6D/lg6zE9tWKnztY41TPU3uF3EV3q39ccAgsAoF1U1Tj1UtY+LVp/SMZIV3UP0r//7HsX9eW2LbdESzYe0f/+I1/VzrqhmcjgAN15fYL+eWSSenVvZY/HeWqdLn2+76SWbz2m1bsL3fUG+dTqlmSbbuvro+ERZ+RfeaJx70h5vuSqucBvqGcPqw8f9UMy516fP1+kW5Tk4/1cnQOF5e67iHxsap+7iBqoqnFq9ketnPR7CRBYAAAXbdfxUs1Ytl17T5RLkn6WGq9nfjxIYYHtMwG1qMKhZV/n6p0vjyq/tG64xtfHpoxBMbonvbfSro5o/g6c+rVFDh7ar83bdujAwf0KdhQqznZKMbbTSgoo1VU+pxVUc7qVrbFJIdH1PSC96kNIwwmscZK9Y+948uouIi8dPFmhR9/dqj0F5bLZpOkdEIi8RWABALRZrdOlP35+UAtW71etyygqJED/dvu1yhgc22G/L2v3Cf3npiP68tAp+cilKJUqLbJKP+nvo7Qoh+xnT7hv63WWHperNE/+rlZOXPW1N5602nDiakiM5GuddWPae8jmo215mvXBDp2pdioqxK6X7xyiUX0v/RBQQwQWAECbHDpZoRn/vd0992PC4Bj92+3XKrK97hq5wNoiNSXH5FN5Ur5q3doip02IKu3RCoy4ShFxyfIJ69V4iCaoR4dNXO1I7TFEVFXj1Jy/7NLSr+p6bNKvjtR/3DVE0aGBFzjy0ujQwLJw4UL9+7//u/Lz8zV48GAtWLBAY8aMabLs2rVrdeONNzba/+2332rgwIHu98uXL9czzzyjgwcPqk+fPnruued0++23t7pNBBYAXUFheZUKyxzqHxOqAL9Lu16Jy2X09pdHNe/Tb1VV41JooJ/m3DJYtw+9qnULoxkjnT193iTVhqut1r9u5doixuaryoAo5dSE62hNuApMRP3WQwUmUt1jEzU29Vr9cGgf9QgOuLiTt7CLGSI6dLJCj/5Xtr7NL5PNJj02rp8eH9/PUg9fbO33t9c3bS9btkzTp0/XwoULNXr0aL3++uuaOHGidu/ercTExGaP27t3r0dDevbs6X69adMmZWZm6re//a1uv/12rVixQpMnT9aGDRs0cuRIb5sIAJ2Oy2X05heH9cJne1Vd65Ldz0fXxXfXsKQeGp7UQ8OSeiiiA7+Uj5ec1b++v11fHCiWVLcuyQs//d53k18bri1y/mqrbVpbJLiZOSLf9Y7YQqIV4uOrgS6jwv0ntX7TUeWcOqPx10Rr2rB49Yux7uq57SkowFfP//R7Gnl1hJ5asfO7ZxFltjyk85ftxzVz+T9UWe1UZHCAFtw5RGP69Wy2vNV53cMycuRIDRs2TK+99pp73zXXXKPbbrtN8+bNa1T+XA/L6dOn1b179ybrzMzMVFlZmT799FP3vptvvlk9evTQ0qVLW9UuelgAdFbHTp/Rr/5nu748VLfiapC/r87WNB4OuToqWMOSeii1fuvbM+Si18swxugvX+/Tn1d+oZDqk0rwK1HmAF8NDT8rW3lb1xaJanAHTRMLngWGd8ohmsvt/CEim016fHw/PTbOs8ekqsap3/7vbr27uW6tnOuTI/TKXUMVE2aNIaCGOqSHpbq6Wlu2bNHMmTM99mdkZGjjxo0tHjt06FBVVVVp0KBBevrppz2GiTZt2qQnnnjCo/yECRO0YMGCZutzOBxyOBzu92Vlrbw3HgAswhijD7bm6dmPd6ncUasgf1899aNrdPf1iTpcXKktR09r69HT2nL0tPYXVuhQUaUOFVW6VyQNDfTTsMTvAsx1Cd0Vcv4qrRdYW6S25LhqSvJ0i6tSt0jSuQ6c/c002Mf/vADSuEfE3WPid3luj70S9I0O1YePjnYPES1YvV9fHznlHiI6UlSpR/9rq3YdrxsCevSf+mr6D/pZ4nEIF8urwFJUVCSn06mYmBiP/TExMSooKGjymLi4OC1atEipqalyOBx6++23NX78eK1du1Zjx46VJBUUFHhVpyTNmzdPc+bM8ab5AGAZxRUOPbVip/66q+7vuaGJ3TV/8hAlRwVLkvr0rHvy7+ThCZKkkjPVys4t0dajp/XNkdPalXtSYY7jqty/U/sPnFKZ7bT22E6pf1C5EgNK1dNVrCDHSdlaWFvET999CTh8gxXQI0G2sBaWgO8W2aa1RdC+mhoimvgf6/Xz0b312tqDqnDUKiI4QC9lDtEN/TvvEFBDbXrwQMPJV8aYZidkDRgwQAMGfPc46vT0dOXm5urFF190BxZv65SkWbNmacaMGe73ZWVlSkhI8Oo8AOBy+Nu3J/Sb5TtUVOGQn49NT9zUXw+PvbruX8H1a4s07BHpXpanG8vydeO5iay+xVJTi8LW1G/1XLKpzDdCNd1i5N/jKgVGxOvvx/21+piPChShoIgEPfnTf9Kg3r0u1emjndwxLF7fiw93DxH9+2d7JUnX947Qy3cNVWy4NYeA2sqrwBIVFSVfX99GPR+FhYWNekhakpaWpnfeecf9PjY21us67Xa77Ha6HYHOqMbpksuYdluGvbOoOOvQf3z0hb7avkOpttO6tnulMgf4qufpD6W3z7uTpuZM6ypssLZIhT1GOTXh2l0RrK9OBWnTyQDlO8NUKz+pUtLJ7w612aSHxl6tGTf1v+KuQ1dybohozl92aUV2nn7x/WQ9eVP/LjEE1JBXgSUgIECpqanKysryuOU4KytLt956a6vryc7OVlxcnPt9enq6srKyPOaxrFq1SqNGjfKmeQAsrryqRovWHdIbGw7rbI1TvcKDlBjRTUmR3ZQY2U1JEcHu1+21kuolU32mwdN5Pe+kqT59TIFnCvWUXNK5f2tVSdreTH1BPb6bF3L+yqvnT2RtsLZIiKRB9dtPVTf5ckdeqbbUz4PZevS0iiurlRjRTX+YfJ1G9I7oyP8iuESCAnz1+598T8/dfq2lbldub14PCc2YMUNTpkzR8OHDlZ6erkWLFiknJ0dTp06VVDdUk5eXpyVLlkiSFixYoN69e2vw4MGqrq7WO++8o+XLl2v58uXuOh9//HGNHTtWzz//vG699VZ99NFHWr16tTZs2NBOpwngcnLUOvXOlzl6dc0B99N6JSmv5KzySs5q06HiRsdEBAe4w0xSRDclRga7X/cMtbduXZD2YIx05tR5t/C2bW2Rc/NZa+UjZ7cY2Xtc1fzKq6FxUkC3i256oL+vRvSOcAcTY4wKyx2KCrF36S+2K1VXv6ZeB5bMzEwVFxdr7ty5ys/PV0pKilauXKmkpCRJUn5+vnJyctzlq6ur9atf/Up5eXkKCgrS4MGD9cknn+iHP/yhu8yoUaP03nvv6emnn9YzzzyjPn36aNmyZazBAnRyTpfRh9l5mp+1T3klZyVJV/cM1q8nDFBqUoRyTlXqaPEZHS0+o5xTZ3S0uFI5p86oqKJapyrrtvOftHtOkL+vEiPqemJ6R9aHmfpw06t7kPxb2x3e0toi5792Oi5cl/Td2iL1PSLFvpF6b0+ttpd2U4GJUGrKYD1x+2iFdbs8cwtsNptlb20FLoSl+QG0O2OM/r6nUC/8da/7oXkxYXZN/0F//Sw1/oLj6xWO2rrwUnxGR0+dCzR14eZ4yVm5Wvhby9fHpvgeQRqTEKiMBJeGR1apW9WJJoZq2nltkbBedU/xtdnkdBn9ef0h/WHVPlU7XYoIrnsOz80pHfMcHqAz67CVbgFcWO6pM/qPv+3XoLgw/Wx4vEI723yMi7Dl6Cn9/tM9+vpI3RNywwL99C//1Ff3jeqtoIDWTe4MsftpcK9wDe4V3uiz6ppa5R/PVeHxIyo/cVRnTx2TKc1TwJkCBTtOKlqnFFNxSmF7zkp7WvHLLri2SC8pNLbVa4vknjqjJ/97u746UrcI3PiB0Zr3k2st89wWoLMisADtbPfxMt27+CudLK8bRngpa58mj0jQfaN6KyHi4uclWNW+E+V64a97tfrbE5Iku5+P7hvdW4/c0Ffh3VoZ2GodjXtBys5bbbUsXwHl+Upy1SipqeMbdNxUqJuOu3qowETohOmhfEWotlusYuOv1oD+A5RyzUDZQ6PbZW0RY4z+55tjmvOXXaqsdio4wFfPTBqkzBEJl26+DdCFMSQEtKNNB4v10JJvVO6oVd/oELmM0aGTlZIkH5uUMShW949J1vCkHl3mS+x4yVm9lLVPy7cek8vUnefk4Ql6/Af9FBde/xyac2uLNPX8mfMnsp5pPPm2aTYpJKaF1VbPDdGE6HBRpf6+p1Br9hRq8+Fi1Ti/+yuvW4CvRveN0riB0bpxQHSb160oqnBo5vId7rA2oncP/eFnQ5QY2XUDKtBeOvRpzVZEYMHltnJHvqa/t03VTpeuT47Qn+4ZrlC7nz7ff1Jvbjis9fuL3GW/Fx+uX4xO1g+vjbvkT+RtL6crq7Vw7QG9vemwwmtPKdZ2SjcnGv20v496uoob95S0dm0Rv8AGK6yeP1ek/iF5ITGSr/fDbBWOWm3YX6Q1ewq1Zm+hCss9J9MOigurCy8DozUkoXur7rpYtatAsz7YoeLKavn72vRkxgA9OObqLn/HBtBeCCzAJbRk0xHN/niXjJFuHhyrBXcOUaC/53yNvQXlWvzFYX2QnafqWpekuomo96T31t3XJ6pHBz6Jt80arS1S9/yZo0cOqLIoRz3NKfVUifxsrtbV14a1RTqKy2W0O79Mf99TqL/vKdT2YyU6/2/DiOAA3dC/p24cGK0b+vVsNKxVXlWjuX/Zrf+pf67PwNhQzZ88RIN68fcP4A0CC3AJGGP0h1X79P/WHJAk/fPIRM29NaXFf10XVzj0X5tztOTLo+55LoH+Prp9aLzu/35v9Y0OvRQN91xbxD1HpMH6IhdYW8Rdnc1XttDY5ntEzu33D+rY87oIRRUOfb73pP6+t1Dr9p1UeVWt+zNfH5tSE3voxoHRGn9NtE5VVuvJ/96uvJKzrBgLXCQCC9DBap0u/d8VO/Tf39T9C3vGTf312Li+rZ6b4qh16pN/5OuNDYe16/h3Txu/oX9P/eL7yRrbL6pt81w81hY5f45I29YWMf7BqrT31L6zYTpcHaYTJkJVQTEaNfRaXX9tiny6XyUF95R8us6XdY3TpS1HT2tNfe/L/sKKJsvF9wjS/MlDdH0yK8YCbUVgATrQ2Wqnpv3XVv1tT6F8bNJzt1+ru65PbFNdxhhtPnxKb244rKxvT7iHJfpFh+jno5N1x7CrvhtecpQ37hG56LVFmu8R+bIoUP/2t2P6R15doIoMDtC0cX1198jEK6o3IffUGa3ZWxdeNh4sVnWtS5nDE/TMjwcpxM7NlsDFILAAHeR0ZbXu/8+vtTWnRHY/H71y11BlDL7IBcFcLulMkfJzD2rt19u1/8A+RbiKFGs7rXjf0+oXVKEezpPyqW76X/qN+Pg3fddMM2uLGGNUVlWrogqHisodOlnh0LKvc90ThYMDfPXAmKv14Nirr/gv6LPVTlVW1yoqhIevAu2BheOADpBXclb3vLFZB09WKjzIX2/cO1zDL/QAuZqqup6PpuaInHtdXiC5ahQn6S6pbj2R828eOvvdS6d/qHy7t7DaamgvqVuknLLp9JlqFVdU1wWRCodOnnaoKLdaxRUlKqo4oaL6z4orqlXtbDxx1t/Xpn8emaRp4/ryBV0vKMC31QvgAWg/BBaglfYUlOneN7/SiTKH4sID9Z8/H6H+4U7pxO4Gz6D5bpEzlbdxbZH6u2acIbHaWR6sFQeN1hX4q8BE6ExVoK6PilDm4AQZ1U0WLTrhUNFBh4orq3Sy/Nv6Z/E4WlzCvimhdj9FhdoVFRKgfjGhmjq2D2uJALAEhoSApjhrpYoT7p6QI4cP6O9fZ6uHs1jJAWVKCa2QX0WBVHv2wnVJ560tcv4ckas8h20usLbI9twSvfnFYX3yj3zVepFEenTzV1SIXVEhdkWGBCgqxK6e9aGk4f6Gt2IDQEdjDgvQnOpKz9VVm5y4ekIyXqwt4l5HpMGaIh2wtkhBaZWWbDqiLw4WKyzQrz50fBc+okLtigwOUM9QuyKCA1r/5GIAuAyYw4IrjzF1wy/u4HG8QTCpf11V2rr6bL6qtEdp75lQFZgIBfS4SjcMv07+3ePPW/gs7pKvLRIbHqhf3zzwkv5OALjcCCzoHGqrpYqClhc5K8+XnNWtq88/uPHQzHm9JCa0l/7jyxIt+PshSdKdIxL0u9tS5EdvBQBcFgSWy6CqxqmjxWd0uKhCh4vOKCTQTzddE9PmB691elVlF17krLKw9fVdYG2RuofihTU7RON0GT394U4t/SpHkvTLcX31xE39u8zDCgGgMyKwdJBap0t5JWd1uKjSYzt0slLHS8+q4cyhZz7cqWGJ3XVzSqwmpsQpIaIL3JnhckmVJ1ueK1J2XGrr2iJNzRs5b22RtqiqceqXS7O1avcJ2WzS3FtTNCUtqc31AQDaB5NuL4IxRifLHTrUIJAcLqpQzqkzHo+xbyg00E9XRwWrd1Swck+d0dacEo/PB/cK08SUWN2cEntpni3jrWbXFjnXS1K/uWovXJck2cObuHum8doi8um4IZnSMzV6YMnX+vrIaQX4+ejlO4fo5pS4Dvt9AADuEmrXukvP1tQHkgodPlnpDihHiipVWe1s9rgAPx8lRwYrOSpYyT3rfp4LKZHBAR5DDCfKqvTZrgJ9uqNAmw8Xe6yf0Tc6RBNTYjVhcKwG9wrr2KEJY+oeeNdwSKYd1xZp8k4ae0jHnVMr5Jee1b1vfqV9JyoUGuinP90zXGlXR17WNgHAlYDA0k5u/X8btP1Y83eV+NikhIhudaGkPpAkR4UouWew4sIC5dPCU3ubU1zh0OpvT+jTnQX64kCRR09NYkQ33Vzf8zIkvrt39TdYW8TzTprzeke8Xlukqfki9ftCYiRfa4887j9Rrnvf/ErHS6sUE2bXf/7ieg2M5dZ4ALgUCCzt5N43v9Ln+04qJsxeH0pC6kNJXa9JQo9uCvDrwGGKszX6+54T+uvOAq3de1KO2u/WBokNC9SEwTG6OSVOI3oFyK/yRDuuLRLRxJLvDV6349oil8uWo6f0i7e+UenZGl3dM1hLfnG94nt0gflDANBJEFjayYmyKoXY/RR8uR74dt7aIlWncrX/wD7l5RzS2aIcRbqKFWM7rVjbKYXbzrSuPh8/KST2vHVEmpjAehnWFrmUXC6j/LIqfXmwWP93xQ45al0aktBdb943QhHBAZe7eQBwRWHhuHYSE9aBtxp7ubZIoKRr6zfZJDVYRb3CBKrARKjIJ1K+4b0UGddbCUl95N8j/rvhmuCeMjabqp0uVde65Kit++l+fcYlR9lZVddWyuF0yVHjOq+s07NsrUtOY9QzxK648EDFhgeqV/cgRYXY5duGobD25HQZ5Zee1ZGiMzpSXKmjxZU6XHRGR4srdfTUGVWf11N144CeevWfh6lbAP87AIBV8Td0R6kqa3m11bLjdbf8tlZwdINber/rHakJjtM3pwL1v3sr9NmuEyqqcEhVkk5IQbt81aObvxy1xaquPSlHffjoSL4+NsWE2hUbHqi48KD6n4Hn/QxSdKj9opeMd7qMjpec1ZHiugnQR4rP1AeTSuWeOtvk04fP8fOxKTGim24aFKNfTRjA8vUAYHEMCXnL5awLGs2tKXLudWvXFvENaPzcmYYTWENiJb/WDVU4XUZbc07r0x0F+mxXgfJKLjyB1t/XJrufrwL8fGT381GAn48CfH1k96/7Wbe/7vNzZez1ZWw2m06WO5RfelYFpVU6Ue6QsxUP5rPZ5NEz4xFswurex4Tb5WuzKa/krEcYOVpc12uSe4FbxwN8fZQQEaTekcFKigxW76hu6h0ZrN6RwerVPZBVawHAApjD0l4+f0Eq2PHdLb0VBa1fWyQwvMkeEY9bertFdtjEVWOM9p2okKPWeV4I8T0vhNTta8udTM1xuoyKKhzKL61SQenZ+p9V3/0sqws2LQWN8/n62FoMQAF+PkqK6FYXSCK7KSkqWMmRwUqK7KZe3YMu+9AUAKBlzGFpL/uzpGNfee6z+dTdrtvsHTT1wSQg+PK0+VwzbTYNiL20i875+tgUExZYN/cnoXuTZVwuo1Nnqs8LMg2CTVmVjpeclaPWJafLyO7nU99L0k29o4Lre0nqwklsWCChBACuAASWCxnxgJTyE8+ekU6wtoiV+fjYFBViV1SIXSlXhTdZxhij0rM1qqpxKTrU3q69QACAzodv3Qu5LvNyt+CKZLPZ1L0btxgDAOow6xAAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFgegQUAAFhemwLLwoULlZycrMDAQKWmpmr9+vWtOu6LL76Qn5+fhgwZ4rH/rbfeks1ma7RVVVW1pXkAAKCL8TqwLFu2TNOnT9dTTz2l7OxsjRkzRhMnTlROTk6Lx5WWluqee+7R+PHjm/w8LCxM+fn5HltgYKC3zQMAAF2Q14Fl/vz5uv/++/XAAw/ommuu0YIFC5SQkKDXXnutxeMefvhh3X333UpPT2/yc5vNptjYWI+tJQ6HQ2VlZR4bAADomrwKLNXV1dqyZYsyMjI89mdkZGjjxo3NHrd48WIdPHhQs2fPbrZMRUWFkpKSFB8fr0mTJik7O7vFtsybN0/h4eHuLSEhwZtTAQAAnYhXgaWoqEhOp1MxMTEe+2NiYlRQUNDkMfv379fMmTP17rvvys/Pr8kyAwcO1FtvvaWPP/5YS5cuVWBgoEaPHq39+/c325ZZs2aptLTUveXm5npzKgAAoBNpOkFcgM1m83hvjGm0T5KcTqfuvvtuzZkzR/3792+2vrS0NKWlpbnfjx49WsOGDdMrr7yil19+uclj7Ha77HZ7W5oPAAA6Ga8CS1RUlHx9fRv1phQWFjbqdZGk8vJyffPNN8rOzta0adMkSS6XS8YY+fn5adWqVRo3blyj43x8fDRixIgWe1gAAMCVw6shoYCAAKWmpiorK8tjf1ZWlkaNGtWofFhYmHbs2KFt27a5t6lTp2rAgAHatm2bRo4c2eTvMcZo27ZtiouL86Z5AACgi/J6SGjGjBmaMmWKhg8frvT0dC1atEg5OTmaOnWqpLq5JXl5eVqyZIl8fHyUkpLicXx0dLQCAwM99s+ZM0dpaWnq16+fysrK9PLLL2vbtm169dVXL/L0AABAV+B1YMnMzFRxcbHmzp2r/Px8paSkaOXKlUpKSpIk5efnX3BNloZKSkr00EMPqaCgQOHh4Ro6dKjWrVun66+/3tvmAQCALshmjDGXuxHtoaysTOHh4SotLVVYWNjlbg4AAGiF1n5/8ywhAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeQQWAABgeW0KLAsXLlRycrICAwOVmpqq9evXt+q4L774Qn5+fhoyZEijz5YvX65BgwbJbrdr0KBBWrFiRVuaBgAAuiCvA8uyZcs0ffp0PfXUU8rOztaYMWM0ceJE5eTktHhcaWmp7rnnHo0fP77RZ5s2bVJmZqamTJmi7du3a8qUKZo8ebI2b97sbfMAAEAXZDPGGG8OGDlypIYNG6bXXnvNve+aa67Rbbfdpnnz5jV73J133ql+/frJ19dXH374obZt2+b+LDMzU2VlZfr000/d+26++Wb16NFDS5cubVW7ysrKFB4ertLSUoWFhXlzSgAA4DJp7fe3Vz0s1dXV2rJlizIyMjz2Z2RkaOPGjc0et3jxYh08eFCzZ89u8vNNmzY1qnPChAkt1ulwOFRWVuaxAQCArsmrwFJUVCSn06mYmBiP/TExMSooKGjymP3792vmzJl699135efn12SZgoICr+qUpHnz5ik8PNy9JSQkeHMqAACgE2nTpFubzebx3hjTaJ8kOZ1O3X333ZozZ4769+/fLnWeM2vWLJWWlrq33NxcL84AAAB0Jk13eTQjKipKvr6+jXo+CgsLG/WQSFJ5ebm++eYbZWdna9q0aZIkl8slY4z8/Py0atUqjRs3TrGxsa2u8xy73S673e5N8wEAQCflVQ9LQECAUlNTlZWV5bE/KytLo0aNalQ+LCxMO3bs0LZt29zb1KlTNWDAAG3btk0jR46UJKWnpzeqc9WqVU3WCQAArjxe9bBI0owZMzRlyhQNHz5c6enpWrRokXJycjR16lRJdUM1eXl5WrJkiXx8fJSSkuJxfHR0tAIDAz32P/744xo7dqyef/553Xrrrfroo4+0evVqbdiw4SJPDwAAdAVeB5bMzEwVFxdr7ty5ys/PV0pKilauXKmkpCRJUn5+/gXXZGlo1KhReu+99/T000/rmWeeUZ8+fbRs2TJ3DwwAALiyeb0Oi1WxDgsAAJ1Ph6zDAgAAcDkQWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOW1KbAsXLhQycnJCgwMVGpqqtavX99s2Q0bNmj06NGKjIxUUFCQBg4cqJdeesmjzFtvvSWbzdZoq6qqakvzAABAF+Pn7QHLli3T9OnTtXDhQo0ePVqvv/66Jk6cqN27dysxMbFR+eDgYE2bNk3f+973FBwcrA0bNujhhx9WcHCwHnroIXe5sLAw7d271+PYwMDANpwSAADoamzGGOPNASNHjtSwYcP02muvufddc801uu222zRv3rxW1XHHHXcoODhYb7/9tqS6Hpbp06erpKTEm6Z4KCsrU3h4uEpLSxUWFtbmegAAwKXT2u9vr4aEqqurtWXLFmVkZHjsz8jI0MaNG1tVR3Z2tjZu3KgbbrjBY39FRYWSkpIUHx+vSZMmKTs7u8V6HA6HysrKPDYAANA1eRVYioqK5HQ6FRMT47E/JiZGBQUFLR4bHx8vu92u4cOH69FHH9UDDzzg/mzgwIF666239PHHH2vp0qUKDAzU6NGjtX///mbrmzdvnsLDw91bQkKCN6cCAAA6Ea/nsEiSzWbzeG+MabSvofXr16uiokJffvmlZs6cqb59++quu+6SJKWlpSktLc1ddvTo0Ro2bJheeeUVvfzyy03WN2vWLM2YMcP9vqysjNACAEAX5VVgiYqKkq+vb6PelMLCwka9Lg0lJydLkq699lqdOHFCzz77rDuwNOTj46MRI0a02MNit9tlt9u9aT4AAOikvBoSCggIUGpqqrKysjz2Z2VladSoUa2uxxgjh8PR4ufbtm1TXFycN80DAABdlNdDQjNmzNCUKVM0fPhwpaena9GiRcrJydHUqVMl1Q3V5OXlacmSJZKkV199VYmJiRo4cKCkunVZXnzxRT322GPuOufMmaO0tDT169dPZWVlevnll7Vt2za9+uqr7XGOAACgk/M6sGRmZqq4uFhz585Vfn6+UlJStHLlSiUlJUmS8vPzlZOT4y7vcrk0a9YsHT58WH5+furTp49+//vf6+GHH3aXKSkp0UMPPaSCggKFh4dr6NChWrduna6//vp2OEUAANDZeb0Oi1WxDgsAAJ1Ph6zDAgAAcDkQWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOURWAAAgOW1KbAsXLhQycnJCgwMVGpqqtavX99s2Q0bNmj06NGKjIxUUFCQBg4cqJdeeqlRueXLl2vQoEGy2+0aNGiQVqxY0ZamAQCALsjrwLJs2TJNnz5dTz31lLKzszVmzBhNnDhROTk5TZYPDg7WtGnTtG7dOn377bd6+umn9fTTT2vRokXuMps2bVJmZqamTJmi7du3a8qUKZo8ebI2b97c9jMDAABdhs0YY7w5YOTIkRo2bJhee+01975rrrlGt912m+bNm9eqOu644w4FBwfr7bffliRlZmaqrKxMn376qbvMzTffrB49emjp0qVN1uFwOORwONzvS0tLlZiYqNzcXIWFhXlzSgAA4DIpKytTQkKCSkpKFB4e3nxB4wWHw2F8fX3NBx984LH/l7/8pRk7dmyr6ti6dauJiYkxf/rTn9z7EhISzPz58z3KzZ8/3yQmJjZbz+zZs40kNjY2NjY2ti6w5ebmtpgf/OSFoqIiOZ1OxcTEeOyPiYlRQUFBi8fGx8fr5MmTqq2t1bPPPqsHHnjA/VlBQYHXdc6aNUszZsxwv3e5XDp16pQiIyNls9m8Oa0WnUt+V0rPzZV0vpxr13UlnS/n2nVdKedrjFF5ebl69erVYjmvAss5DQOBMeaCIWH9+vWqqKjQl19+qZkzZ6pv376666672lyn3W6X3W732Ne9e/dWnoH3wsLCuvQfmIaupPPlXLuuK+l8Odeu60o43xaHgup5FViioqLk6+vbqOejsLCwUQ9JQ8nJyZKka6+9VidOnNCzzz7rDiyxsbFtqhMAAFwZvLpLKCAgQKmpqcrKyvLYn5WVpVGjRrW6HmOMx4TZ9PT0RnWuWrXKqzoBAEDX5fWQ0IwZMzRlyhQNHz5c6enpWrRokXJycjR16lRJdXNL8vLytGTJEknSq6++qsTERA0cOFBS3bosL774oh577DF3nY8//rjGjh2r559/Xrfeeqs++ugjrV69Whs2bGiPc7wodrtds2fPbjT81FVdSefLuXZdV9L5cq5d15V2vhfi9W3NUt3CcS+88ILy8/OVkpKil156SWPHjpUk3XfffTpy5IjWrl0rSXrllVf0+uuv6/Dhw/Lz81OfPn304IMP6uGHH5aPz3cdPO+//76efvppHTp0SH369NFzzz2nO+64o33OEgAAdGptCiwAAACXEs8SAgAAlkdgAQAAlkdgAQAAlkdgAQAAlnfFB5bnnntOo0aNUrdu3ZpdKTcnJ0c//vGPFRwcrKioKP3yl79UdXV1i/U6HA499thjioqKUnBwsG655RYdO3asA86g7dauXSubzdbk9vXXXzd73H333deofFpa2iVsedv17t27UdtnzpzZ4jHGGD377LPq1auXgoKC9E//9E/atWvXJWpx2xw5ckT333+/kpOTFRQUpD59+mj27NkX/HPbWa7twoULlZycrMDAQKWmpmr9+vUtlv/888+VmpqqwMBAXX311frjH/94iVp6cebNm6cRI0YoNDRU0dHRuu2227R3794Wj2nu/+s9e/Zcola3zbPPPtuozbGxsS0e01mvq9T030U2m02PPvpok+U763VtT21amr8rqa6u1s9+9jOlp6frjTfeaPS50+nUj370I/Xs2VMbNmxQcXGx7r33Xhlj9MorrzRb7/Tp0/WXv/xF7733niIjI/Xkk09q0qRJ2rJli3x9fTvylFpt1KhRys/P99j3zDPPaPXq1Ro+fHiLx958881avHix+31AQECHtLEjzJ07Vw8++KD7fUhISIvlX3jhBc2fP19vvfWW+vfvr9/97ne66aabtHfvXoWGhnZ0c9tkz549crlcev3119W3b1/t3LlTDz74oCorK/Xiiy+2eKzVr+2yZcs0ffp0LVy4UKNHj9brr7+uiRMnavfu3UpMTGxU/vDhw/rhD3+oBx98UO+8846++OILPfLII+rZs6d+8pOfXIYzaL3PP/9cjz76qEaMGKHa2lo99dRTysjI0O7duxUcHNzisXv37vVYzr1nz54d3dyLNnjwYK1evdr9vqW/KzvzdZWkr7/+Wk6n0/1+586duummm/Szn/2sxeM643VtN616xPIVYPHixSY8PLzR/pUrVxofHx+Tl5fn3rd06VJjt9tNaWlpk3WVlJQYf39/895777n35eXlGR8fH/PXv/613dveXqqrq010dLSZO3dui+Xuvfdec+utt16aRrWzpKQk89JLL7W6vMvlMrGxseb3v/+9e19VVZUJDw83f/zjHzughR3nhRdeMMnJyS2W6QzX9vrrrzdTp0712Ddw4EAzc+bMJsv/+te/NgMHDvTY9/DDD5u0tLQOa2NHKSwsNJLM559/3myZNWvWGEnm9OnTl65h7WD27Nnmuuuua3X5rnRdjTHm8ccfN3369DEul6vJzzvrdW1PV/yQ0IVs2rRJKSkpHk+RnDBhghwOh7Zs2dLkMVu2bFFNTY0yMjLc+3r16qWUlBRt3Lixw9vcVh9//LGKiop03333XbDs2rVrFR0drf79++vBBx9UYWFhxzewnTz//POKjIzUkCFD9Nxzz7U4THL48GEVFBR4XEu73a4bbrjB0teyKaWlpYqIiLhgOStf2+rqam3ZssXjekhSRkZGs9dj06ZNjcpPmDBB33zzjWpqajqsrR2htLRUklp1HYcOHaq4uDiNHz9ea9as6eimtYv9+/erV69eSk5O1p133qlDhw41W7YrXdfq6mq98847+sUvfnHBBwl3xuvaXggsF1BQUNDoIYw9evRQQEBAowc2nn9MQECAevTo4bE/Jiam2WOs4I033tCECROUkJDQYrmJEyfq3Xff1d///nf94Q9/0Ndff61x48Z5PB/Kqh5//HG99957WrNmjaZNm6YFCxbokUceabb8uevV8M+A1a9lQwcPHtQrr7zifoRGc6x+bYuKiuR0Or26Hk39PxwTE6Pa2loVFRV1WFvbmzFGM2bM0Pe//32lpKQ0Wy4uLk6LFi3S8uXL9cEHH2jAgAEaP3681q1bdwlb672RI0dqyZIl+uyzz/SnP/1JBQUFGjVqlIqLi5ss31WuqyR9+OGHKikpafEfi531urary93F0xFmz55tJLW4ff311x7HNDck9OCDD5qMjIxG+/39/c3SpUub/P3vvvuuCQgIaLT/Bz/4gXn44YfbdlJeaMv55+bmGh8fH/P+++97/fuOHz9u/P39zfLly9vrFLzSlvM95/333zeSTFFRUZOff/HFF0aSOX78uMf+Bx54wEyYMKHdz+VC2nKueXl5pm/fvub+++/3+vdd7mvbUF5enpFkNm7c6LH/d7/7nRkwYECTx/Tr18/827/9m8e+DRs2GEkmPz+/w9ra3h555BGTlJRkcnNzvT520qRJ5sc//nEHtKrjVFRUmJiYGPOHP/yhyc+7ynU1xpiMjAwzadIkr4/rjNf1YnTJSbfTpk3TnXfe2WKZ3r17t6qu2NhYbd682WPf6dOnVVNT0yjdn39MdXW1Tp8+7dHLUlhYeEmeQN2W81+8eLEiIyN1yy23eP374uLilJSUpP3793t9bHu4mOt97g6YAwcOKDIystHn5+5SKCgoUFxcnHt/YWFhs9e/I3l7rsePH9eNN97oflCpty73tW0oKipKvr6+jXpTWroesbGxTZb38/Nr8ppb0WOPPaaPP/5Y69atU3x8vNfHp6Wl6Z133umAlnWc4OBgXXvttc3+2esK11WSjh49qtWrV+uDDz7w+tjOeF0vRpcMLFFRUYqKimqXutLT0/Xcc88pPz/f/YW1atUq2e12paamNnlMamqq/P39lZWVpcmTJ0uS8vPztXPnTr3wwgvt0q6WeHv+xhgtXrxY99xzj/z9/b3+fcXFxcrNzfX4Qr+ULuZ6Z2dnS1KzbU9OTlZsbKyysrI0dOhQSXXjzZ9//rmef/75tjX4Inhzrnl5ebrxxhuVmpqqxYsXezxstLUu97VtKCAgQKmpqcrKytLtt9/u3p+VlaVbb721yWPS09P1l7/8xWPfqlWrNHz48Db9eb+UjDF67LHHtGLFCq1du1bJycltqic7O9sy17C1HA6Hvv32W40ZM6bJzzvzdT3f4sWLFR0drR/96EdeH9sZr+tFudxdPJfb0aNHTXZ2tpkzZ44JCQkx2dnZJjs725SXlxtjjKmtrTUpKSlm/PjxZuvWrWb16tUmPj7eTJs2zV3HsWPHzIABA8zmzZvd+6ZOnWri4+PN6tWrzdatW824cePMddddZ2pray/5OV7I6tWrjSSze/fuJj8fMGCA+eCDD4wxxpSXl5snn3zSbNy40Rw+fNisWbPGpKenm6uuusqUlZVdymZ7bePGjWb+/PkmOzvbHDp0yCxbtsz06tXL3HLLLR7lzj9fY4z5/e9/b8LDw80HH3xgduzYYe666y4TFxdn6fM9Nww0btw4c+zYMZOfn+/eztcZr+17771n/P39zRtvvGF2795tpk+fboKDg82RI0eMMcbMnDnTTJkyxV3+0KFDplu3buaJJ54wu3fvNm+88Ybx9/dv0/DnpfYv//IvJjw83Kxdu9bjGp45c8ZdpuH5vvTSS2bFihVm3759ZufOnWbmzJlGkmWG9Zrz5JNPmrVr15pDhw6ZL7/80kyaNMmEhoZ2yet6jtPpNImJieY3v/lNo8+6ynVtT1d8YLn33nubnAewZs0ad5mjR4+aH/3oRyYoKMhERESYadOmmaqqKvfnhw8fbnTM2bNnzbRp00xERIQJCgoykyZNMjk5OZfwzFrvrrvuMqNGjWr2c0lm8eLFxhhjzpw5YzIyMkzPnj2Nv7+/SUxMNPfee69lz+18W7ZsMSNHjjTh4eEmMDDQDBgwwMyePdtUVlZ6lDv/fI2pu7V59uzZJjY21tjtdjN27FizY8eOS9x67yxevLjZOS7n66zX9tVXXzVJSUkmICDADBs2zOM233vvvdfccMMNHuXXrl1rhg4dagICAkzv3r3Na6+9dolb3DbNXcPz/3w2PN/nn3/e9OnTxwQGBpoePXqY73//++aTTz659I33UmZmpomLizP+/v6mV69e5o477jC7du1yf96Vrus5n332mZFk9u7d2+izrnJd25PNGGMuWXcOAABAG3BbMwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsDwCCwAAsLz/D8ybjble/SWLAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "coeff: [0.00205436 0.49332832]\n", + "residue: [0.00063572]\n", + "0.8153207463656073\n" + ] + } + ], + "source": [ + "# count the freqcy of player1 win vs delta m\n", + "import matplotlib.pyplot as plt\n", + "print(len(player1_got_point[0]), len(player1_m[0]))\n", + "\n", + "MULTPLY_COEFF = 10\n", + "CUT_WIDTH = 10\n", + "\n", + "count_of_p1_win = {}\n", + "count_of_in_certain_m = {}\n", + "freq_of_p1_win = list()\n", + "all_delta_m = list()\n", + "\n", + "for i in range(len(player1_m)):\n", + " for j in range(len(player1_m[i])):\n", + " delta_m = player1_m[i][j] - player2_m[i][j]\n", + " if player1_got_point[i][j]:\n", + " count_of_p1_win[int(delta_m * MULTPLY_COEFF)] = count_of_p1_win.get(int(delta_m * MULTPLY_COEFF), 0) + 1\n", + " \n", + " count_of_in_certain_m[int(delta_m * MULTPLY_COEFF)] = count_of_in_certain_m.get(int(delta_m * MULTPLY_COEFF), 0) + 1\n", + "\n", + "\n", + "for i in range(-max_delta_m * MULTPLY_COEFF, max_delta_m * MULTPLY_COEFF):\n", + " if (count_of_in_certain_m.get(i, 0) > 100):\n", + " freq_of_p1_win.append(count_of_p1_win.get(i, 0) / count_of_in_certain_m[i])\n", + " else:\n", + " freq_of_p1_win.append(0)\n", + "\n", + "for i in range(-max_delta_m * MULTPLY_COEFF, max_delta_m * MULTPLY_COEFF):\n", + " count_of_in_certain_m[i] = count_of_in_certain_m.get(i, 0)\n", + "\n", + "plt.plot(range(-max_delta_m * MULTPLY_COEFF, max_delta_m * MULTPLY_COEFF), [count_of_in_certain_m[i] for i in range(-max_delta_m * MULTPLY_COEFF, max_delta_m * MULTPLY_COEFF)])\n", + "plt.show()\n", + "\n", + "plt.plot(range(-max_delta_m * MULTPLY_COEFF, max_delta_m * MULTPLY_COEFF), freq_of_p1_win)\n", + "plt.show()\n", + "\n", + "freq_of_p1_win = list()\n", + "for i in range(-CUT_WIDTH, CUT_WIDTH):\n", + " if (count_of_in_certain_m.get(i, 0) > 100):\n", + " freq_of_p1_win.append(count_of_p1_win.get(i, 0) / count_of_in_certain_m[i])\n", + " else:\n", + " freq_of_p1_win.append(0)\n", + "\n", + "# plt.plot(range(-28, 28), freq_of_p1_win)\n", + "# plt.show()\n", + "\n", + "poly_coeff, poly_residue, poly_rank, poly_singular_value, _ = np.polyfit(range(-CUT_WIDTH, CUT_WIDTH), freq_of_p1_win, 1, full=True)\n", + "regressed_freq = np.polyval(poly_coeff, range(-CUT_WIDTH, CUT_WIDTH))\n", + "correlate_coeff = np.corrcoef(range(-CUT_WIDTH, CUT_WIDTH), freq_of_p1_win)[0, 1]\n", + "r_squared = correlate_coeff**2\n", + "\n", + "plt.plot(range(-CUT_WIDTH, CUT_WIDTH), freq_of_p1_win, range(-CUT_WIDTH, CUT_WIDTH), regressed_freq)\n", + "plt.ylim(0.3, 0.6)\n", + "plt.show()\n", + "print(\"coeff:\", poly_coeff)\n", + "print(\"residue:\", poly_residue)\n", + "print(r_squared)" + ] + }, + { + "cell_type": "code", + "execution_count": 306, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: -0.2079626610329065 Std: 9.921375151785\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# fit with gauss\n", + "from scipy.stats import norm\n", + "\n", + "count_of_in_certain_m_alt = deepcopy(count_of_in_certain_m)\n", + "\n", + "count_of_in_certain_m_alt[0] = int((count_of_in_certain_m_alt[-1] + count_of_in_certain_m_alt[1]) / 2)\n", + "\n", + "fake_m = list()\n", + "\n", + "# print(count_of_in_certain_m)\n", + "\n", + "for key, value in count_of_in_certain_m_alt.items():\n", + " fake_m += [key + 1 / (MULTPLY_COEFF * 2)] * value\n", + "\n", + "# print(fake_m)\n", + "\n", + "point_count_by_m_mean, point_count_by_m_std = norm.fit(fake_m)\n", + "\n", + "# data = np.random.normal(loc=5.0, scale=2.0, size=1000)\n", + "# print(data)\n", + "print(\"Mean:\", point_count_by_m_mean,\"Std:\", point_count_by_m_std)\n", + "regressed_point_count_by_m = norm.pdf(range(-max_delta_m * MULTPLY_COEFF, max_delta_m * MULTPLY_COEFF), point_count_by_m_mean, point_count_by_m_std)\n", + "plt.plot(range(-max_delta_m * MULTPLY_COEFF, max_delta_m * MULTPLY_COEFF), regressed_point_count_by_m)\n", + "plt.hist(fake_m, bins=[i for i in range(-max_delta_m * MULTPLY_COEFF, max_delta_m * MULTPLY_COEFF + 1)], density=True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# delta m: 滞回" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ICM2024", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}