Long Chain Simulation Extra Edge Test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e02b3392",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-08-14T20:55:30.577634Z",
     "start_time": "2021-08-14T20:55:27.728246Z"
    },
    "hideCode": false,
    "hidePrompt": false,
    "hide_input": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# import statements for all used packages\n",
    "import matplotlib\n",
    "from IPython.display import display\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib.ticker import FormatStrFormatter\n",
    "plt.rcParams['figure.figsize'] = [18, 20]\n",
    "from pprint import pprint\n",
    "from scipy.optimize import minimize, Bounds, LinearConstraint, fsolve\n",
    "import numpy as np\n",
    "import copy\n",
    "import matplotlib.gridspec as gridspec\n",
    "import seaborn as sns; sns.set()\n",
    "import pandas as pd\n",
    "import time as time_lib\n",
    "import os\n",
    "from gurobipy import GRB, Model, quicksum"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b04f416",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "# Helper Classes and Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b3a8eb7d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-08-14T20:55:30.608814Z",
     "start_time": "2021-08-14T20:55:30.580592Z"
    },
    "hideCode": false,
    "hideOutput": false,
    "hidePrompt": false,
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "# chooses optimal random probabilities to optimize costs\n",
    "def randFunc(alpha):\n",
    "    if extra_edge:\n",
    "        alpha = list(alpha)\n",
    "#         alpha.append(alpha[0])\n",
    "    else:\n",
    "        alpha = [1] + list(alpha)\n",
    "    grad = [-c[j]*lamb[j]*mu[2*j]/(alpha[j]*(mu[2*j])+(1-alpha[j+1])*mu[2*(j+1)-1]-lamb[j])**2 + -c[j-1]*lamb[j-1]*-mu[2*j-1]/(alpha[j-1]*mu[2*(j-1)]+(1-alpha[j])*mu[2*j-1]-lamb[j-1])**2 for j in range(1 - extra_edge, n-1)]\n",
    "    if extra_edge:\n",
    "        grad += [-c[(n-1)]*lamb[(n-1)]*mu[2*(n-1)]/(alpha[(n-1)]*(mu[2*(n-1)])+(1-alpha[0])*mu[2*((n-1)+1)-1]-lamb[(n-1)])**2 + -c[(n-1)-1]*lamb[(n-1)-1]*-mu[2*(n-1)-1]/(alpha[(n-1)-1]*mu[2*((n-1)-1)]+(1-alpha[(n-1)])*mu[2*(n-1)-1]-lamb[(n-1)-1])**2]\n",
    "    else:\n",
    "        grad += [-c[n-1]*lamb[n-1]*mu[2*(n-1)]/(alpha[n-1]*(mu[2*(n-1)])-lamb[n-1])**2 + -c[(n-1)-1]*lamb[(n-1)-1]*-mu[2*(n-1)-1]/(alpha[(n-1)-1]*mu[2*((n-1)-1)]+(1-alpha[n-1])*mu[2*(n-1)-1]-lamb[(n-1)-1])**2]\n",
    "\n",
    "    \n",
    "    \n",
    "    return grad\n",
    "\n",
    "# uses KKT conditions to solve for Best Random probabilities\n",
    "def randOptimize():\n",
    "    init = [1 for j in range(n)] #+ [1]\n",
    "    if not extra_edge:\n",
    "        for j in range(1, n):\n",
    "            ub = min([1, (mu[2*(j-1)] - lamb[j-1] + init[j-1]*mu[2*(j-1)])/ mu[2*j-1]])\n",
    "            init[j] = ub\n",
    "        for j in range(n-1, 0, -1):\n",
    "            if j == n-1:\n",
    "                lb = lamb[j] / mu[2*j]\n",
    "            else:\n",
    "                lb = max([0, (-(1-init[j+1])*mu[2*(j+1)-1] + lamb[j])/mu[2*j]])\n",
    "            init[j] = (init[j] + lb)/2\n",
    "        init = init[1:]\n",
    "    \n",
    "    root = fsolve(randFunc, init) #, method='trust-constr', options={'disp': False, 'xtol':1e-40,}, bounds=bounds, constraints=[denom_constr]) # 'xtol':1e-13,  , xtol=1e-25   , factor = 1e-6\n",
    "    if not extra_edge:\n",
    "        root = [1] + list(root)\n",
    "    \n",
    "#     objective = lambda alpha: sum([c[j]*lamb[j]/(alpha[j]*mu[2*j]+(1-alpha[j+1])*mu[2*(j+1)-1]-lamb[j]) for j in range(n-1)]) + c[n-1]*lamb[n-1]/(alpha[n-1]*mu[2*(n-1)] - lamb[n-1])\n",
    "    results = root\n",
    "    if not extra_edge:\n",
    "        for j in range(1, n):\n",
    "            ub = min([1, (mu[2*(j-1)] - lamb[j-1] + results[j-1]*mu[2*(j-1)])/ mu[2*j-1]])\n",
    "            if results[j] > ub:\n",
    "                results[j] = ub\n",
    "        for j in range(n-1, 0, -1):\n",
    "            if j == n-1:\n",
    "                lb = lamb[j] / mu[2*j]\n",
    "            else:\n",
    "                lb = max([0, (-(1-results[j+1])*mu[2*(j+1)-1] + lamb[j])/mu[2*j]])\n",
    "            if results[j] < lb:\n",
    "                results[j] = lb\n",
    "    print(results)\n",
    "    return(results)\n",
    "\n",
    "# color map for joint plots\n",
    "afmhot = matplotlib.cm.get_cmap('afmhot', 512)\n",
    "newcolors = afmhot(np.linspace(0, 1, 512))\n",
    "bg = np.array([200/256, 220/256, 250/256, 1])\n",
    "newcolors[:1, :] = bg\n",
    "afmhot_with0 = matplotlib.colors.ListedColormap(newcolors)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23a17450",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false
   },
   "source": [
    "# Input Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2a24f182",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-08-14T21:21:10.438755Z",
     "start_time": "2021-08-14T21:21:10.422097Z"
    },
    "hideCode": false,
    "hidePrompt": false,
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "extra_edge = False\n",
    "ns = [3] # number of servers/buffers\n",
    "mu = [1 for i in range(2*max(ns)-1 + extra_edge)] # service rates per server\n",
    "duration = 5*10**5 # number of events (cont) or time units (disc)\n",
    "epsilons = [0.005] # extent to which the system is in heavy traffic [0.1, 0.05, 0.01, 0.005, 0.001]\n",
    "c = []#DEFINE LATER ##list(range(1, 20)) #if max(ns)==2 else np.random.randint(5, 15, size=max(ns)) # random costs per buffer, comment out if keeping costs between algs\n",
    "time_mode = \"continuous\"\n",
    "out_folder = \"Output\\\\N-Systems\" # base folder\n",
    "#\"C:\\\\Users\\\\Adam\\\\Dropbox\\\\REU 2021 Shared Folder\\\\Adam\\\\Code\\\\Output\\\\N-Systems\"\n",
    "additional_info = \"\" # info to write to the run log # distribution of q0 and q1-q0\n",
    "lamb_defined = False                                 if max(ns)==2 else True # set all lambda equal to 1-(epsilon/n)?\n",
    "ordered_costs = True # sort costs? will try ascending and descending\n",
    "warmup_period = 0.4 # proportion of duration to cut off\n",
    "graph = False # create graphs? very taxing on memory\n",
    "graph_dist = True\n",
    "to_folder = True\n",
    "show_output = True # print output in Jupyter Notebook?\n",
    "\n",
    "\n",
    "\n",
    "# don't change most of this, it mostly cleans up the inputs above\n",
    "directions = sorted([\"crp_tri\", \"crp_rect\", \"noncrp_tri\", \"noncrp_rect\"]) if not lamb_defined else [1]\n",
    "algs = [\"maxweight\", \"weighted_maxweight\", \"cmu\", \"cmu_thresh\", \"random\", \"random_idle\"]#[\"maxweight\", \"weighted_maxweight\", \"cmu\", \"cmu_thresh\", \"random\", \"random_idle\"] # [\"maxweight\", \"weighted_maxweight\", \"cmu\", \"cmu_single_thresh\", \"cmu_multi_thresh\", \"random\", \"prioritize_right\", \"threshold\", \"random_idle\"]\n",
    "num_algs = len(algs)\n",
    "color_dict = {i:color for (i, color) in enumerate([f\"C{i}\" for i in range(10)])}\n",
    "# maxweight params\n",
    "# gamma = [1 for j in range(n)] # \"cost\"\n",
    "beta = 1\n",
    "\n",
    "input_params = {\"mu\":mu, \"duration\":duration, \"warmup proportion\":warmup_period, \"cost vect\":c, \"beta\":beta, \"time\":time_mode,\n",
    "                \"lamb = 1-epsilon/n\":lamb_defined, \"random cost order\":(not ordered_costs), \"additional info\":additional_info} # \"gamma\":gamma, "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0c4fc35",
   "metadata": {
    "hideCode": false,
    "hidePrompt": false,
    "hide_input": true
   },
   "source": [
    "# Simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "034eee50",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-08-14T21:22:38.429393Z",
     "start_time": "2021-08-14T21:21:56.358662Z"
    },
    "hideCode": false,
    "hidePrompt": false,
    "hide_input": false,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Good Case: Queue 0 is least expensive.\n",
      "[1, 1, 1, 1]\n",
      "Progress: 10%\n",
      "Progress: 20%\n",
      "Progress: 30%\n",
      "Progress: 40%\n",
      "Progress: 50%\n",
      "Progress: 60%\n",
      "Progress: 70%\n",
      "Progress: 80%\n",
      "Progress: 90%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x1440 with 24 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      "  Graph Index Direction epsilon  Case           Algorithm lambda_0 lambda_1  \\\n",
      "0           0       NaN   0.005  good           maxweight    0.995    0.995   \n",
      "1           0       NaN   0.005  good  weighted_maxweight    0.995    0.995   \n",
      "2           0       NaN   0.005  good                 cmu    0.995    0.995   \n",
      "3           0       NaN   0.005  good          cmu_thresh    0.995    0.995   \n",
      "4           0       NaN   0.005  good              random    0.995    0.995   \n",
      "5           0       NaN   0.005  good         random_idle    0.995    0.995   \n",
      "\n",
      "  lambda_2 lambda_3 Queue 0 Param Queue 1 Param Queue 2 Param Queue 3 Param  \\\n",
      "0    0.995    0.995             1             1             1             1   \n",
      "1    0.995    0.995           1.0      1.333333      1.666667           2.0   \n",
      "2    0.995    0.995           NaN           NaN           NaN           NaN   \n",
      "3    0.995    0.995           600           600           600           NaN   \n",
      "4    0.995    0.995             1             1             1             1   \n",
      "5    0.995    0.995             1             1             1             1   \n",
      "\n",
      "    Avg Lq_0   Avg Lq_1   Avg Lq_2    Avg Lq_3 Avg sum(Lq)  \\\n",
      "0  15.000752  35.719231  55.568267  154.680881   260.96913   \n",
      "1  16.192054  32.916691  43.970091  149.461797  242.540633   \n",
      "2  24.496601  25.530035  22.251266  139.376558   211.65446   \n",
      "3  24.496601  25.530035  22.251266  139.376558   211.65446   \n",
      "4  24.496601  25.530035  22.251266  139.376558   211.65446   \n",
      "5  59.098859  51.112664  24.261337  117.033663  251.506523   \n",
      "\n",
      "  Avg Cost-Weighted sum(Lq)  \n",
      "0                464.601933  \n",
      "1                432.288055  \n",
      "2                374.375208  \n",
      "3                374.375208  \n",
      "4                374.375208  \n",
      "5                401.751966  \n",
      "\n",
      "\n",
      "\n",
      "Bad Case: Queue 0 is most expensive.\n",
      "[1, 0.9991800815818671, 0.9988672472595318, 0.9991153037518907]\n",
      "Progress: 10%\n",
      "Progress: 20%\n",
      "Progress: 30%\n",
      "Progress: 40%\n",
      "Progress: 50%\n",
      "Progress: 60%\n",
      "Progress: 70%\n",
      "Progress: 80%\n",
      "Progress: 90%\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x1440 with 24 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "\n",
      "  Graph Index Direction epsilon Case           Algorithm lambda_0 lambda_1  \\\n",
      "0           1       NaN   0.005  bad           maxweight    0.995    0.995   \n",
      "1           1       NaN   0.005  bad  weighted_maxweight    0.995    0.995   \n",
      "2           1       NaN   0.005  bad                 cmu    0.995    0.995   \n",
      "3           1       NaN   0.005  bad          cmu_thresh    0.995    0.995   \n",
      "4           1       NaN   0.005  bad              random    0.995    0.995   \n",
      "5           1       NaN   0.005  bad         random_idle    0.995    0.995   \n",
      "\n",
      "  lambda_2 lambda_3 Queue 0 Param Queue 1 Param Queue 2 Param Queue 3 Param  \\\n",
      "0    0.995    0.995             1             1             1             1   \n",
      "1    0.995    0.995           2.0      1.666667      1.333333           1.0   \n",
      "2    0.995    0.995           NaN           NaN           NaN           NaN   \n",
      "3    0.995    0.995           600           600           600           NaN   \n",
      "4    0.995    0.995             1       0.99918      0.998867      0.999115   \n",
      "5    0.995    0.995             1       0.99918      0.998867      0.999115   \n",
      "\n",
      "    Avg Lq_0   Avg Lq_1   Avg Lq_2     Avg Lq_3  Avg sum(Lq)  \\\n",
      "0  15.000752  35.719231  55.568267   154.680881    260.96913   \n",
      "1  14.419962  37.549905  69.605862   177.807735   299.383465   \n",
      "2   1.153915   2.395137   3.356455  7444.870347  7451.775853   \n",
      "3  24.496601  25.530035  22.251266   139.376558    211.65446   \n",
      "4  24.242112  25.665263  22.095722   142.554401   214.557498   \n",
      "5   55.15651  50.406417  23.391552   120.302549   249.257027   \n",
      "\n",
      "  Avg Cost-Weighted sum(Lq)  \n",
      "0                318.305458  \n",
      "1                362.038652  \n",
      "2               7455.645344  \n",
      "3                260.588174  \n",
      "4                263.275026  \n",
      "5                345.814999  \n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# creates info.txt to store important run info\n",
    "out_time = int(time_lib.time())\n",
    "out_i = 0\n",
    "if to_folder:\n",
    "    os.makedirs(f\"{out_folder}\\\\{out_time}\")\n",
    "with open(f\"{out_folder}\\\\{out_time}\\\\\"*to_folder + \"info.txt\", \"w\") as file:\n",
    "    for (label, data) in input_params.items():\n",
    "        print(f\"{label}:\", data, file=file)\n",
    "    \n",
    "# iterate through system lengths  \n",
    "for n in ns:\n",
    "\n",
    "    # build cost vector evenly spread b/w 1 and 2\n",
    "    c = list(np.linspace(1, 2, num=n))\n",
    "    \n",
    "    # iterate through good and bad case if applicable\n",
    "    for case in range(1 + ordered_costs):\n",
    "        if ordered_costs:\n",
    "            c.sort()\n",
    "            if case == 0:\n",
    "                if show_output:\n",
    "                    print(\"Good Case: Queue 0 is least expensive.\")\n",
    "            else:\n",
    "                if show_output:\n",
    "                    print(\"Bad Case: Queue 0 is most expensive.\")\n",
    "                c = c[::-1]\n",
    "        \n",
    "        # iterate through capacity region directions if applicable\n",
    "        for direction in directions:\n",
    "            lambdas = []\n",
    "    \n",
    "            # only if lambdas are not defined directly by epsilon\n",
    "            if not lamb_defined:\n",
    "\n",
    "                if n == 2:\n",
    "                    fig = plt.figure(figsize=[10, 10])\n",
    "                    # plot capacity region w/ lambdas approaching facets\n",
    "                    plt.fill_between([0, mu[0]], 0, mu[2], color='C2', alpha=0.1)\n",
    "                    plt.fill_between([mu[0], mu[0] + mu[1]], 0, [mu[2], 0], color='C2', alpha=0.1)\n",
    "                    plt.axhline(mu[2], xmin=0, xmax=mu[0])\n",
    "                    plt.axvline(mu[0], ymin=0, ymax=mu[2], linestyle=\"dashed\")\n",
    "                    plt.plot([0, mu[0]+mu[1]], [mu[2] + mu[0]*mu[2]/mu[1], 0])\n",
    "                    plt.xlim([0, (mu[0]+mu[1])])\n",
    "                    plt.ylim([0, (mu[2] + mu[0]*mu[2]/mu[1])])\n",
    "\n",
    "                    # what direction do we approach heavy traffic limit\n",
    "                    if direction == \"noncrp_rect\":\n",
    "                        slope = mu[2] / mu[0]\n",
    "                        for epsilon in epsilons:\n",
    "                                lambdas.append((mu[0] * (1-epsilon/2), slope * mu[0] * (1-epsilon/2)))\n",
    "                                plt.plot(lambdas[-1][0], lambdas[-1][1], marker=\"+\")\n",
    "                    if direction == \"crp_tri\":\n",
    "                        slope = (mu[0]+mu[1]) / (mu[2] + mu[0]*mu[2]/mu[1])\n",
    "                        intercept = mu[2]/2 - (mu[0]+mu[1]/2) * slope\n",
    "                        for epsilon in epsilons:\n",
    "                                lambdas.append((mu[0]+ mu[1] / 2 * (1-epsilon/2), intercept + slope * (mu[0]+mu[1]/2) * (1-epsilon/2)))\n",
    "                                plt.plot(lambdas[-1][0], lambdas[-1][1], marker=\"+\")\n",
    "                    if direction == \"crp_rect\":\n",
    "                        for epsilon in epsilons:\n",
    "                                lambdas.append((3*mu[0]/4, mu[2] * (1-epsilon/10)))\n",
    "                                plt.plot(lambdas[-1][0], lambdas[-1][1], marker=\"+\")\n",
    "                    if direction == \"noncrp_tri\":\n",
    "                        for epsilon in epsilons:\n",
    "                                lambdas.append((mu[0] + epsilon*2 * mu[1]/2, mu[2] * (1-epsilon*2)))\n",
    "                                plt.plot(lambdas[-1][0], lambdas[-1][1], marker=\"+\")\n",
    "\n",
    "                    # fix and print plot\n",
    "                    plt.xlabel(\"Buffer 0 Arrival Rate\")\n",
    "                    plt.ylabel(\"Buffer 1 Arrival Rate\")\n",
    "                    plt.title(\"Capacity Region\")\n",
    "                    plt.savefig(f\"{out_folder}\\\\{out_time}\\\\\"*to_folder + f\"region_{direction}.png\")\n",
    "                    if show_output:\n",
    "                        plt.show()\n",
    "                        print(\"\\n\\n\")\n",
    "                \n",
    "            # otherwise lambdas are defined by epsilon\n",
    "            else:\n",
    "                for epsilon in epsilons:\n",
    "                    lambdas.append([1-epsilon for j in range(n)])\n",
    "\n",
    "            for lamb in lambdas:\n",
    "    #             if n == 2:\n",
    "    #                 epsilon = abs((1-lamb[1]/mu[2]) - (lamb[0]-mu[0])/mu[1])\n",
    "    #             else:\n",
    "    #             epsilon = 1 - sum(lamb) / sum(mu[::2])\n",
    "                if not lamb_defined:\n",
    "                    epsilon = sum(mu[::2]) - sum(lamb)\n",
    "                else:\n",
    "                    epsilon = epsilons[lambdas.index(lamb)]\n",
    "\n",
    "\n",
    "                # initializing variables\n",
    "                if time_mode == \"continuous\":\n",
    "                    rng1 = np.random.default_rng(100)\n",
    "                    rng2 = np.random.default_rng(200)\n",
    "                    rng3 = np.random.default_rng(300)\n",
    "                elif time_mode == \"discrete\":\n",
    "                    rng1 = [np.random.default_rng(100 + j) for j in range(n)]\n",
    "                    rng2 = [np.random.default_rng(200 + act) for act in range(2*n-1)]\n",
    "                    rng3 = np.random.default_rng(300)\n",
    "                    unused_tallys = [[0 for j in range(n)] for alg_index in range(num_algs)]\n",
    "\n",
    "                # for threshold algs\n",
    "                Lr = [600 for j in range(n)]#[i*3 for i in np.linspace(78-8*(n-3), 200+35*(n-3), num=n-1)] #[500 for j in range(n-1)]#[c[j+1]/c[j] * 120 * np.log(1/epsilon) for j in range(n-1)] # used to be 75  [110, 330][lambdas.index(lamb)]\n",
    "                # for best random alg\n",
    "                alpha = randOptimize()\n",
    "#                 alpha = [0 for j in range(n)]\n",
    "\n",
    "                # initializing statistics\n",
    "                if graph:\n",
    "                    event_time_stats = [[] for alg_index in range(num_algs)]\n",
    "                    Lq_stats = [[] for alg_index in range(num_algs)]\n",
    "                if graph_dist and n == 2:\n",
    "                    Lq_freqs = [{} for alg_index in range(num_algs)]\n",
    "                elif graph_dist:\n",
    "                    Lq_freqs = [[{} for j in range(n)] for alg_index in range(num_algs)]\n",
    "                decisions = [[1 for i in range(n)] for alg_index in range(num_algs)]\n",
    "                Lqs = [[0 for i in range(n)] for alg_index in range(num_algs)]\n",
    "                times = [0 for alg_index in range(num_algs)]\n",
    "                Lq_tallys = [[0 for j in range(n)] for alg_index in range(num_algs)]\n",
    "                \n",
    "\n",
    "                # beginning run\n",
    "                for iteration in range(duration):\n",
    "                    if iteration % (duration // 10) == 0 and iteration > 0:\n",
    "                        print(f\"Progress: {(iteration // (duration // 10))*10}%\")\n",
    "                    if time_mode == \"continuous\":\n",
    "                        # combining process rates\n",
    "                        if extra_edge:\n",
    "                            denominators = [sum(lamb) + (Lqs[alg_index][0] > 0 and decisions[alg_index][0] == 1) * mu[0] + (Lqs[alg_index][n-1] > 0 and decisions[alg_index][0] == 0) * mu[-1] + sum([(Lqs[alg_index][i] > 0 and decisions[alg_index][i+1] == 0) * mu[2*(i+1)-1] +\n",
    "                                                (Lqs[alg_index][i+1] > 0 and decisions[alg_index][i+1] == 1) * mu[2*(i+1)] for i in range(n-1)]) for alg_index in range(num_algs)]\n",
    "                        else:\n",
    "                            denominators = [sum(lamb) + (Lqs[alg_index][0] > 0) * mu[0] + sum([(Lqs[alg_index][i] > 0 and decisions[alg_index][i+1] == 0) * mu[2*(i+1)-1] +\n",
    "                                                (Lqs[alg_index][i+1] > 0 and decisions[alg_index][i+1] == 1) * mu[2*(i+1)] for i in range(n-1)]) for alg_index in range(num_algs)]\n",
    "                        \n",
    "                            \n",
    "                        \n",
    "                        \n",
    "                        prob = rng1.uniform(0, 1)\n",
    "                        interarrival_times = [-denominators[alg_index]*np.log(1-prob) for alg_index in range(num_algs)]\n",
    "\n",
    "                        # record state to statistic\n",
    "                        if iteration > warmup_period * duration:\n",
    "                            for alg_index in range(num_algs):\n",
    "                                for j in range(n):\n",
    "                                    Lq_tallys[alg_index][j] = Lq_tallys[alg_index][j]*times[alg_index]/(times[alg_index]+interarrival_times[alg_index]) + (Lqs[alg_index][j] * interarrival_times[alg_index]) / (times[alg_index] + interarrival_times[alg_index])\n",
    "                                times[alg_index] += interarrival_times[alg_index]\n",
    "                                if graph:\n",
    "                                    event_time_stats[alg_index].append(times[alg_index])\n",
    "                                    Lq_stats[alg_index].append(copy.deepcopy(Lqs[alg_index]))\n",
    "\n",
    "\n",
    "                        # check what this event represents, do appropriate action\n",
    "                        prob = rng2.uniform(0, 1)\n",
    "                        for alg_index in range(num_algs):\n",
    "                            prob_copy = prob\n",
    "                            for j in range(n):\n",
    "                                prob_copy -= lamb[j] / denominators[alg_index]\n",
    "                                if prob_copy < 0:\n",
    "                                    Lqs[alg_index][j] += 1\n",
    "                                    break\n",
    "                            if prob_copy > 0:\n",
    "                                prob_copy -= (Lqs[alg_index][0] > 0 and decisions[alg_index][0] == 1) * mu[0] / denominators[alg_index]\n",
    "                                if prob_copy < 0:\n",
    "                                    Lqs[alg_index][0] -= 1\n",
    "                            for j in range(n-1):\n",
    "                                if prob_copy > 0:\n",
    "                                    prob_copy -= (Lqs[alg_index][j] > 0 and decisions[alg_index][j+1] == 0) * mu[2*(j+1)-1] / denominators[alg_index]\n",
    "                                    if prob_copy < 0:\n",
    "                                        Lqs[alg_index][j] -= 1\n",
    "                                        break\n",
    "                                if prob_copy > 0:\n",
    "                                    prob_copy -= (Lqs[alg_index][j+1] > 0 and decisions[alg_index][j+1] == 1) * mu[2*(j+1)] / denominators[alg_index]\n",
    "                                    if prob_copy < 0:\n",
    "                                        Lqs[alg_index][j+1] -= 1\n",
    "                                        break\n",
    "                            if extra_edge:\n",
    "                                if prob_copy > 0:\n",
    "                                    prob_copy -= (Lqs[alg_index][n-1] > 0 and decisions[alg_index][0] == 0) * mu[-1] / denominators[alg_index]\n",
    "                                    if prob_copy < 0:\n",
    "                                        Lqs[alg_index][n-1] -= 1\n",
    "                                        break\n",
    "                                    \n",
    "                    # corresponding discrete-time algorithm, likely out of date\n",
    "                    elif time_mode == \"discrete\":\n",
    "                        time += 1\n",
    "\n",
    "                        # num arrivals per buffer\n",
    "                        for j in range(n):\n",
    "                            Lqs[alg_index][j] += rng1[j].poisson(lamb[j])\n",
    "\n",
    "                        # num services for each buffer\n",
    "                        Lqs[alg_index][0] -= rng2[0].poisson(mu[0])\n",
    "                        for j in range(1, n):\n",
    "                            if alg == \"random\":\n",
    "                                Lqs[alg_index][j-1] -= rng2[2*j-1].poisson((1-alpha[j]) * mu[2*j-1])\n",
    "                                Lqs[alg_index][j] -= rng2[2*j].poisson((alpha[j]) * mu[2*j])\n",
    "                            elif alg == \"maxweight\":\n",
    "                                Lqs[alg_index][j-1] -= round((1-alpha_maxweight[j]) * rng2[2*j-1].poisson(mu[2*j-1]))\n",
    "                                Lqs[alg_index][j] -= round((alpha_maxweight[j]) * rng2[2*j].poisson(mu[2*j]))\n",
    "                            else:\n",
    "                                Lqs[alg_index][j-1] -= (decisions[alg_index][j] == 0) * rng2[2*j-1].poisson(mu[2*j-1])\n",
    "                                Lqs[alg_index][j] -= (decisions[alg_index][j] == 1) * rng2[2*j].poisson(mu[2*j])\n",
    "\n",
    "                        # ensure positive buffers\n",
    "                        for j in range(n):\n",
    "                            if Lqs[alg_index][j] < 0:\n",
    "                                unused_tallys[alg_index][j] = - Lqs[alg_index][j]\n",
    "                                Lqs[alg_index][j] = 0\n",
    "\n",
    "                    # changes servers' priority by the policy\n",
    "                    for alg_index in range(num_algs):\n",
    "                        alg = algs[alg_index]\n",
    "                        for i in range(1-extra_edge, n):\n",
    "                            if Lqs[alg_index][i-1] == 0 and time_mode == \"continuous\" and \"idle\" not in alg:\n",
    "                                decisions[alg_index][i] = 1\n",
    "                            elif Lqs[alg_index][i] == 0 and time_mode == \"continuous\" and \"idle\" not in alg:\n",
    "                                decisions[alg_index][i] = 0\n",
    "                            else:\n",
    "                                if \"maxweight\" in alg:\n",
    "                                    if \"weighted\" in alg:\n",
    "                                        gamma = c\n",
    "                                    else:\n",
    "                                        gamma = [1 for j in range(n)]\n",
    "                                    decisions[alg_index][i] = int(gamma[i] * Lqs[alg_index][i] ** beta * mu[2*i] >\n",
    "                                                                  gamma[i-1] * Lqs[alg_index][i-1] ** beta * mu[2*i-1])\n",
    "                                elif \"random\" in alg:\n",
    "                                    decisions[alg_index][i] = int(rng3.uniform(0,1) < alpha[i]) # applies only if continuous time\n",
    "                                elif alg == \"prioritize_right\":\n",
    "                                    decisions[alg_index][i] = 1\n",
    "                                elif \"cmu\" in alg:\n",
    "                                    decisions[alg_index][i] = int(c[i] * mu[2*i] > c[i-1] * mu[2*i-1])\n",
    "                                    if \"thresh\" in alg:\n",
    "                                        if Lqs[alg_index][i-1] <= Lr[i-1]:\n",
    "                                            decisions[alg_index][i] = 1\n",
    "\n",
    "                            \n",
    "                        # record distribution frequencies if applicable\n",
    "                        if iteration > warmup_period * duration and graph_dist:\n",
    "                            if n == 2:\n",
    "                                if alg == \"maxweight\":\n",
    "                                    term = (Lqs[alg_index][0], Lqs[alg_index][1]-Lqs[alg_index][0])\n",
    "                                elif alg == \"weighted_maxweight\":\n",
    "                                    term = (Lqs[alg_index][0], c[1]*Lqs[alg_index][1]-c[0]*Lqs[alg_index][0])\n",
    "                                else:\n",
    "                                    term = tuple(Lqs[alg_index])\n",
    "                                if term not in Lq_freqs[alg_index].keys():\n",
    "                                    Lq_freqs[alg_index][term] = 0\n",
    "                                Lq_freqs[alg_index][term] += 1\n",
    "                            else:\n",
    "                                for j in range(n):\n",
    "                                    if j > 0:\n",
    "                                        if alg == \"maxweight\":\n",
    "                                            term = Lqs[alg_index][j] - Lqs[alg_index][j-1]\n",
    "                                        elif alg == \"weighted_maxweight\":\n",
    "                                            term = c[j]*Lqs[alg_index][j] - c[j-1]*Lqs[alg_index][j-1]\n",
    "                                        else:\n",
    "                                            term = Lqs[alg_index][j]\n",
    "                                    else:\n",
    "                                        term = Lqs[alg_index][j]\n",
    "                                    if term not in Lq_freqs[alg_index][j].keys():\n",
    "                                        Lq_freqs[alg_index][j][term] = 0\n",
    "                                    Lq_freqs[alg_index][j][term] += 1\n",
    "                                        \n",
    "\n",
    "                # initialize subplots and table\n",
    "                avg_df = pd.DataFrame(columns=[\"Graph Index\", \"Direction\", \"epsilon\", \"Case\", \"Algorithm\"] + [f\"lambda_{j}\" for j in range(max(ns))] + [f\"Queue {j} Param\" for j in range(max(ns))] + [f\"Avg Lq_{j}\" for j in range(max(ns))] + [\"Avg sum(Lq)\", \"Avg Cost-Weighted sum(Lq)\"]) # index=range(len(algs)), \n",
    "                if graph:\n",
    "                    fig_Lq, axs_Lq = plt.subplots(len(algs) // 2, 2, sharex=False, sharey=False)\n",
    "\n",
    "\n",
    "                \n",
    "                # initialize joint dist plots\n",
    "                if graph_dist and n == 2:\n",
    "                    fig_dist = plt.figure()\n",
    "                    subfigs_dist = fig_dist.subfigures(len(algs) // 2, 2, wspace=0.07)\n",
    "                elif graph_dist:\n",
    "                    fig_dist = plt.figure()\n",
    "                    subfigs_dist = fig_dist.subfigures(len(algs) // 2, 2, wspace=0.07)\n",
    "                   \n",
    "                            \n",
    "                # plot queue lengths\n",
    "                for alg_index in range(num_algs):\n",
    "                    alg = algs[alg_index]\n",
    "                    if graph:\n",
    "                        for j in range(n):\n",
    "                            axs_Lq[alg_index // 2, alg_index % 2].plot(event_time_stats[alg_index], [Lq[j] for Lq in Lq_stats[alg_index]], label = f\"Lq_{j}\", color=color_dict[j])\n",
    "                        if \"thresh\" in alg:\n",
    "                            for j in range(n-1):\n",
    "                                axs_Lq[alg_index // 2, alg_index % 2].axhline(Lr[j], xmin=0, xmax=times[alg_index], label = f\"Lr_{j}\", linestyle=\"dotted\", color=color_dict[j], alpha=0.6)\n",
    "                        axs_Lq[alg_index // 2, alg_index % 2].legend()\n",
    "                        axs_Lq[alg_index // 2, alg_index % 2].set(ylabel=\"Queue Length\", xlabel=\"Time\")\n",
    "                        axs_Lq[alg_index // 2, alg_index % 2].set_title(alg)\n",
    "\n",
    "                    # joint plots only for two-dimensional state space\n",
    "                    if graph_dist and n == 2:\n",
    "                        df = pd.DataFrame({\"Lq_0\":[Lq_0 for (Lq_0, Lq_1) in Lq_freqs[alg_index].keys()], \"Lq_1\":[Lq_1 for (Lq_0, Lq_1) in Lq_freqs[alg_index].keys()], \"weights\":list(Lq_freqs[alg_index].values())})\n",
    "                        x_range = (min(df[\"Lq_0\"]), max(df[\"Lq_0\"]))\n",
    "                        y_range = (min(df[\"Lq_1\"]), max(df[\"Lq_1\"]))\n",
    "                        x_bins = min(50, len(df[\"Lq_0\"]))\n",
    "                        y_bins = min(50, len(df[\"Lq_1\"]))\n",
    "                        axs = subfigs_dist[alg_index // 2, alg_index % 2].subplots(2, 2, sharex=False, sharey=False, gridspec_kw={'height_ratios': [1, 3], 'width_ratios': [3, 1], 'wspace':0, 'hspace':0})\n",
    "                        axs[1, 0].hist2d(df[\"Lq_0\"], df[\"Lq_1\"], weights=df[\"weights\"], bins=(x_bins, y_bins), range=(x_range, y_range), density=False, cmin=0, cmap=afmhot_with0)\n",
    "                        if alg == \"maxweight\":\n",
    "                            axs[1, 0].set(ylabel=\"Lq_1-Lq_0\", xlabel=\"Lq_0\")\n",
    "                        elif alg == \"weighted_maxweight\":\n",
    "                            axs[1, 0].set(ylabel=\"c_1*Lq_1-c_0*Lq_0\", xlabel=\"Lq_0\")\n",
    "                        else:\n",
    "                            axs[1, 0].set(ylabel=\"Lq_1\", xlabel=\"Lq_0\")\n",
    "                        axs[0, 0].hist(df[\"Lq_0\"], weights=df[\"weights\"], bins=x_bins, range=x_range, density=True)\n",
    "                        axs[0, 0].set_xticklabels([])\n",
    "                        axs[0, 0].set_yticklabels([])\n",
    "                        axs[1, 1].hist(df[\"Lq_1\"], weights=df[\"weights\"], bins=y_bins, range=y_range, density=True, orientation=\"horizontal\")\n",
    "                        axs[1, 1].set_xticklabels([])\n",
    "                        axs[1, 1].set_yticklabels([])\n",
    "                        subfigs_dist[alg_index // 2, alg_index % 2].suptitle(alg)\n",
    "                        subfigs_dist[alg_index // 2, alg_index % 2].delaxes(axs[0, 1])\n",
    "\n",
    "                    # marginal distribution plots otherwise\n",
    "                    elif graph_dist:\n",
    "                        axs = subfigs_dist[alg_index // 2, alg_index % 2].subplots(1, n, sharex=False, sharey=False, gridspec_kw={'wspace':0.35, 'hspace':0})\n",
    "                        for j in range(n):\n",
    "                            data = [Lq for Lq in Lq_freqs[alg_index][j].keys()]\n",
    "                            weights = list(Lq_freqs[alg_index][j].values())\n",
    "                            bins = min(50, len(data))\n",
    "                            \n",
    "                            axs[j].hist(data, weights=weights, bins=bins, density=True, orientation=\"horizontal\")\n",
    "                            if alg == \"maxweight\" and j>0:\n",
    "                                axs[j].set_xlabel(f\"Lq_{j}-Lq_{j-1}\", rotation=-15, position=(1.2-0.1*(11-n), 0))\n",
    "                            elif alg == \"weighted_maxweight\" and j>0:\n",
    "                                axs[j].set_xlabel(f\"c_{j}*Lq_{j}-c_{j-1}*Lq_{j-1}\", rotation=-15, position=(1.8-0.16*(11-n), 0))\n",
    "                            else:\n",
    "                                axs[j].set(xlabel=f\"Lq_{j}\")\n",
    "                        \n",
    "                            axs[j].set_xticklabels([])\n",
    "                            axs[j].yaxis.set_major_formatter(FormatStrFormatter('%d'))\n",
    "                            for tick in axs[j].get_yticklabels():\n",
    "                                tick.set_rotation(-90)\n",
    "                                tick.set_position((0.17-0.023*(11-n), 0))\n",
    "                        subfigs_dist[alg_index // 2, alg_index % 2].suptitle(alg)\n",
    "\n",
    "                    # populate avgs table with run results\n",
    "                    if graph or graph_dist:\n",
    "                        avg_df.loc[alg_index, \"Graph Index\"] = out_i\n",
    "                    if direction != 1:\n",
    "                        avg_df.loc[alg_index, \"Direction\"] = direction\n",
    "                    avg_df.loc[alg_index, \"epsilon\"] = epsilon\n",
    "                    if ordered_costs:\n",
    "                        avg_df.loc[alg_index, \"Case\"] = \"good\" if (case == 0) else \"bad\"\n",
    "                    avg_df.loc[alg_index, \"Algorithm\"] = alg\n",
    "                    for j in range(n):\n",
    "                        avg_df.loc[alg_index, f\"lambda_{j}\"] = lamb[j]\n",
    "                        avg_df.loc[alg_index, f\"Avg Lq_{j}\"] = Lq_tallys[alg_index][j] #np.mean([Lq[j] for Lq in Lq_stat])\n",
    "                        if \"random\" in alg:\n",
    "                            avg_df.loc[alg_index, f\"Queue {j} Param\"] = alpha[j]\n",
    "                        elif \"thresh\" in alg and j<n-1:\n",
    "                            avg_df.loc[alg_index, f\"Queue {j} Param\"] = Lr[j]\n",
    "                        elif \"maxweight\" in alg:\n",
    "                            if \"weighted\" in alg:\n",
    "                                avg_df.loc[alg_index, f\"Queue {j} Param\"] = c[j]\n",
    "                            else:\n",
    "                                avg_df.loc[alg_index, f\"Queue {j} Param\"] = 1\n",
    "                    avg_df.loc[alg_index, \"Avg sum(Lq)\"] = sum(Lq_tallys[alg_index])#sum_Lq_tallys[alg_index]/(times[alg_index]) #np.mean([sum(Lq) for Lq in Lq_stat])\n",
    "                    avg_df.loc[alg_index, \"Avg Cost-Weighted sum(Lq)\"] = sum([c[j] * Lq_tallys[alg_index][j] for j in range(n)]) #sum_weighted_Lq_tallys[alg_index]/(times[alg_index]) # np.mean([sum([c[i] * Lq[i] for i in range(n)]) for Lq in Lq_stat])\n",
    "\n",
    "                # display or save multigraphs and tables w/ all algorithm outputs\n",
    "                csv_filename = f\"{out_folder}\\\\{out_time}\\\\\"*to_folder + \"results.csv\"\n",
    "                avg_df.to_csv(csv_filename, mode=\"a\", header= (not os.path.exists(csv_filename)), index=False)\n",
    "\n",
    "                if graph:\n",
    "                    fig_Lq.suptitle(f\"Epsilon {round(epsilon, 3)} Queue Length\", fontsize=\"xx-large\", y=0.94)\n",
    "                    fig_Lq.savefig(f\"{out_folder}\\\\{out_time}\\\\\"*to_folder + f\"{out_i}_Lq.png\", bbox_inches=\"tight\")\n",
    "                if graph_dist:\n",
    "                    fig_dist.suptitle(f\"Epsilon {round(epsilon, 3)} Joint Distribution\", fontsize=\"xx-large\", y=0.94)\n",
    "                    fig_dist.savefig(f\"{out_folder}\\\\{out_time}\\\\\"*to_folder + f\"{out_i}_dist.png\")\n",
    "                if show_output:\n",
    "                    if graph:\n",
    "                        display(fig_Lq)\n",
    "                        print(\"\\n\\n\")\n",
    "                    if graph_dist:\n",
    "                        display(fig_dist)\n",
    "                        print(\"\\n\\n\\n\")\n",
    "                    pprint(avg_df)\n",
    "                    print(\"\\n\\n\")\n",
    "                out_i += 1\n",
    "\n",
    "\n",
    "                plt.close(\"all\")\n",
    "\n",
    "# record run length for time management purposes\n",
    "with open(f\"{out_folder}\\\\{out_time}\\\\\"*to_folder + \"info.txt\", \"a\") as file:\n",
    "    print(\"Run time:\", int(time_lib.time()) - out_time, \"seconds\", file=file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b79688d5",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Hide code",
  "hide_code_all_hidden": false,
  "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}