Traffic_Gravity.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython import get_ipython\n",
    "get_ipython().magic('reset -sf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "# np.set_printoptions(suppress=True) # чтоб без e\n",
    "from matplotlib import pyplot as plt\n",
    "from mpl_toolkits.mplot3d import axes3d, Axes3D\n",
    "import time\n",
    "from pylab import *\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--- 0.01526498794555664 seconds ---\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>i</th>\n",
       "      <th>j</th>\n",
       "      <th>amt</th>\n",
       "      <th>t</th>\n",
       "      <th>s</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>40</td>\n",
       "      <td>26</td>\n",
       "      <td>2.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "      <td>49</td>\n",
       "      <td>8.1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>35</td>\n",
       "      <td>6.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>2</td>\n",
       "      <td>75</td>\n",
       "      <td>9.3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1</td>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>30</td>\n",
       "      <td>8.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   i  j  amt   t    s\n",
       "0  1  1   40  26  2.2\n",
       "1  1  2    4  49  8.1\n",
       "2  1  3    3  35  6.8\n",
       "3  1  4    2  75  9.3\n",
       "4  1  5    2  30  8.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "df = pd.read_csv('traffic_moscow.csv', header=None)\n",
    "df.columns = [\"i\", \"j\", \"amt\", \"t\", \"s\"]\n",
    "print(\"--- %s seconds ---\" % (time.time() - start_time))\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Надо учесть коэффициент 1.62\n",
    "для этого добавить столбец принадлежности к Москве-области и умножить amt москвичей на 1.62"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_index(i, j):\n",
    "    residents = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "    if int(i) in residents:\n",
    "        return 1 # живут в Москве\n",
    "    else:\n",
    "        return 0 # живут в области"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['r'] = df.apply(lambda row: make_index(row['i'], \n",
    "                                              row['j']), axis=1) # добавили столбец"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def amt_for_residents(df): # умножили значения москвичей на 1.62\n",
    "    for i in range(df.shape[0]):\n",
    "        df.loc[i, 'amt'] *= 1.62 if df.loc[i, 'r'] == 1 else 1\n",
    "    return df\n",
    "\n",
    "df = amt_for_residents(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cначала попробовать в качестве издержек время\n",
    "\n",
    "Считаем $L_i$, где $L_i$ -- это объем отправления из i. Причём $sum$ ($L_i$) = $sum$ ($W_j$), где $W_j$ -- это объём прибытия в район j.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2571.36 2571.3599999999997\n"
     ]
    }
   ],
   "source": [
    "L_i = df.groupby('i')['amt'].sum().reset_index()\n",
    "W_j = df.groupby('j')['amt'].sum().reset_index()\n",
    "\n",
    "total_i = L_i['amt'].sum()\n",
    "total_j = W_j['amt'].sum()\n",
    "\n",
    "print(total_i, total_j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   i     amt\n",
      "0  1  108.54\n",
      "1  2  197.64\n",
      "2  3  204.12\n",
      "3  4  158.76\n",
      "4  5  183.06\n"
     ]
    }
   ],
   "source": [
    "print(L_i.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   j     amt\n",
      "0  1  512.82\n",
      "1  2  208.58\n",
      "2  3  163.98\n",
      "3  4  153.64\n",
      "4  5  153.50\n"
     ]
    }
   ],
   "source": [
    "print(W_j.head())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Теперь надо решать систему и искать $d_{ij}$\n",
    "Метод последовательных итераций.\n",
    "##### Вопрос: куда девать $alpha$? \n",
    "Пока примем $alpha$ за единицу. Потом надо что-то решать.\n",
    "##### UPDATE: просто A_i и B_i надо всё время пересчитывать в gravity func, а не считать заранее!\n",
    "##### Вопрос: что такое $T_{ij}$?\n",
    "$T_{ij}$ -- это издержки. Издержки -- это время t.\n",
    "#### Проблема: i с j не всегда пересекаются. Не получается вернуть издержку. Возвращаю ноль\n",
    "Пока что возвращаю в таких случаях 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def costs_func(i, j, alpha):\n",
    "    rows = df.loc[df['i'] == i]\n",
    "    columns = rows.loc[df['j'] == j]\n",
    "    t = columns['t'] # потому что издержки -- это время\n",
    "    try:\n",
    "        t = int(t)\n",
    "        return np.exp(np.dot(-alpha, t))\n",
    "    except TypeError: # если не пересекается район i с районом j\n",
    "        return 0\n",
    "\n",
    "def iteration_method(L_i, W_j, alpha):\n",
    "    A_i = 1\n",
    "    B_j = 1\n",
    "    list_A_i = []\n",
    "    list_B_j = []\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    for i in range(1, n+1): # нумерация районов начинается с 1\n",
    "        for j in range(1, n+1):\n",
    "            value_i = L_i.loc[L_i['i'] == i]['amt']\n",
    "            value_j = W_j.loc[W_j['j'] == j]['amt']\n",
    "            value_i = int(value_i)\n",
    "            value_j = int(value_j)\n",
    "            denominator_i = B_j*value_i*costs_func(i, j, alpha)\n",
    "            denominator_j = A_i*value_j*costs_func(i, j, alpha)\n",
    "            if denominator_i!=0:\n",
    "                A_i += denominator_i \n",
    "                list_A_i.append(1 / A_i) # вызывает вопросы обращать тут или строкой выше\n",
    "            else:\n",
    "                list_A_i.append(0)\n",
    "            if denominator_j!=0:\n",
    "                B_j += denominator_j\n",
    "                list_B_j.append(1 / B_j)\n",
    "            else:\n",
    "                list_B_j.append(0)\n",
    "\n",
    "    return list_A_i, list_B_j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Пр мнмзрвать фнкцинл, Птчк"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gravity_func(alpha):\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    d_i_j = np.zeros((n+1, n+1))\n",
    "    list_A_i, list_B_j = iteration_method(L_i, W_j, alpha) # добавлено сюда, чтобы считать с нужным alpha\n",
    "    for i in range(1, n+1): # нумерация районов начинается с 1\n",
    "        for j in range(1, n+1):\n",
    "\n",
    "            value_i = L_i.loc[L_i['i'] == i]['amt']\n",
    "            value_j = W_j.loc[W_j['j'] == j]['amt']\n",
    "            value_i = int(value_i)\n",
    "            value_j = int(value_j)\n",
    "            cost = costs_func(i, j, alpha)\n",
    "            if cost!=0:\n",
    "                d_i_j[i][j] = (list_A_i[i]*list_B_j[j]*value_i*value_j)*cost #умножить потому что -alpha в функции\n",
    "            else:\n",
    "                d_i_j[i][j] = 0\n",
    "    return d_i_j\n",
    "\n",
    "def minimaze_func(real_d_i_j, alpha):\n",
    "    d_i_j = gravity_func(alpha) # добавлено сюда, чтобы считать с нужным alpha\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    s = 0\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            s += (real_d_i_j[i][j] - d_i_j[i][j])**2\n",
    "    return s\n",
    "\n",
    "def get_real_d_i_j(df): # чтобы натыкать нулей в местах, где нет пересечений\n",
    "    n = L_i.shape[0]\n",
    "    real_d = np.zeros((n+1, n+1))\n",
    "    for i in range(1, n+1):\n",
    "        for j in range(1, n+1):\n",
    "            value = df.loc[df['i'] == i]\n",
    "            value = value.loc[value['j'] == j]['amt']\n",
    "            try:\n",
    "                value = int(value)\n",
    "            except TypeError: # если не пересекается район i с районом j\n",
    "                value = 0\n",
    "            real_d[i][j] = value\n",
    "    return real_d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### графики ниже БЕЗ поправок Мерузы и исправленной минимизирующей функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "real_d_i_j = get_real_d_i_j(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:25: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:26: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:25: RuntimeWarning: invalid value encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:26: RuntimeWarning: invalid value encountered in double_scalars\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha:  0.0 min:  117039.99434314598\n",
      "alpha:  0.01 min:  117039.98077377593\n",
      "alpha:  0.02 min:  117039.93531075206\n",
      "alpha:  0.03 min:  117039.78566795413\n",
      "alpha:  0.04 min:  117039.30590902446\n",
      "alpha:  0.05 min:  117037.82454501034\n",
      "alpha:  0.06 min:  117033.47909015707\n",
      "alpha:  0.07 min:  117021.55541929668\n",
      "alpha:  0.08 min:  116991.42632242411\n",
      "alpha:  0.09 min:  116922.06240810403\n",
      "alpha:  0.1 min:  116777.2497791617\n",
      "alpha:  0.11 min:  116504.99827656975\n",
      "alpha:  0.12 min:  116049.8137719443\n",
      "alpha:  0.13 min:  115378.32212085077\n",
      "alpha:  0.14 min:  114493.6879479648\n",
      "alpha:  0.15 min:  113417.68731550305\n",
      "alpha:  0.16 min:  112168.29231512832\n",
      "alpha:  0.17 min:  110771.30035299927\n",
      "alpha:  0.18 min:  109291.88570136619\n",
      "alpha:  0.19 min:  107844.429498997\n",
      "alpha:  0.2 min:  106571.44326018143\n",
      "alpha:  0.21 min:  105611.24367881556\n",
      "alpha:  0.22 min:  105067.58958337724\n",
      "alpha:  0.23 min:  104987.059211989\n",
      "alpha:  0.24 min:  105352.11105358912\n",
      "alpha:  0.25 min:  106092.05085768277\n",
      "alpha:  0.26 min:  107104.29144089243\n",
      "alpha:  0.27 min:  108276.47366034899\n",
      "alpha:  0.28 min:  109504.1911008159\n",
      "alpha:  0.29 min:  110702.57692606529\n",
      "alpha:  0.3 min:  111811.59443642723\n",
      "alpha:  0.31 min:  112795.89499942987\n",
      "alpha:  0.32 min:  113640.95779556649\n",
      "alpha:  0.33 min:  114347.52546093627\n",
      "alpha:  0.34 min:  114926.00290653022\n",
      "alpha:  0.35000000000000003 min:  115391.80951567893\n",
      "alpha:  0.36 min:  115762.03311432373\n",
      "alpha:  0.37 min:  116053.31289711289\n",
      "alpha:  0.38 min:  116280.68701974004\n",
      "alpha:  0.39 min:  116457.1063423316\n",
      "alpha:  0.4 min:  116593.35990332608\n",
      "alpha:  0.41000000000000003 min:  116698.22560953413\n",
      "alpha:  0.42 min:  116778.72319929057\n",
      "alpha:  0.43 min:  116840.395602148\n",
      "alpha:  0.44 min:  116887.57858876638\n",
      "alpha:  0.45 min:  116923.63995404444\n",
      "alpha:  0.46 min:  116951.18197902493\n",
      "alpha:  0.47000000000000003 min:  116972.20763622617\n",
      "alpha:  0.48 min:  116988.2541881844\n",
      "alpha:  0.49 min:  117000.49898796577\n"
     ]
    }
   ],
   "source": [
    "alpha_list = []\n",
    "minimize_list =[]\n",
    "for alpha in np.arange(0, 0.5, 0.01):\n",
    "    value = minimaze_func(real_d_i_j, alpha)\n",
    "    print('alpha: ', alpha, 'min: ', value)\n",
    "    alpha_list.append(alpha)\n",
    "    minimize_list.append(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(alpha_list, minimize_list, 'ro')\n",
    "plt.title('зависимость минимизирующего функционала от alpha')\n",
    "plt.xlabel('alpha')\n",
    "plt.ylabel('минимизирующий функционал') # см. функцию  minimaze_func\n",
    "# xlim(0, 0.2)\n",
    "# ylim(5000, 10000)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# более приближенный график\n",
    "plt.plot(alpha_list, minimize_list, 'ro')\n",
    "xlim(0.2, 0.3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Поправки Мерузы\n",
    "\n",
    "1. Отнормировать минимизируемую функцию (minimize_func) по alpha = 0\n",
    "2. Издержки сделать бесконечностью\n",
    "\n",
    "##### Далее исправлен ТОЛЬКО первый пункт"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def minimaze_func(real_d_i_j, alpha):\n",
    "    d_i_j = gravity_func(alpha) # добавлено сюда, чтобы считать с нужным alpha\n",
    "    d_i_j_alpha_0 = gravity_func(alpha=0)\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    s = 0\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            numerator = (real_d_i_j[i][j] - d_i_j[i][j])**2 # числитель\n",
    "            denominator = (real_d_i_j[i][j] - d_i_j_alpha_0[i][j])**2 # знаменатель\n",
    "            if denominator != 0:\n",
    "                s += numerator / denominator\n",
    "            else:\n",
    "                s += 0\n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:23: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:24: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:23: RuntimeWarning: invalid value encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:24: RuntimeWarning: invalid value encountered in double_scalars\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha:  0.0 min:  206.0\n",
      "alpha:  0.01 min:  205.99999654840633\n",
      "alpha:  0.02 min:  205.99998492979805\n",
      "alpha:  0.03 min:  205.99994641480657\n",
      "alpha:  0.04 min:  205.9998214430437\n",
      "alpha:  0.05 min:  205.9994274354781\n",
      "alpha:  0.06 min:  205.99823090383643\n",
      "alpha:  0.07 min:  205.9947648117176\n",
      "alpha:  0.08 min:  205.98525706833684\n",
      "alpha:  0.09 min:  205.96048931933584\n",
      "alpha:  0.1 min:  205.89896320455495\n",
      "alpha:  0.11 min:  205.75583508489382\n",
      "alpha:  0.12 min:  205.45321114908745\n",
      "alpha:  0.13 min:  204.87670770963476\n",
      "alpha:  0.14 min:  203.89812681785008\n",
      "alpha:  0.15 min:  202.6004403876101\n",
      "alpha:  0.16 min:  201.98003385806064\n",
      "alpha:  0.17 min:  204.52314793646622\n",
      "alpha:  0.18 min:  212.8778009474332\n",
      "alpha:  0.19 min:  226.9205841547136\n",
      "alpha:  0.2 min:  242.74064151971064\n",
      "alpha:  0.21 min:  255.02599003459227\n",
      "alpha:  0.22 min:  260.2445949045739\n",
      "alpha:  0.23 min:  257.9608672008692\n",
      "alpha:  0.24 min:  250.13564155414616\n",
      "alpha:  0.25 min:  239.64595801979087\n",
      "alpha:  0.26 min:  229.05713501115443\n",
      "alpha:  0.27 min:  220.02160211303308\n",
      "alpha:  0.28 min:  213.22837212274183\n",
      "alpha:  0.29 min:  208.65853481191508\n",
      "alpha:  0.3 min:  205.91540581902223\n",
      "alpha:  0.31 min:  204.49008682229262\n",
      "alpha:  0.32 min:  203.9183053715532\n",
      "alpha:  0.33 min:  203.84377608284248\n",
      "alpha:  0.34 min:  204.02360738688972\n",
      "alpha:  0.35000000000000003 min:  204.30754917797324\n",
      "alpha:  0.36 min:  204.61113697446183\n",
      "alpha:  0.37 min:  204.89220471644688\n",
      "alpha:  0.38 min:  205.13359874600786\n",
      "alpha:  0.39 min:  205.3317468629941\n",
      "alpha:  0.4 min:  205.48968146359243\n",
      "alpha:  0.41000000000000003 min:  205.61307339413264\n",
      "alpha:  0.42 min:  205.70814362651615\n",
      "alpha:  0.43 min:  205.78067316390275\n",
      "alpha:  0.44 min:  205.8356172596263\n",
      "alpha:  0.45 min:  205.8770295705809\n",
      "alpha:  0.46 min:  205.90812977488235\n",
      "alpha:  0.47000000000000003 min:  205.9314254291248\n",
      "alpha:  0.48 min:  205.9488433191098\n",
      "alpha:  0.49 min:  205.96185006075916\n"
     ]
    }
   ],
   "source": [
    "real_d_i_j = get_real_d_i_j(df)\n",
    "\n",
    "alpha_list = []\n",
    "minimize_list =[]\n",
    "for alpha in np.arange(0, 0.5, 0.01):\n",
    "    value = minimaze_func(real_d_i_j, alpha)\n",
    "    alpha_list.append(alpha)\n",
    "    minimize_list.append(value)\n",
    "    print('alpha: ', alpha, 'min: ', value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY0AAAEWCAYAAACaBstRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvDW2N/gAAIABJREFUeJzt3XuYHFWd//H3J4BoJIJCRA2ZDGgQwRsYERf8rajPItco3tARBdYdxQugeFkI67q68YKCK94HUUFGARdURHQFRRQVMIEQCBEJmnAxSgCBaAAN+f7+OKdJpdOX6slUT8/M5/U8/XTXqdup6u76Vp1TdY4iAjMzszKmjHUGzMxs/HDQMDOz0hw0zMysNAcNMzMrzUHDzMxKc9AwM7PSHDTMzMYRSUdIumK0py3LQcNsEpHULykkbT7WebHxyUHDzMxK6/mgIennku6TdK+k8yVNy+lPlfRTSXdLukvSsKRtCvMtl/SApL9KukPSOwvjfibpLfnzFEnXS7q9MH6mpAskrcrL/1xO3+BST9L781nby/Lwh/LwKwvTvD2nFdd3kqQVku6UdJakrQvT7yPpV3l7b8vrfF3ejr9KeljSg7XhwnrPLrk/y+SxzHaeXRi/eR7fn4e/Lum/C+MvLp7d5v3/d0lPLExzXp7maSWXMSzpL/m3camkGTn9xXXf5WsbbNsvJX0uz/tbSS/N414jaWHd/nqPpO/V50nSLpIuz9/TDZIOKcxTn/crJB1RGF5e25d5+ChJS/P2/J+kWYVxIelvhe//Wzl96/zbWZV/SydJavh/lvR4ST+SdCdQ+x98OM97oaTH5elukHRwYb4tlP5bu6vBFYqksyV9qMl+Pznvn0c32ea3SPpZYbjdf/IZeZp7JS1ps7+fJikKw0fm/bta0u8lvbVu/9S2rfgfq+VlT0m/zutdmX83j2q0n/P0h+T83Zvz+4yc/rnC8ovf6Q+bLOffJd2S83yjCv/XBtOGpGPytt0l6ZP1vwVJn8q/rz9I2r/svmmk54MG6Ue+LTATeBxwRE4X8DHgKcAz8vgP1c17cERsBbwBOK3256jzZuDxtQFJmwEXASuAfmAGcE79TJKeABwD3Fs36rfAWwrDRwA31w0fAewL7ARsBdSC0izgh8BngenAc4FFEXFuRGyVt+UXwDsLwyPRLo+PaLGdpUjaF3h2g1G3kPY9krYDdu5wGR8FtgeeCNwBvKfBfFsAHwFW1o16QV7/dsB/Ahfk7bwQ2LH2R88OB86qW+6jgO8DF5O+p+OAb0p6erNtaLFtc4ETgUPzsn4BfKtusufUvu+IeH1O+yywNek39M/Am4Ajm6zmI8B9wCzgwZy2EugDHmb9/+Ys4I2F+Q4AVkbEtR1u0weAl5H+fw+2m76B+v/kFqT9/WPS9/0uYLiD/X0ncBDp+HEk8GlJexTG146DWxf+YzUPA+8m/VZeCLwUeHujlUjamfTdHUf6Li8Gvi/pURFR/5+tfaf7N1oW6ff5ItJ3/F/A2ZKe3GIbXwnMAfYA5gJHFca9ALgpb8PJwBmSlMe12zcb6fmgERGLI2ItKUisBa7P6csi4pKIeCgiVgGnkv48jWwO3A/8vZiYz4I+SPpT1exJCkTvi4i/RcSDEdGoIulE4KukP2PRQuBJknbIO//PwB8L4weAUyPi9xHxV+AE4LB8BvcG4NKI+FZE/CMi7o6IRa32zwi1y2NRs+1sK/8wTybt43pnkQ7IkA543+hkGRGxJCL+TvpdADQ6sL0VuAr4XV36ncD/5H18LukPdWBEPAScSz5wStqNdOJwUd38ewNTgZPzMi7N07yezr0N+FhELM2/848Cz1XhaqNePrE5DDghIlZHxHLgFNbvz3oHA5+PiAeAr+S0L+bhz5ACFsDZwAGFk6vDafK9tMjbW4D3Ai+PiPs7mTfP3+g/uRfp5OrjEfH3iPgpHezviPhBRNwSyeWk4POiwiSPAtZFxMMN5l0YEVdGxNq8n79M8+PM64Af5OPSP4BPAY8B/qlMPuvW++2I+GNErMu/0ZtJx6ZmPhER90TErcD/sOG+WRERp+ftOxN4MumEq8y+2UjPBw0ASYuBv5C+gN/ltO0lnaNU9HQ/6Qe/Xd2s383jfgx8tMFZz7HAj0gHjZqZpJ28tkV+ZgGvBT7ZZJKvkaL2W1j/J615CukqpmYFKahtn9d9S7P1tvHafEl8l6RLJO3UZvpWeQTabmdtffcCdzXLUx730wbjVgG/k/QiGpzNl1mGpIuA1cDupEBYHDcNeD/wHw2WeUds2FLnCtL3AulP9YYcrA4HzsvBpOa9wA+AW+uWsZx0VdqpWcBnCvvyHlIgbLWs7YAt2Ph31Gye7Un7u5E7gScBRMQfgV8Cr1Iq6t0fGK6b/q5CXl9bN246aX+vIV0lj0Sj/+RTgNsiYl0hrX5731vI1zXFBUraX9KVku7J4w9gw2PFE0jHl41I2lnSRZL+lI8lH2Xj40wxn498Jzm/tzGC34WkN0laVNimZ7ZYL3k9NcXfM8CfCnlakz9uldfTbt9sZFwEjYh4NjCNtGM+nZM/CgTwrIh4HOnsUHWzviKP6wOOlfTCwrgnkIq+/qtuntuAPrW+u+QjpLPM1U3Gn026atiXdIAp+iPpQFHTR7qC+nNe91NbrLeV8yJiG9KP5VbS/mmlVR5rWm3neRGxTV5nox9ZrWjoAy3y8BVSMcuyfLXY0TIi4iDgsTn/X68b/b6cxxX18wEzCpfnkL6DP+ZlXkm6In0Raf/Un2l/inQWN7NuGf2kYrJO3Qa8tbYv8+sxEfGrFvPcBfyDjX9Hzda/iuYHgieSfns1Z5L+S68Bfh0R9cvcrvC9n1c37mFSoBkEhnLg7kSz/+QfSfu7eLyq395PFfL1SPGKpC2B80nf2/Z5/MVseKzYmY2vRmu+SCrOnZ2PJSey8XGmmM9ifZRIJ4Id/S7yydrp5KL5nOcbWqyXvJ6aR37PbdZTZt9spKeDhqStJO2YBzcnHUQeyMPTgL8C9ylVgr6vxaJql53TC2nHAWdExJ/qpr2aVN77cUmPlfRoSXsXxj+NVEb45WYri4h7SWfypzS4YvkW8G5JO0rainRwPzdPNwy8TKnydnNJ20rq6IwtF9n8lTbfbZs8QontbONw4FcRsbjFND8mnRV+usn4hstQqijdLf8ppwBbsv53Aem3cSQwv8lynwgco1TR+xpSndjFhfFnkeqZ/tGkaPIKUvHU8XkZLyGVC29U91XCl4ATclFYrYL7Na1myMUM5wHzJU3LB5n3kE4EGrkYeLukx7C+LuvoPHwMqb6g5rukg+6xNL/6a+aeiLgxIv4P+AmpWLETzf6TV5GuXt6f9/eLSUVuZfb3o0i/j1XAWqVK4H+pjZQ0k7St320y/zRS0fZfJe0CHN1iXecBB0p6aa6HOR54CGh1AtDIY0knxKtyHo8kXWm08j6lGx5q23NuifW03DfN9HTQIFUCXShpNfAH0gb+ex73X6Qf932kM80LGsz/faU7jBbn8cUz6s1IEXYD+Q95MOmgeStwO6mssmZ74KRcZtlURJwcEY2Kfb5KOnv9ed6mB0kVe+TyyANIP7Z7gEXAc1qtp+CVkm6XdAdpv5zUboYWeYSS29nC42lcNFRc/7qIOKrFWXWzZWxGOiO+j3Tp/SxS3UDN44DTIqJhkQPpIDSbdMY+H3h1RNxdGP8N0p+04UE4T3sI6XdxN3AaMBARvy1Mdkz+Pm4Hng+cWhjegVzZHRHfAT4BnJOLP24gna238y7gb8DvSUHsm6TfViMnkU6YVpD+Q5CKpG4DHk1hH+d6jvOBHWn8nyrrPcBB+QBf863CPjgZeKGkUwvjm/0n/076T+5P+s6+ALypbn83lK+SjyEd0P9Cunq8sDDJ/wE/o/mJy3vzPKtJZ/9ND8YRcRPpKu2zOZ8Hk24G+HuzeZos50ZSHdWvSVeBzyIVG7byPVIR7SLSce6MEutpt28aUrgTJptElG59fUtE7NNimseQyvr3iIiGd5WNQj4ujYiXtZ9y1NfbTzpZ2aJZvZ2kDwI7R8QbG40fxby8GDgiIo6ocj0TndLtxbMjYlk31uenQs02djTwm6oCRnZN+0m6T+nW43+l+Z1Yo+kvwJIurMdGkYOGWYGk5aSKwFdUuZ6IeH+Vyx8JSf9Gul3zGxHx86rXFxHXAddVvR4bXS6eMjOz0nq9ItzMzHrIuC6e2m677aK/v3+ss2FmNq4sXLjwroiY3n7KjY3roNHf38+CBQvGOhtmZuOKpEYPvZbi4ikzMyvNQcPMzEpz0DAzs9IcNMzMrDQHDTMzK81Bw6ze8DD098OUKel9uL5LCbPJq7KgodTP9mVK/dsukXRsYdy7lPpmXiLp5EL6CZKWSbpJ0n5V5c2sqeFhGByEFSsgIr0PDjpwmGVVPqexFjg+Iq7JnbEslHQJqcntuaQ+ch+S9EQASbuSurDcjdSR0KWSdm7UBaNZZebNgzVrNkxbsyalDwyMTZ7MekhlVxoRsTIirsmfVwNLSd0eHk3q6/ehPO7OPMtc4JxIfX7/AVhG6z5xzUbfrbd2lm42yXSlTiO34b87qfObnYEXSbpK0uWSnp8nm8GG/dzeToO+dSUNSlogacGqVc26PTYbob6+ztLNJpnKg0bu0vR84LiIuJ9UJPYEYC9yP851fS23FBFDETEnIuZMnz6iplPMmps/H6ZO3TBt6tSUbmbVBo3cT+75wHBE1LqOvB24IJKrgXWkTu/vYMPO0Xegww7ZzTbZwAAMDcGsWSCl96Eh12eYZVXePSVSP7VLI6LYD/B3gX3zNDuTOje/i9Q37WGStpS0I6kP56uryp9ZUwMDsHw5rFuX3h0wzB5R5ZXG3qQuI18iaVF+HQB8FdhJ0g3AOcCb81XHElIH5zcCPwLe4TunrKf4+Q2z8d1z35w5c8JNo1tX1J7fKN6OO3Wqi65sXJK0MCLmjGRePxFuVkar5zfMJhEHDbMy/PyGGeCgYVaOn98wAxw0zMrx8xtmgIOGWTl+fsMMqLbBQrOJZWDAQcImPV9pmJlZaQ4aZmZWmoOGTV5+wtusY67TsMmp/gnvWg994HoLsxZ8pWGTk5/wNhsRBw2bnPyEt9mItC2eknRao/SIOGb0s2PWJX19qUiqUbqZNVXmSmMusLDBy2z88hPeZiNSpiL87og4s/KcmHVTrbJ73rxUJNXXlwKGK8HNWioTNHaRtAh4EPgj8Evg8xHxYKU5M6uan/A261iZoPEMYDPgMcBTgNcAXwHeWGG+zMysB7UNGhFRrC1cAlwi6RPVZcnMzHpV6Yf7JD0ReHQe/Hw12TEzs17W9u4pSYdIuhn4A3A5sBy4uOJ8mZlZDypzy+1HgL2A30XEjsBLgasqzZWZmfWkMkHjHxFxNzBF0pSIuAyYU3G+zMysB5Wp07hX0lbAz4FhSXcCf6s2W2Zm1ovKPhH+APBu4EfALcDBVWbKzMx6U5lbbotXFX4y3MxsEitz99RqSfdL+kd+Xy3p/hLzzZR0maQbJS2RdGxO/5CkOyQtyq8DCvOcIGmZpJsk7bdpm2bWJe7MySaRMlca0wAkXRsRu3ew7LXA8RFxjaRpwEJJl+Rxn46ITxUnlrQrcBiwG+nJ80sl7RwRD3ewTrPucmdONsl00p9GdLLgiFgZEdfkz6uBpcCMFrPMBc6JiIci4g/AMmDPTtZp1nXuzMkmmTLFU3tI2gN4jKTdC8OlSeoHdmf98x3vlLRY0lclPT6nzQBuK8x2Ow2CjKRBSQskLVi1alUn2TAbfe7MySaZMlcap+TXn4BT8+dPtZyjIN+uez5wXETcD3wReCrwXGBlXl5pETEUEXMiYs706dM7mdVs9DXrtMmdOdkEVaZOY9+RLlzSFqSAMRwRF+Tl/bkw/nTgojx4BzCzMPsOOc2sd82fv2GdBrgzJ5vQyhRPbS3p1FqRkKRTJG1dYj4BZwBLI+LUQvqTC5O9Erghf74QOEzSlpJ2BGYDV3eyMWZdNzAAQ0MwaxZI6X1oyJXgNmGVeSL8q6QD+2vz8OHA14BD28y3d572+tyJE8CJwOslPZdUsb4ceCtARCyRdB5wI+nOq3f4zikbF9yZk00iimh9U5SkRRHx3HZpY2HOnDmxYMGCsc6Gmdm4ImlhRIyoDcEyFeEPSNqnsLK9Sc2KmJnZJFOmeOpo4MxcjyHgHuCIKjNlZma9qczdU4uA50h6XB5u24SImZlNTG2DhqT31A0DULwjyszMJocyxVP/AawAvlNxXszMrMeVCRpPBU4gdfP64Yi4tNosmZlZr2p791RE3BMR7yO1QPsaST+S9Pzqs2ZmZr2mTJ3G91nfwq2APuBKYLMK82VmZj2oTPFU6cYJzcxsYitzy+3l9WmS9pP0JuCaiLihwWxmZjYBlSme+hobd8C0P/CBSnJkZmY9q0zx1EUN0l4QEWeNdmbMzKy3lSmeOr8+TdJx1WTHzMx6WSd9hBd11F+4mZlNDGXqNK5nwyAhoL+qDJmZWe8qU6dxUOW5MDOzcaFM8dTaiFhRfJHunjIbH4aHob8fpkxJ78PDY50js3GrTND4gaRdACQ9XdLlwJj32mdWyvAwDA7CihUQkd4HBx04zEaoTHevzwC+CfwM2Bc4JiJ+Xn3W2nN3r9ZWf38KFPVmzYLly7udG7OeUGl3rxGxFDgQeAnwsV4JGGal3HprZ+lm1lLboJHvnvoR8DjgbEmLJS2uPGdmo6Gvr7N0M2vJd0/ZxDZ/fqrDWLNmfdrUqSndzDpWpiI8mrzMet/AAAwNpToMKb0PDaV0M+tYmSuNH+T3nYBbSA/3BfDsqjJlNqoGBhwkzEZJmbanngUg6dqI2L36LJmZWa/qpO2pjoqkJM2UdJmkGyUtkXRs3fjjJYWk7fKwJJ0maVmubN+jk/WZmVn1ytw9daikQ4Ftap/zcDtrgeMjYldgL+AdknbNy5wJ/AtQvO9xf2B2fg0CX+xsU8x6kJ9GtwmmTJ3Gwfn98sLnAC5oNVNErARW5s+rJS0FZgA3Ap8G3g98rzDLXOCsSE8bXilpG0lPzssxG39qT6PX7tyqPY0OrmOxcatM0HhvRNy9KSuR1A/sDlwlaS5wR0RcJ6k42QzgtsLw7Tltg6AhaZB0JUKf77W3XjZv3oa3+kIanjfPQcPGrTJ1GldK+rakA1R3lC9D0lbA+cBxpCKrE4EPdrqcmogYiog5ETFn+vTpI12MWfX8NLpNQGWCxs7AEHA4cLOkj0rauczCJW1BChjDEXEB8FRgR+A6ScuBHYBrJD0JuAOYWZh9h5xmNj75aXSbgMq0PRURcUlEvB74N+DNwNWSLpf0wmbz5auSM4ClEXFqXtb1EfHEiOiPiH5SEdQeEfEn4ELgTfkuqr2A+1yfYePa/Pnp6fMiP41u41yZu6e2lXSspAXAe4F3AdsBx5Nav21mb9LVyUskLcqvA1pMfzHwe2AZcDrw9pLbYNab/DS6TUBlmkb/HfAN4GsRcXvduA9ExCcqzF9LbhrdzKxzm9I0epm7p54eESFpc0mbR8Ta2oixDBhmZtZ9ZSrC95T0G9LtsLdLWtiqLsPMzCauMlcaXwdeFxGLASQ9GzgP2KXCfJmZWQ8qc6VxM+kup5o7gJuqyY6ZmfWyplcauce+AB4L/FbSn/KoJwH31cZHhJtINzObJFoVTx1E6jvjw8C3gVoXr88BXgl8qNKcmZlZz2kaNCJiBUBuovyo2l1TklYCH6uNNzOzyaNMRfjZpGY/fp2H/wlw+85mZpNQmZ77Pi7pm8AepOKq/46I5VVnzMzMek+ZKw0i4lY27DDJzMwmoU66ezUzs0nOQcPMzEprWzwl6QmN0iPintHPjpmZ9bJWD/dNj4hVwF3An4EHSBXhkB7626n67JmZWS9pVTz1rfw+SGpG5BRgdkTsGBEOGGZmk1CroDENICK+AuwDbAn8UpJ7kDEzm6TaXmlIOhQ4EFgOfAn4gKTrqs+amZn1mlbNiPxP/nhw3aiF1WXHzMx6WZknwo/sRkbMzKz3lbnl9rRG6RFxzOhnx8zMelmZZkQOAu4HvgA8VG12zMysl5V5Inxn4HTg34AtgG9ExJmV5srMzHpS26AREWsj4vPAPwPTgV9JenXlOTMzs55Tpk6j1u0rpCfCtwbOBTarMF9mZtaDytZpmJmZlSqeWlH/AvaV9EFJ+zSbT9JMSZdJulHSEknH5vSPSFosaZGkH0t6Sk6XpNMkLcvj9xi1rTQzs1FRpnjqMtYXT0EqonouMJfWHTOtBY6PiGskTQMWSroE+GRE/Ede9jHAB4G3AfsDs/PrBcAX87uZmfWIMsVT760bFnB6RPy81UwRsRJYmT+vlrQUmBERNxYmeyzrA9Jc4KyICOBKSdtIenJejpmZ9YAyxVML614LgNWdrERSP7A7cFUeni/pNmCAdKUBMAO4rTDb7TmtflmDkhZIWrBq1apOsmHWO4aHob8fpkxJ78PDY50js1LKFE99sD4J6Cu7AklbAecDx0XE/QARMQ+YJ+kE4J3Af5ZdXkQMAUMAc+bMiTaTm/We4WEYHIQ1a9LwihVpGGDAjUhbbyvzcN/f6l5/BR4us3BJW5ACxnBEXNBgkmHgVfnzHcDMwrgdcprZxDJv3vqAUbNmTUo363FlGiw8pT5N0tx280kScAawNCJOLaTPjoib8+Bc4Lf584XAOyWdQ6oAv8/1GTYh3drk/pFm6WY9pEzx1KENkrctsey9gcOB6yUtymknAv8q6enAOmAF6c4pgIuBA4BlwBrArevaxNTXl4qkGqWb9bgyd0/V96cBcHW7mSLiCtb3KV50cZPpA3hHifyYjW/z529YpwEwdWpKN+tx7k/DrNtqld3z5qUiqb6+FDBcCW7jQNuKcElPlPQNScvz6+uSpncjc2aljbdbWAcGYPlyWLcuvTtg2DhR5u6prwG/AZ6dXwuBr1aZKbOO1G5hXbECItbfwtrrgcNsHCoTNHaIiNMi4v78+iwb3hprNrZ8C6tZ15QJGmslHVgbkHQAHT4RblYp38Jq1jVlgsbbgdMk3S3pTlJbVEdVmy2zDjS7VdW3sJqNujJtT10VEU8ltQv1pIh4SeHhPLOxN39+umW1yLewmlWizN1TqyXdDzwTuFfS/XnYrDcMDMDQEMyaBVJ6HxryHUlmFSjznMa0bmTEbJMMDDhImHVBmSuNUyTt2o3MmJlZbytTEb4UOF3SVZLeJmnrqjNlZma9qUxF+FciYm/gTUA/sFjSNyXtW3XmzMyst5S50kDSZsAu+XUXcB3wntyMuZmZTRJlmkb/NKml258AH42IWgu3n5B0U5WZMzOz3lKmafTFwEkR8bcG4/Yc5fyYmVkPKxM0vg68UtI+QABXRMR3ACLivgrzZmZmPaZMncbnSb3rXQ/cALxV0ucrzZWZmfWkMlcaLwGekXvWQ9KZwJJKc2VmZj2pzJXGMqDY8tvMnGZmZpNMmSuNacBSSVeT6jT2BBZIuhAgIg6pMH9mZtZDygSND1aeCzMzGxfKNFh4eTcyYmZmva/Mw32rScVSAMrvERGPqyxXZmbWk8pUhH+GdKvt6yNiWn45YJiZTUJlGiw8CZgL7CfpJ5L2rj5bZmbWi8r0p7EH6TbbrwNfAL4g6aIS882UdJmkGyUtkXRsTv+kpN9KWizpO5K2KcxzgqRlkm6StN+It8psvBoehv5+mDIlvQ8Pj3WOzDZQ5u6pU+qG7wEeW2K+tcDxEXGNpGnAQkmXAJcAJ0TEWkmfAE4APpA7ejoM2A14CnCppJ0j4uGyG2M2rg0Pw+AgrFmThlesSMPgXgmtZ5S5e2pE/WZExEpgZf68WtJSYEZE/Lgw2ZXAq/PnucA5EfEQ8AdJy0jPhPx6JOs3G3fmzVsfMGrWrEnpDhrWI8oUT+0taVjSCyV9Lhc5vbCTlUjqB3YHrqobdRTww/x5BnBbYdztOa1+WYOSFkhasGrVqk6yYdbbbr21s3SzMVDm7qnPAT8Dvg/8AjiN1IhhKZK2As4HjouI+wvp80hFWB0V2kbEUETMiYg506dP72RWs97W19dZutkYKBM01kXE6cDdEXFubhZd7WYCkLQFKWAMR8QFhfQjgIOAgVpDiMAdpAr3mh1ymtnkMH8+TJ26YdrUqSndrEeUCRq1iujXAkiaUmY+SQLOAJZGxKmF9JcD7wcOiYhiAe6FwGGStpS0IzAbuBqzyWJgAIaGYNYskNL70JDrM6ynaP2JfpMJpO0i4q7C8FbAbhFRXz9RP98+pOKs64F1OflEUvHWlsDdOe3KiHhbnmceqZ5jLak464e0MGfOnFiwYEHL/JuZ2YYkLYyIOSOZt8wtt+skPaEu7eZ2M0XEFTQuxrq4xTzzAV+Lm5n1qDJB4y7gz8ADFNqeAnaqKlNmZtabytRpDJJufz0FmB0RO0aEA4aZ2SRUpu2prwD7kOohfinJtXJmZpNUmbugDgUOBJYDXyI1+XFdxfkyM7MeVKZO4+C64YVVZMTMzHpfmbanjuxGRszMrPeV6bnvq43SI+Ko0c+OmZn1sjLFU/sBK4BvAHdWmx0zM+tlZYLGTODlwOHAZsDX2j2pbWZmE1OZW27XRcTFwEeANcA7K8+VmZn1pDJ1GoPAK4BlwGci4trKc2VmZj2pTPHUl0gBYybw4tR4LUTEsyvMl5mZ9aAyQWPHynNhZmbjQpmgsbryXJiZ2bhQpsHCu4AlwALS0+AL82cz65bhYejvhylT0vtwR70km40at3Jr48tkPHgOD8PgIKxYARHpfXBwcmy79Ry3cmvjx2Q9eM6bB2vWbJi2Zk1KN+uyMt29HloY3Bp4NxAR8ZwqM1aGu3udZPr7U6CoN2sWLF/e7dx0z5QpKUjWk2Dduo3TzdqourtXt3JrveHWWztLnyj6+hoHy76+7ufFJj23cmvjx2Q9eM6fn4rhikVUU6emdLMuK/NE+NdIfYJvwK3cWtdN1oPnQK5GnDcvXVX19aVtHnD1onVfmeKpi/L7ycD7K8yLWWuT+eA5MDA5ttN6XtuK8EcmlK6NiN0rzk9HXBFuZta5TakIL/OcRk256GJmZhNWmTqN60kB42mSFgMi3XLrBgvNzCaZMlcaB5Fuu31Gfq8xZXiHAAAK4ElEQVQNtyRppqTLJN0oaYmkY3P6a/LwOklz6uY5QdIySTdJ2q/zzTEzsypV2WDhWuD4iLhG0jRgoaRLgBuAQ4EvFyeWtCtwGLAb8BTgUkk7R8TDI1y/mZmNsjJB4y7gz8ADpKIpSMVVLdufioiVwMr8ebWkpcCMiLgEoNYvR8Fc4JyIeAj4g6RlwJ7Ar8ttipmZVa0rDRZK6gd2B65qMdkM4LbC8O05rX5Zg5IWSFqwatWqTrJhZmabqPIGCyVtBZwPHBcR948olxvmZygi5kTEnOnTp2/q4szGv8nY8q+NmbZBIzdYeCCwnNT16wckXVdm4ZK2IAWM4Yi4oM3kd5C6lK3ZIaeZWTOTteVfGzNliqcOLrz+H6nBwmvazaRUaXEGsDQiTi2xnguBwyRtKWlHYDZwdYn5zCYvN5tuXVZlg4V7A4cD10talNNOJBVzfRaYDvxA0qKI2C8ilkg6D7iRdOfVO3znlFkbk7XlXxszZR7u+2qj9HYNFkbEFay/26red5rMMx+Y4K3PmY2iydryr42ZMsVT+wG7AL8BflB4mdlYmz8/tfRbNBla/rUxUyZozAT+m1Sf8TpgTUScX2muzKycgQEYGkq9F0rpfWjILeJaZTpp5XZXUtPo0yPiwEpzVZJbuTUz61yl3b1KGgReASwDPhMR145kRWZmNv6VKZ76EvA0YF/gTEmLc2u341OrB6Gajas6vVvrMLPxo1f/4xHR8gXMavRqN183Xs973vOiI2efHTF1akR6DCq9pk5N6c3GHX10tendWPfZZ6/f/lmzIqT03i7dxjd/r+W02k+d/mdGM30k//GSgAUxwuPumB/4N+XVcdCYNWvDnV17zZrVfNxmm1Wb3o11136MIwlmPuiMT61OkCa6Tg7QvXoi2ekxYdasjnaRg0ZZUuMdLjUfV/WrG+uu/Uk6+RFuu+3kPehMBK1OkMaTTq8COj3Qb7tt8/00lieSnR4TpI52q4NGWZP5SmO0AlPtz+krkN7W6gSpF43WVUCzINDsv9HqIDyWJ5K+0uiRoNGrl6LdqNPo9EfY6tWNKxAHpk3T6gRpLPdtJ8FhJFcBo/Ua6xNJ12n0SNCI6M1Kr26tezQu20fpTKelyVweP1oqPuiUWv+mBodmr5FcBYykGHYsTySb7cNW6R1w0LByRqOCsNUfebTOYCdKefxYa/R9jPYVSJXBodmr1VVAsyAw0hs+xvJEskIOGlaNTg46o1lxPt7K48eTVmfonR5Uqw4OI7kKaJdfF3lGhIOGddNIyp875SuN6ozmXXSjVa/QLjh0ehVgbTloWHc1+rOO5tWB6zSq02mxY7PXSO7IG2lwsFHnoGFjb7SvDnwQqU4nxY7NXq1uC3Vw6HkOGjb22l0d+GDR20ZS7DiSegXrCQ4a1hs6rTD1gaS3dHInlE8GxrVNCRql+9PoRe5PY5zo72/cJemsWamHuXnzUp/WfX1p2B0I9ZbhYX9HE8ym9KfhoGHVmzIlnaM2MnUqrFmz4bB7njOr1KYEjTL9aZhtmr6+xumbbbZhwIA0PG9e9XkysxFx0LDqzZ+friCKpk6Fhx9uPP2tt1afJzMbEQcNq97AQCpymjULpPReG26k2ZWJmY25tn2Em42KgYHG9RSDgxvXacyf3718mVlHKrvSkDRT0mWSbpS0RNKxOf0Jki6RdHN+f3xOl6TTJC3L/ZDvUVXerEc0uwJxJbhZz6qyeGotcHxE7ArsBbxD0q7AvwM/iYjZwE/yMMD+wOz8GgS+WGHerFcMDMDy5bBuXXp3wDDraZUFjYhYGRHX5M+rgaXADGAucGae7EzgFfnzXOCs/OzJlcA2kp5cVf7MzKxzXakIl9QP7A5cBWwfESvzqD8B2+fPM4DbCrPdntPMzKxHVB40JG0FnA8cFxH3F8flx9k7erpQ0qCkBZIWrFq1ahRzamZm7VQaNCRtQQoYwxFxQU7+c63YKb/fmdPvAGYWZt8hp20gIoYiYk5EzJk+fXp1mTczs41UefeUgDOApRFxamHUhcCb8+c3A98rpL8p30W1F3BfoRjLzMx6QGVtT0naB/gFcD2wLiefSKrXOA/oA1YAr42Ie3KQ+RzwcmANcGREtGxYStKqvIyR2A64a4TzjneTddu93ZOLt7u5WRExoqKacd1g4aaQtGCkDXaNd5N1273dk4u3uxpuRsTMzEpz0DAzs9Imc9AYGusMjKHJuu3e7snF212BSVunYWZmnZvMVxpmZtYhBw0zMyttwgcNSS+XdFNucv3fG4zfUtK5efxVuZ2sca/Edv8/SddIWivp1WORxyqU2O735Ob6F0v6iaQmPUGNPyW2/W2Srpe0SNIVudXpca/ddheme5WkkDQhbsMt8X0fIWlV/r4XSXrLqKw4IibsC9gMuAXYCXgUcB2wa900bwe+lD8fBpw71vnu0nb3A88GzgJePdZ57uJ27wtMzZ+Pngjfdwfb/rjC50OAH411vrux3Xm6acDPgSuBOWOd7y5930cAnxvtdU/0K409gWUR8fuI+DtwDqkJ9qJiU+3/C7w0P50+nrXd7ohYHhGLWf+0/kRQZrsvi4haV4FXkto4mwjKbHuxwdDH0mFjoT2qzH8c4CPAJ4AHu5m5CpXd7lE30YNGmebWH5kmItYC9wHbdiV31Zmszcx3ut3/Cvyw0hx1T6ltl/QOSbcAJwPHdClvVWq73bkX0JkR8YNuZqxiZX/rr8pFsf8raWaD8R2b6EHDrCFJbwTmAJ8c67x0U0R8PiKeCnwAOGms81M1SVOAU4HjxzovY+D7QH9EPBu4hPUlKptkogeNMs2tPzKNpM2BrYG7u5K76pRqZn4CKrXdkl4GzAMOiYiHupS3qnX6nZ/D+l4zx7N22z0NeCbwM0nLSV1PXzgBKsPbft8RcXfh9/0V4HmjseKJHjR+A8yWtKOkR5Equi+sm6bYVPurgZ9GrkUax8ps90TUdrsl7Q58mRQw7mywjPGqzLbPLgweCNzcxfxVpeV2R8R9EbFdRPRHRD+pHuuQaNOC9jhQ5vsudpd9CKnL7U031ncBdOEugwOA35HuNJiX0z5M+uEAPBr4NrAMuBrYaazz3KXtfj6pHPRvpCurJWOd5y5t96XAn4FF+XXhWOe5i9v+GWBJ3u7LgN3GOs/d2O66aX/GBLh7quT3/bH8fV+Xv+9dRmO9bkbEzMxKm+jFU2ZmNoocNMzMrDQHDTMzK81Bw8zMSnPQMDOz0hw0zEZI0nJJ223qNGbjiYOGmZmV5qBhVoKk70paKGmJpMG6cf2SfitpWNLS3Djc1MIk78p9l1wvaZc8z56Sfi3pWkm/kvT0rm6Q2Qg5aJiVc1REPI/UyOExkupbQn468IWIeAZwP6mflpq7ImIP4IvAe3Pab4EXRcTuwAeBj1aae7NR4qBhVs4xkq4jtV00E5hdN/62iPhl/nw2sE9h3AX5fSGp8ytIDWN+W9INwKeB3arItNloc9Awa0PSi4GXAS+MiOcA15LaLCuqb4+nOFxrafRhYPP8+SPAZRHxTODgBssz60kOGmbtbQ38JSLW5DqJvRpM0yfphfnzG4ArSiyz1pT1EaOSS7MucNAwa+9HwOaSlgIfJxVR1bsJeEee5vGk+otWTgY+Jula1l99mPU8t3Jrtokk9QMX5aImswnNVxpmZlaarzTMzKw0X2mYmVlpDhpmZlaag4aZmZXmoGFmZqU5aJiZWWn/H6E9Yj9vBq5GAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(alpha_list, minimize_list, 'ro')\n",
    "plt.title('зависимость минимизирующего функционала от alpha')\n",
    "plt.xlabel('alpha')\n",
    "plt.ylabel('минимизирующий функционал') # см. функцию  minimaze_func\n",
    "# xlim(0, 0.2)\n",
    "# ylim(5000, 10000)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Первый и второй пункт сразу, нули исправлены на np.inf()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "def costs_func(i, j, alpha):\n",
    "    rows = df.loc[df['i'] == i]\n",
    "    columns = rows.loc[df['j'] == j]\n",
    "    t = columns['t'] # потому что издержки -- это время\n",
    "    try:\n",
    "        t = int(t)\n",
    "        return np.exp(np.dot(-alpha, t))\n",
    "    except TypeError: # если не пересекается район i с районом j\n",
    "        return np.inf # возвращаем бесконечность\n",
    "\n",
    "def iteration_method(L_i, W_j, alpha):\n",
    "    A_i = 1\n",
    "    B_j = 1\n",
    "    list_A_i = []\n",
    "    list_B_j = []\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    for i in range(1, n+1): # нумерация районов начинается с 1\n",
    "        for j in range(1, n+1):\n",
    "            value_i = L_i.loc[L_i['i'] == i]['amt']\n",
    "            value_j = W_j.loc[W_j['j'] == j]['amt']\n",
    "            value_i = int(value_i)\n",
    "            value_j = int(value_j)\n",
    "            denominator_i = B_j*value_i*costs_func(i, j, alpha)\n",
    "            denominator_j = A_i*value_j*costs_func(i, j, alpha)\n",
    "            \n",
    "            if np.isinf(denominator_i): # если не пересекаются районы, т.е. бесконечность\n",
    "                list_A_i.append(np.inf) # добавляем бесконечность\n",
    "            else:\n",
    "                A_i += denominator_i \n",
    "                list_A_i.append(1 / A_i)\n",
    "            if np.isinf(denominator_j):\n",
    "                list_B_j.append(np.inf)\n",
    "            else:\n",
    "                B_j += denominator_j\n",
    "                list_B_j.append(1 / B_j)\n",
    "    return list_A_i, list_B_j\n",
    "\n",
    "def gravity_func(alpha):\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    d_i_j = np.zeros((n+1, n+1))\n",
    "    list_A_i, list_B_j = iteration_method(L_i, W_j, alpha) # добавлено сюда, чтобы считать с нужным alpha\n",
    "    for i in range(1, n+1): # нумерация районов начинается с 1\n",
    "        for j in range(1, n+1):\n",
    "\n",
    "            value_i = L_i.loc[L_i['i'] == i]['amt']\n",
    "            value_j = W_j.loc[W_j['j'] == j]['amt']\n",
    "            value_i = int(value_i)\n",
    "            value_j = int(value_j)\n",
    "            cost = costs_func(i, j, alpha)\n",
    "            if np.isinf(cost):\n",
    "                d_i_j[i][j] = np.inf\n",
    "            else:\n",
    "                d_i_j[i][j] = (list_A_i[i]*list_B_j[j]*value_i*value_j)*cost #умножить потому что -alpha в функции\n",
    "    return d_i_j\n",
    "\n",
    "def minimaze_func(real_d_i_j, alpha):\n",
    "    d_i_j = gravity_func(alpha) # добавлено сюда, чтобы считать с нужным alpha\n",
    "    d_i_j_alpha_0 = gravity_func(alpha=0)\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    s = 0\n",
    "    list_s = []\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            numerator = (real_d_i_j[i][j] - d_i_j[i][j])**2 # числитель\n",
    "            denominator = (real_d_i_j[i][j] - d_i_j_alpha_0[i][j])**2 # знаменатель\n",
    "            if np.isinf(denominator):\n",
    "                s += np.inf\n",
    "                list_s.append(np.inf)\n",
    "            else:\n",
    "                if denominator != 0:\n",
    "                    s += numerator / denominator\n",
    "                    list_s.append(numerator / denominator)\n",
    "                else:\n",
    "                    s += 0\n",
    "                    list_s.append(0)\n",
    "    return s, list_s\n",
    "\n",
    "def get_real_d_i_j(df): # чтобы натыкать нулей в местах, где нет пересечений\n",
    "    n = L_i.shape[0]\n",
    "    real_d = np.zeros((n+1, n+1))\n",
    "    for i in range(1, n+1):\n",
    "        for j in range(1, n+1):\n",
    "            value = df.loc[df['i'] == i]\n",
    "            value = value.loc[value['j'] == j]['amt']\n",
    "            try:\n",
    "                value = int(value)\n",
    "            except TypeError: # если не пересекается район i с районом j\n",
    "                value = np.inf\n",
    "            real_d[i][j] = value\n",
    "    return real_d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:23: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:24: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:34: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:64: RuntimeWarning: invalid value encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:65: RuntimeWarning: invalid value encountered in double_scalars\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha:  0.0 min:  nan\n",
      "alpha:  0.1 min:  nan\n",
      "alpha:  0.2 min:  nan\n"
     ]
    }
   ],
   "source": [
    "real_d_i_j = get_real_d_i_j(df)\n",
    "list_s = []\n",
    "alpha_list = []\n",
    "minimize_list =[]\n",
    "\n",
    "for alpha in np.arange(0, 0.3, 0.1):\n",
    "    value, list_s = minimaze_func(real_d_i_j, alpha)\n",
    "    alpha_list.append(alpha)\n",
    "    minimize_list.append(value)\n",
    "    print('alpha: ', alpha, 'min: ', value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(list_s, 'ro')\n",
    "plt.title('просто s в каждой точке цикла по районам, чтобы посмотреть как оно изменяется')\n",
    "# xlim(0, 0.2)\n",
    "# ylim(0, 1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Первый и второй пункт сразу, нули исправлены не на np.inf, а на самую большую издержку В КВАДРАТЕ, что есть у нас в таблице"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "57600.0\n"
     ]
    }
   ],
   "source": [
    "max_t = df.loc[df['t'].idxmax()]\n",
    "max_t = max_t['t']\n",
    "max_t = max_t**2\n",
    "print(max_t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def costs_func(i, j, alpha):\n",
    "    rows = df.loc[df['i'] == i]\n",
    "    columns = rows.loc[df['j'] == j]\n",
    "    t = columns['t'] # потому что издержки -- это время\n",
    "    try:\n",
    "        t = int(t)\n",
    "        return np.exp(np.dot(-alpha, t))\n",
    "    except TypeError: # если не пересекается район i с районом j\n",
    "        return max_t\n",
    "\n",
    "def iteration_method(L_i, W_j, alpha):\n",
    "    A_i = 1\n",
    "    B_j = 1\n",
    "    list_A_i = []\n",
    "    list_B_j = []\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    for i in range(1, n+1): # нумерация районов начинается с 1\n",
    "        for j in range(1, n+1):\n",
    "            value_i = L_i.loc[L_i['i'] == i]['amt']\n",
    "            value_j = W_j.loc[W_j['j'] == j]['amt']\n",
    "            value_i = int(value_i)\n",
    "            value_j = int(value_j)\n",
    "            denominator_i = B_j*value_i*costs_func(i, j, alpha)\n",
    "            denominator_j = A_i*value_j*costs_func(i, j, alpha)\n",
    "            if denominator_i!=0:\n",
    "                A_i += denominator_i \n",
    "                list_A_i.append(1 / A_i) # вызывает вопросы обращать тут или строкой выше\n",
    "            else:\n",
    "                list_A_i.append(0)\n",
    "            if denominator_j!=0:\n",
    "                B_j += denominator_j\n",
    "                list_B_j.append(1 / B_j)\n",
    "            else:\n",
    "                list_B_j.append(0)\n",
    "\n",
    "    return list_A_i, list_B_j\n",
    "\n",
    "def gravity_func(alpha):\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    d_i_j = np.zeros((n+1, n+1))\n",
    "    list_A_i, list_B_j = iteration_method(L_i, W_j, alpha) # добавлено сюда, чтобы считать с нужным alpha\n",
    "    for i in range(1, n+1): # нумерация районов начинается с 1\n",
    "        for j in range(1, n+1):\n",
    "\n",
    "            value_i = L_i.loc[L_i['i'] == i]['amt']\n",
    "            value_j = W_j.loc[W_j['j'] == j]['amt']\n",
    "            value_i = int(value_i)\n",
    "            value_j = int(value_j)\n",
    "            cost = costs_func(i, j, alpha)\n",
    "            if cost!=0:\n",
    "                d_i_j[i][j] = (list_A_i[i]*list_B_j[j]*value_i*value_j)*cost #умножить потому что -alpha в функции\n",
    "            else:\n",
    "                d_i_j[i][j] = 0\n",
    "    return d_i_j\n",
    "\n",
    "def minimaze_func(real_d_i_j, alpha):\n",
    "    d_i_j = gravity_func(alpha) # добавлено сюда, чтобы считать с нужным alpha\n",
    "    d_i_j_alpha_0 = gravity_func(alpha=0)\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    s = 0\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            numerator = (real_d_i_j[i][j] - d_i_j[i][j])**2 # числитель\n",
    "            denominator = (real_d_i_j[i][j] - d_i_j_alpha_0[i][j])**2 # знаменатель\n",
    "            if denominator != 0:\n",
    "                s += numerator / denominator\n",
    "#                 print(s, numerator, denominator)\n",
    "            else:\n",
    "                s += 0\n",
    "    return s\n",
    "\n",
    "def get_real_d_i_j(df): # чтобы натыкать нулей в местах, где нет пересечений\n",
    "    n = L_i.shape[0]\n",
    "    real_d = np.zeros((n+1, n+1))\n",
    "    for i in range(1, n+1):\n",
    "        for j in range(1, n+1):\n",
    "            value = df.loc[df['i'] == i]\n",
    "            value = value.loc[value['j'] == j]['amt']\n",
    "            try:\n",
    "                value = int(value)\n",
    "            except TypeError: # если не пересекается район i с районом j\n",
    "                value = 0\n",
    "            real_d[i][j] = value\n",
    "    return real_d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:23: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:24: RuntimeWarning: overflow encountered in double_scalars\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha:  0.0 min:  427.0\n",
      "alpha:  0.1 min:  1.690594294297507e+67\n",
      "alpha:  0.2 min:  1.3760978424480482e+84\n",
      "alpha:  0.30000000000000004 min:  1.486257161203373e+87\n",
      "alpha:  0.4 min:  3.8379807148007863e+87\n",
      "alpha:  0.5 min:  4.121130360725836e+87\n",
      "alpha:  0.6000000000000001 min:  4.141211336945963e+87\n",
      "alpha:  0.7000000000000001 min:  4.142610232989188e+87\n",
      "alpha:  0.8 min:  4.142709355067351e+87\n",
      "alpha:  0.9 min:  4.14271647986346e+87\n",
      "alpha:  1.0 min:  4.142716997274834e+87\n",
      "alpha:  1.1 min:  4.142717035120176e+87\n",
      "alpha:  1.2000000000000002 min:  4.1427170379020214e+87\n",
      "alpha:  1.3 min:  4.14271703810719e+87\n",
      "alpha:  1.4000000000000001 min:  4.1427170381223535e+87\n",
      "alpha:  1.5 min:  4.142717038123482e+87\n",
      "alpha:  1.6 min:  4.142717038123561e+87\n",
      "alpha:  1.7000000000000002 min:  4.142717038123565e+87\n",
      "alpha:  1.8 min:  4.142717038123565e+87\n",
      "alpha:  1.9000000000000001 min:  4.142717038123565e+87\n",
      "alpha:  2.0 min:  4.142717038123565e+87\n"
     ]
    }
   ],
   "source": [
    "real_d_i_j = get_real_d_i_j(df)\n",
    "list_s = []\n",
    "alpha_list = []\n",
    "minimize_list = []\n",
    "\n",
    "for alpha in np.arange(0, 2.1, 0.1):\n",
    "    value = minimaze_func(real_d_i_j, alpha)\n",
    "    alpha_list.append(alpha)\n",
    "    minimize_list.append(value)\n",
    "    print('alpha: ', alpha, 'min: ', value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(alpha_list, minimize_list, 'ro')\n",
    "plt.title('зависимость минимизирующего функционала от alpha')\n",
    "plt.xlabel('alpha')\n",
    "plt.ylabel('минимизирующий функционал') # см. функцию  minimaze_func\n",
    "# xlim(0, 0.25)\n",
    "# ylim(5000, 10000)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:23: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:24: RuntimeWarning: overflow encountered in double_scalars\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha:  0.0 min:  427.0\n",
      "alpha:  0.01 min:  3019291376.023451\n",
      "alpha:  0.02 min:  8.383387009019386e+16\n",
      "alpha:  0.03 min:  2.431910324110451e+24\n",
      "alpha:  0.04 min:  6.140990828256307e+31\n",
      "alpha:  0.05 min:  1.0389119980620333e+39\n",
      "alpha:  0.06 min:  7.628650401072488e+45\n",
      "alpha:  0.07 min:  1.5696411567514395e+52\n",
      "alpha:  0.08 min:  7.537098341164558e+57\n",
      "alpha:  0.09 min:  8.024966815625137e+62\n",
      "alpha:  0.1 min:  1.690594294297507e+67\n",
      "alpha:  0.11 min:  6.617364702434282e+70\n",
      "alpha:  0.12 min:  5.304840499025599e+73\n",
      "alpha:  0.13 min:  1.0845783213455936e+76\n",
      "alpha:  0.14 min:  7.41535639542682e+77\n",
      "alpha:  0.15 min:  2.24620465222087e+79\n",
      "alpha:  0.16 min:  3.875016218156094e+80\n",
      "alpha:  0.17 min:  4.5479973806530315e+81\n",
      "alpha:  0.18 min:  3.982391355269703e+82\n",
      "alpha:  0.19 min:  2.673753898157704e+83\n",
      "alpha:  0.2 min:  1.3760978424480482e+84\n",
      "alpha:  0.21 min:  5.46084941038352e+84\n",
      "alpha:  0.22 min:  1.7136360436037515e+85\n",
      "alpha:  0.23 min:  4.420275528673924e+85\n",
      "alpha:  0.24 min:  9.75370892021507e+85\n",
      "alpha:  0.25 min:  1.9015220113646485e+86\n",
      "alpha:  0.26 min:  3.349402842478372e+86\n",
      "alpha:  0.27 min:  5.408848553341459e+86\n",
      "alpha:  0.28 min:  8.089682035550576e+86\n",
      "alpha:  0.29 min:  1.1300533651371324e+87\n",
      "alpha:  0.3 min:  1.4862571612033717e+87\n",
      "alpha:  0.31 min:  1.8552629848759025e+87\n",
      "alpha:  0.32 min:  2.2154535390872067e+87\n",
      "alpha:  0.33 min:  2.5497763658146995e+87\n",
      "alpha:  0.34 min:  2.8474245415517795e+87\n",
      "alpha:  0.35000000000000003 min:  3.1036016911410983e+87\n",
      "alpha:  0.36 min:  3.318196322851162e+87\n",
      "alpha:  0.37 min:  3.494154339158009e+87\n",
      "alpha:  0.38 min:  3.636039750540417e+87\n",
      "alpha:  0.39 min:  3.7489771842306798e+87\n",
      "alpha:  0.4 min:  3.8379807148007863e+87\n",
      "alpha:  0.41000000000000003 min:  3.907589811579339e+87\n",
      "alpha:  0.42 min:  3.9617163069283494e+87\n",
      "alpha:  0.43 min:  4.003620320202855e+87\n",
      "alpha:  0.44 min:  4.035955754626845e+87\n",
      "alpha:  0.45 min:  4.060846877915814e+87\n",
      "alpha:  0.46 min:  4.0799732582823585e+87\n",
      "alpha:  0.47000000000000003 min:  4.094650932990972e+87\n",
      "alpha:  0.48 min:  4.105904253886485e+87\n",
      "alpha:  0.49 min:  4.114526627800503e+87\n",
      "alpha:  0.5 min:  4.121130360725836e+87\n",
      "alpha:  0.51 min:  4.1261867388070245e+87\n",
      "alpha:  0.52 min:  4.130057802863392e+87\n",
      "alpha:  0.53 min:  4.1330212827003e+87\n",
      "alpha:  0.54 min:  4.135290020053543e+87\n",
      "alpha:  0.55 min:  4.137027017346552e+87\n",
      "alpha:  0.56 min:  4.138357051711506e+87\n",
      "alpha:  0.5700000000000001 min:  4.139375612605126e+87\n",
      "alpha:  0.58 min:  4.140155765514996e+87\n",
      "alpha:  0.59 min:  4.140753415130288e+87\n",
      "alpha:  0.6 min:  4.141211336945963e+87\n",
      "alpha:  0.61 min:  4.141562263238172e+87\n",
      "alpha:  0.62 min:  4.1418312440763825e+87\n",
      "alpha:  0.63 min:  4.142037453148426e+87\n",
      "alpha:  0.64 min:  4.142195568733351e+87\n",
      "alpha:  0.65 min:  4.142316829721058e+87\n",
      "alpha:  0.66 min:  4.1424098431628995e+87\n",
      "alpha:  0.67 min:  4.1424812018664365e+87\n",
      "alpha:  0.68 min:  4.142535956775605e+87\n",
      "alpha:  0.6900000000000001 min:  4.142577978336788e+87\n",
      "alpha:  0.7000000000000001 min:  4.142610232989188e+87\n",
      "alpha:  0.71 min:  4.142634994755416e+87\n",
      "alpha:  0.72 min:  4.142654007198537e+87\n",
      "alpha:  0.73 min:  4.142668607414338e+87\n",
      "alpha:  0.74 min:  4.142679820978011e+87\n",
      "alpha:  0.75 min:  4.142688434664835e+87\n",
      "alpha:  0.76 min:  4.142695052159405e+87\n",
      "alpha:  0.77 min:  4.1427001367416606e+87\n",
      "alpha:  0.78 min:  4.142704044001095e+87\n",
      "alpha:  0.79 min:  4.142707046913557e+87\n",
      "alpha:  0.8 min:  4.142709355067351e+87\n",
      "alpha:  0.81 min:  4.142711129406884e+87\n",
      "alpha:  0.8200000000000001 min:  4.142712493540486e+87\n",
      "alpha:  0.8300000000000001 min:  4.142713542415252e+87\n",
      "alpha:  0.84 min:  4.142714348972708e+87\n",
      "alpha:  0.85 min:  4.142714969256392e+87\n",
      "alpha:  0.86 min:  4.1427154463320656e+87\n",
      "alpha:  0.87 min:  4.1427158132970045e+87\n",
      "alpha:  0.88 min:  4.142716095590488e+87\n",
      "alpha:  0.89 min:  4.142716312767926e+87\n",
      "alpha:  0.9 min:  4.14271647986346e+87\n",
      "alpha:  0.91 min:  4.1427166084364975e+87\n",
      "alpha:  0.92 min:  4.142716707375772e+87\n",
      "alpha:  0.93 min:  4.1427167835170085e+87\n",
      "alpha:  0.9400000000000001 min:  4.1427168421176805e+87\n",
      "alpha:  0.9500000000000001 min:  4.142716887221707e+87\n",
      "alpha:  0.96 min:  4.142716921939918e+87\n",
      "alpha:  0.97 min:  4.142716948665496e+87\n",
      "alpha:  0.98 min:  4.142716969239754e+87\n",
      "alpha:  0.99 min:  4.14271698507946e+87\n"
     ]
    }
   ],
   "source": [
    "real_d_i_j = get_real_d_i_j(df)\n",
    "list_s = []\n",
    "alpha_list = []\n",
    "minimize_list = []\n",
    "\n",
    "for alpha in np.arange(0, 1.0, 0.01):\n",
    "    value = minimaze_func(real_d_i_j, alpha)\n",
    "    alpha_list.append(alpha)\n",
    "    minimize_list.append(value)\n",
    "    print('alpha: ', alpha, 'min: ', value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(alpha_list, minimize_list, 'ro')\n",
    "plt.title('зависимость минимизирующего функционала от alpha')\n",
    "plt.xlabel('alpha')\n",
    "plt.ylabel('минимизирующий функционал') # см. функцию  minimaze_func\n",
    "# xlim(0, 0.25)\n",
    "# ylim(5000, 10000)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Замечания на консультации\n",
    "1. Убрать нормализацию\n",
    "2. Добавить beta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "57600.0\n"
     ]
    }
   ],
   "source": [
    "max_t = df.loc[df['t'].idxmax()]\n",
    "max_t = max_t['t']\n",
    "max_t = max_t**2\n",
    "print(max_t)\n",
    "\n",
    "def costs_func(i, j, alpha):\n",
    "    rows = df.loc[df['i'] == i]\n",
    "    columns = rows.loc[df['j'] == j]\n",
    "    t = columns['t'] # потому что издержки -- это время\n",
    "    try:\n",
    "        t = int(t)\n",
    "        return np.exp(np.dot(-alpha, t))\n",
    "    except TypeError: # если не пересекается район i с районом j\n",
    "        return max_t\n",
    "\n",
    "def iteration_method(L_i, W_j, alpha):\n",
    "    A_i = 1\n",
    "    B_j = 1\n",
    "    list_A_i = []\n",
    "    list_B_j = []\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    for i in range(1, n+1): # нумерация районов начинается с 1\n",
    "        for j in range(1, n+1):\n",
    "            value_i = L_i.loc[L_i['i'] == i]['amt']\n",
    "            value_j = W_j.loc[W_j['j'] == j]['amt']\n",
    "            value_i = int(value_i)\n",
    "            value_j = int(value_j)\n",
    "            denominator_i = B_j*value_i*costs_func(i, j, alpha)\n",
    "            denominator_j = A_i*value_j*costs_func(i, j, alpha)\n",
    "            if denominator_i!=0:\n",
    "                A_i += denominator_i \n",
    "                list_A_i.append(1 / A_i) # вызывает вопросы обращать тут или строкой выше\n",
    "            else:\n",
    "                list_A_i.append(0)\n",
    "            if denominator_j!=0:\n",
    "                B_j += denominator_j\n",
    "                list_B_j.append(1 / B_j)\n",
    "            else:\n",
    "                list_B_j.append(0)\n",
    "\n",
    "    return list_A_i, list_B_j\n",
    "\n",
    "def gravity_func(alpha):\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    d_i_j = np.zeros((n+1, n+1))\n",
    "    list_A_i, list_B_j = iteration_method(L_i, W_j, alpha) # добавлено сюда, чтобы считать с нужным alpha\n",
    "    for i in range(1, n+1): # нумерация районов начинается с 1\n",
    "        for j in range(1, n+1):\n",
    "\n",
    "            value_i = L_i.loc[L_i['i'] == i]['amt']\n",
    "            value_j = W_j.loc[W_j['j'] == j]['amt']\n",
    "            value_i = int(value_i)\n",
    "            value_j = int(value_j)\n",
    "            cost = costs_func(i, j, alpha)\n",
    "            if cost!=0:\n",
    "                d_i_j[i][j] = (list_A_i[i]*list_B_j[j]*value_i*value_j)*cost #умножить потому что -alpha в функции\n",
    "            else:\n",
    "                d_i_j[i][j] = 0\n",
    "    return d_i_j\n",
    "\n",
    "def minimaze_func(real_d_i_j, alpha, beta):\n",
    "    d_i_j = gravity_func(alpha) # добавлено сюда, чтобы считать с нужным alpha\n",
    "    n = L_i.shape[0] # количество районов\n",
    "    s = 0\n",
    "    for i in range(n):\n",
    "        for j in range(n):\n",
    "            s += (real_d_i_j[i][j] - d_i_j[i][j]**beta)**2\n",
    "    return s\n",
    "\n",
    "def get_real_d_i_j(df): # чтобы натыкать нулей в местах, где нет пересечений\n",
    "    n = L_i.shape[0]\n",
    "    real_d = np.zeros((n+1, n+1))\n",
    "    for i in range(1, n+1):\n",
    "        for j in range(1, n+1):\n",
    "            value = df.loc[df['i'] == i]\n",
    "            value = value.loc[value['j'] == j]['amt']\n",
    "            try:\n",
    "                value = int(value)\n",
    "            except TypeError: # если не пересекается район i с районом j\n",
    "                value = 0\n",
    "            real_d[i][j] = value\n",
    "    return real_d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:28: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:29: RuntimeWarning: overflow encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:28: RuntimeWarning: invalid value encountered in double_scalars\n",
      "/usr/local/Cellar/ipython/7.1.1/libexec/vendor/lib/python3.7/site-packages/ipykernel_launcher.py:29: RuntimeWarning: invalid value encountered in double_scalars\n"
     ]
    }
   ],
   "source": [
    "real_d_i_j = get_real_d_i_j(df)\n",
    "list_s = []\n",
    "alpha_list = []\n",
    "beta_list = []\n",
    "\n",
    "# n = 9\n",
    "# i = 0\n",
    "# print(np.shape(minimize_list))\n",
    "\n",
    "# for alpha in np.arange(0, 0.3, 0.1):\n",
    "#     for beta in np.arange(0, 0.3, 0.1):\n",
    "#         value = minimaze_func(real_d_i_j, alpha, beta)\n",
    "#         alpha_list.append(alpha)\n",
    "#         beta_list.append(beta)\n",
    "#         minimize_list[i] = value\n",
    "#         print('alpha: ', alpha, 'min: ', value)\n",
    "#         i += 0\n",
    "        \n",
    "alpha = 0\n",
    "beta = 0\n",
    "minimize_list = np.zeros((3, 3))\n",
    "for i in range(0, 3):\n",
    "    for j in range(0, 3):\n",
    "        \n",
    "        beta += 3*0.1\n",
    "        alpha += 4*0.1\n",
    "        value = minimaze_func(real_d_i_j, alpha, beta)\n",
    "        minimize_list[i][j] = value\n",
    "        alpha_list.append(alpha)\n",
    "        beta_list.append(beta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d') # get current axis\n",
    "\n",
    "alpha = np.arange(0, 0.3, 0.1)\n",
    "beta = np.arange(0, 0.3, 0.1)\n",
    "alpha, beta = np.meshgrid(alpha, beta)\n",
    "Z = minimize_list\n",
    "\n",
    "surf = ax.plot_surface(alpha, beta, Z)\n",
    "ax.set_xlabel('X')\n",
    "ax.set_ylabel('Y')\n",
    "ax.set_zlabel('Z')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}