fixedmeanKurtosis2servers_large.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "aa7bec84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            p      lam1      lam2  kurt\n",
      "182  0.681521  0.793532  0.194058    30\n",
      "185  0.752235  3.860255  0.107484    30\n",
      "192  0.706687  1.180466  0.154266    30\n",
      "193  0.693672  0.987764  0.170397    30\n",
      "200  0.711312  1.262325  0.149077    30\n",
      "p       float64\n",
      "lam1    float64\n",
      "lam2    float64\n",
      "kurt      int64\n",
      "dtype: object\n",
      "            q       mu1       mu2  kurt\n",
      "168  0.691491  2.395065  0.433735    30\n",
      "171  0.702179  2.772309  0.398841    30\n",
      "178  0.704154  2.848570  0.392992    30\n",
      "192  0.723829  3.885792  0.339391    30\n",
      "195  0.723525  3.863712  0.340177    30\n",
      "q       float64\n",
      "mu1     float64\n",
      "mu2     float64\n",
      "kurt      int64\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "#Only diff betweeen this and fixedmeanKurtosis.ipynb is that it works on tha dataset witha. higher kurtosis\n",
    "\n",
    "import numpy as np\n",
    "import sympy as sp\n",
    "import pandas as pd\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "from sympy import solve, Eq, symbols, re\n",
    "\n",
    "#NOTE - Anytime skew is used in this code, it refers to 3rd moment\n",
    "\n",
    "\n",
    "def split_by_plus_minus(s):\n",
    "    return s.str.split(r'[\\+\\-]', expand=True)[0]\n",
    "\n",
    "IAT_params = pd.read_csv('IATparameters_kurt_variation_large.csv')\n",
    "IAT_params = IAT_params[~IAT_params[['lam1', 'lam2']].apply(lambda x: x.str.contains('\\+|\\-')).any(axis=1)]\n",
    "IAT_params[['lam1', 'lam2']] = IAT_params[['lam1', 'lam2']].astype(float)\n",
    "print(IAT_params.head())\n",
    "print(IAT_params.dtypes)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "ST_params = pd.read_csv('STparameters_kurt_variation_large.csv')\n",
    "ST_params = ST_params[~ST_params[['mu1', 'mu2']].apply(lambda x: x.str.contains('\\+|\\-')).any(axis=1)]\n",
    "ST_params[['mu1', 'mu2']] = ST_params[['mu1', 'mu2']].astype(float)\n",
    "print(ST_params.head())\n",
    "print(ST_params.dtypes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ce23bb72",
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculatecoeff_var(lam1, lam2, p) :\n",
    "    dist_mean =  p/lam1+ (1-p)/lam2\n",
    "    dist_var = (2*p/lam1**2 + 2*(1-p)/lam2**2) - dist_mean**2\n",
    "    dist_sd = abs(np.sqrt(dist_var))\n",
    "    \n",
    "    if (dist_sd / dist_mean) >= 1 :\n",
    "        return(dist_sd/dist_mean)\n",
    "    else :\n",
    "        print(\"Please check your inputs. Coefficient of variance < 1\")\n",
    "        return -100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "434c5328",
   "metadata": {},
   "outputs": [],
   "source": [
    "def Tarasov(p_arr, lam1_arr, lam2_arr, q_arr, mu1_arr, mu2_arr) :\n",
    "    WTarasov_arr = []\n",
    "    \n",
    "    \n",
    "    mu_CV_arr = []\n",
    "    lam_CV_arr = []\n",
    "    for k2 in range( len(q_arr)) : \n",
    "        for k1 in range( len(p_arr)) : \n",
    "            \n",
    "            if calculatecoeff_var(lam1_arr[k1], lam2_arr[k1], p_arr[k1]) >=1 : \n",
    "                lam_CV_arr.append(calculatecoeff_var(lam1_arr[k1], lam2_arr[k1], p_arr[k1]))\n",
    "            \n",
    "            if calculatecoeff_var(mu1_arr[k2], mu2_arr[k2], q_arr[k2]) >=1 :\n",
    "                mu_CV_arr.append(calculatecoeff_var(mu1_arr[k2], mu2_arr[k2], q_arr[k2]))\n",
    "            else :\n",
    "                continue\n",
    "                \n",
    "            lam1 = lam1_arr[k1]\n",
    "            lam2 = lam2_arr[k1]\n",
    "            p = p_arr[k1]\n",
    "            \n",
    "            mu1 = mu1_arr[k2]\n",
    "            mu2 = mu2_arr[k2]\n",
    "            q = q_arr[k2]\n",
    "                \n",
    "            b1 = 2*mu1*(1-q)\n",
    "            b2 = 2*mu2*(1-q)\n",
    "            b3 = 2*mu1*q\n",
    "            b4 = 2*mu2*q\n",
    "            f1 = lam1*(1-p)\n",
    "            f2 = lam2*(1-p)\n",
    "            f3 = lam1*p\n",
    "            f4 = lam2*p\n",
    "\n",
    "            #Initializing forward, backward and initial arrays\n",
    "            L_0 = np.transpose(np.array([[-(lam1), 0],\n",
    "                           [0, -(lam2)]]))\n",
    "           # print(L_0)\n",
    "            #F_0 = np.array([[lam1*p*q, lam1*(1-p)*q, lam1*p*(1-q), lam1*(1-p)*(1-q)],\n",
    "            #               [lam2*(1-p)*(1-q), lam2*p*(1-q), lam2*p*q, lam2*(1-p)*q]])\n",
    "\n",
    "            F_0 = np.array([[lam1*p*q, lam1*(1-p)*q, lam1*p*(1-q), lam1*(1-p)*(1-q)],\n",
    "                          #[lam2*p*q, lam2*(p)*(1-q), lam2*(1-p)*(q), lam2*(1-p)*(1-q)],\n",
    "                           [lam2*(p)*(q), lam2*(1-p)*(q), lam2*(p)*(1-q), lam2*(1-p)*(1-q)]])\n",
    "           # print(F_0)\n",
    "            B_0 = np.array([[mu1, 0],\n",
    "                           [mu1, 0],\n",
    "                           [0, mu2],\n",
    "                           [0, mu2]])\n",
    "           # print(B_0)\n",
    "            L = np.array([[-(lam1 + 2*mu1), 0, 0, 0],\n",
    "                         [0, -(lam2 + 2*mu1), 0, 0],\n",
    "                         [0, 0, -(lam1 + 2*mu2), 0],\n",
    "                         [0, 0, 0, -(lam2 + 2*mu2)]])\n",
    "            L_1 = np.array([[-(lam1 + mu1), 0, 0, 0],\n",
    "                         [0, -(lam2 + mu1), 0, 0],\n",
    "                         [0, 0, -(lam1 + mu2), 0],\n",
    "                         [0, 0, 0, -(lam2 + mu2)]])\n",
    "           # print(L)\n",
    "           # print(L_1)\n",
    "            F = np.array([[f3, f1, 0, 0],\n",
    "                         [f4, f2, 0, 0],\n",
    "                         [0, 0, f3, f1],\n",
    "                         [0, 0, f4, f2]])\n",
    "            #print(F)\n",
    "            B = np.array([[b3, 0, b1, 0],\n",
    "                         [0, b3, 0, b1],\n",
    "                         [b4, 0, b2, 0],\n",
    "                         [0, b4, 0, b2]])\n",
    "            B1 = np.array([[mu1*q, 0, mu1*(1-q), 0],\n",
    "                         [0, mu1*q, 0, mu1*(1-q)],\n",
    "                         [mu2*q, 0, mu2*(1-q), 0],\n",
    "                         [0, mu2*q, 0, mu2*(1-q)]])\n",
    "            #print(B)\n",
    "            #print(B1)\n",
    "            R_0 = np.zeros((4, 4))\n",
    "            #print(R_0)\n",
    "\n",
    "            R_prev = R_0\n",
    "            n = 0\n",
    "            flag = 0\n",
    "\n",
    "            while flag == 0 :\n",
    "                diff = []\n",
    "                if n > 0:\n",
    "                    R_prev = R\n",
    "\n",
    "                R_2 = np.matmul(R_prev,R_prev)\n",
    "                R_mid = -(np.matmul(R_2,B) + F)\n",
    "                #print(R_mid)\n",
    "                R = np.matmul(R_mid, np.linalg.inv(L))\n",
    "\n",
    "                for (i,j) in zip(R_prev, R) :\n",
    "                    for (k,l) in zip(i,j) :\n",
    "                        diff.append(abs(k-l))\n",
    "\n",
    "                max = np.max(diff)\n",
    "                #print(\"Max is\", max)\n",
    "                if (max < 10**-7) :\n",
    "\n",
    "                    flag =1\n",
    "                    break\n",
    "                n += 1\n",
    "           # print(R,n)\n",
    "\n",
    "            #Computing steady state distribution for state 0 and 1\n",
    "\n",
    "            #Creating (I - R)^-1 = psi\n",
    "            I = np.eye(4)\n",
    "            psi_full = np.linalg.inv(I - R)\n",
    "            psi = np.matmul(psi_full,np.ones((4,1), dtype=int))\n",
    "            psi = np.vstack([np.ones((6,1), dtype=int), psi])\n",
    "            #print(\"Psi :\",psi)\n",
    "\n",
    "            #Creating L + RB\n",
    "            RB = np.matmul(R, B)\n",
    "            LRB = np.add(L, RB)\n",
    "           # print(LRB)\n",
    "\n",
    "            #Creating stacked version of [0  F  L+RB]T = phi\n",
    "            phi_2 = np.vstack([np.zeros((2, 4)), F, LRB])\n",
    "\n",
    "\n",
    "            #Creating stacked version of [F_0 L_1 B]\n",
    "            phi_1 = np.vstack([F_0, L_1, B])\n",
    "\n",
    "            phi = np.hstack([phi_1, phi_2])\n",
    "            #print(\"Phi :\",phi)\n",
    "\n",
    "            #Solving for pi_0 and pi_1\n",
    "            A = np.array([0, -(lam2), 0, 0, mu2, mu2, 0, 0, 0, 0])\n",
    "            A = A[..., None] \n",
    "\n",
    "            A = np.hstack([psi,A, phi])\n",
    "            b = np.array([1, 0, 0, 0, 0, 0, 0, 0, 0, 0])\n",
    "           # print(A,b)\n",
    "            \"\"\"\n",
    "            steady_pi = np.linalg.solve(np.transpose(A), b)\n",
    "            print(steady_pi)\n",
    "            \"\"\"\n",
    "            steady_pi = np.matmul(b, np.linalg.inv(A)) \n",
    "            #print(steady_pi)\n",
    "            #print(b.shape)\n",
    "\n",
    "            lam_avg = (p/(lam1) + (1-p)/(lam2))\n",
    "\n",
    "\n",
    "            pi_1 = [steady_pi[2], steady_pi[3], steady_pi[4], steady_pi[5]]\n",
    "           # print(\"pi_1 : \", pi_1)\n",
    "\n",
    "            pi_2 = [steady_pi[6], steady_pi[7], steady_pi[8], steady_pi[9]]\n",
    "           # print(\"pi_2 : \", pi_2)\n",
    "\n",
    "            squareI_R = np.matmul((I - R), (I - R)) \n",
    "            W_num_1 = np.matmul(np.linalg.inv(squareI_R), np.ones((4,1), dtype=int))\n",
    "            W_num_1 = np.matmul(R, W_num_1)\n",
    "            #print(W_num_1)\n",
    "\n",
    "            W_num_2 = 2*np.matmul(np.linalg.inv(I - R), np.ones((4,1), dtype=int))\n",
    "            #print(W_num_2)\n",
    "            W_num = np.dot(pi_2, W_num_1 + W_num_2)\n",
    "\n",
    "            W_num = W_num + np.matmul(pi_1, np.ones((4,1), dtype=int))\n",
    "            W = W_num * lam_avg\n",
    "            WTarasov_arr.append(abs(W))\n",
    "            \n",
    "        if len(WTarasov_arr) > 5000 :\n",
    "            break\n",
    "    \n",
    "    \n",
    "        \n",
    "\n",
    "    return WTarasov_arr, lam_CV_arr, mu_CV_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e8134aa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IAT DF             p      lam1      lam2  kurt\n",
      "182  0.681521  0.793532  0.194058    30\n",
      "185  0.752235  3.860255  0.107484    30\n",
      "192  0.706687  1.180466  0.154266    30\n",
      "193  0.693672  0.987764  0.170397    30\n",
      "200  0.711312  1.262325  0.149077    30\n",
      "Lengths for parameter vectors of IAT :  1 1 1\n",
      "For Kurtosis 30\n",
      "ST DF             q       mu1       mu2  kurt\n",
      "168  0.691491  2.395065  0.433735    30\n",
      "171  0.702179  2.772309  0.398841    30\n",
      "178  0.704154  2.848570  0.392992    30\n",
      "192  0.723829  3.885792  0.339391    30\n",
      "195  0.723525  3.863712  0.340177    30\n",
      "Lengths for parameter vectors of IAT :  1 1 1\n",
      "Lengths for parameter vectors of ST :  327 327 327\n",
      "Length of IAT and ST CV , W vectors 327 327 327\n",
      "False\n",
      "False\n",
      "lam_CV_arr 327\n",
      "mu_CV 327\n",
      "lam_CVsq 327\n",
      "mu_CVsq 327\n",
      "Response time 327\n",
      "For Kurtosis 40\n",
      "ST DF              q       mu1       mu2  kurt\n",
      "940   0.805994  2.810914  0.271998    40\n",
      "943   0.823020  6.342222  0.203371    40\n",
      "990   0.818796  4.780493  0.218655    40\n",
      "1004  0.826343  8.741994  0.191786    40\n",
      "1011  0.803073  2.551008  0.287403    40\n",
      "Lengths for parameter vectors of IAT :  1 1 1\n",
      "Lengths for parameter vectors of ST :  161 161 161\n",
      "Length of IAT and ST CV , W vectors 161 161 161\n",
      "False\n",
      "False\n",
      "lam_CV_arr 161\n",
      "mu_CV 161\n",
      "lam_CVsq 161\n",
      "mu_CVsq 161\n",
      "Response time 161\n",
      "For Kurtosis 50\n",
      "ST DF              q        mu1       mu2  kurt\n",
      "2088  0.862624   5.246068  0.164411    50\n",
      "2098  0.869497  33.999611  0.133928    50\n",
      "2116  0.867069  11.041942  0.144259    50\n",
      "2187  0.863568   5.869285  0.159969    50\n",
      "2198  0.851287   2.290175  0.236696    50\n",
      "Lengths for parameter vectors of IAT :  1 1 1\n",
      "Lengths for parameter vectors of ST :  98 98 98\n",
      "Length of IAT and ST CV , W vectors 98 98 98\n",
      "False\n",
      "False\n",
      "lam_CV_arr 98\n",
      "mu_CV 98\n",
      "lam_CVsq 98\n",
      "mu_CVsq 98\n",
      "Response time 98\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "#Using H2/H2/1\n",
    "\n",
    "moment4_arr = [30, 40, 50]\n",
    "\n",
    "#IAT_params_filtered = IAT_params[IAT_params['kurt'] == 1.5]\n",
    "#print('IAT DF', IAT_params_filtered.head())\n",
    "\n",
    "p_arr = [0.7444]\n",
    "lam1_arr = [2.6644]\n",
    "lam2_arr = [0.11508]\n",
    "\n",
    "#IAT_params_filtered = IAT_params[IAT_params['kurt'] == 1.5]\n",
    "print('IAT DF', IAT_params.head())\n",
    "#p_arr = IAT_params_filtered['p'].tolist()\n",
    "#lam1_arr = IAT_params_filtered['lam1'].tolist()\n",
    "#lam2_arr = IAT_params_filtered['lam2'].tolist()\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(8, 8))\n",
    "\n",
    "final_df = pd.DataFrame(columns = ['lam_CV', 'mu_CV', 'lam_CVsq', 'mu_CVsq', 'lam_kurt', 'mu_kurt', 'Response time'])\n",
    "\n",
    "print(\"Lengths for parameter vectors of IAT : \", len(p_arr), len(lam1_arr), len(lam2_arr))\n",
    "\n",
    "for moment4 in moment4_arr : \n",
    "\n",
    "    print('For Kurtosis', moment4)\n",
    "    i = 0\n",
    "    j = 0\n",
    "    #For IAT where mean service time is 5\n",
    "    q_arr= []\n",
    "    mu1_arr = []\n",
    "    mu2_arr = []\n",
    "    #mu_CV_arr = []\n",
    "    \n",
    "\n",
    "    \n",
    "    #lam_CV_arr = []\n",
    "\n",
    "    ST_params_filtered = ST_params[ST_params['kurt'] == moment4]\n",
    "    print('ST DF', ST_params_filtered.head())\n",
    "    q_arr = ST_params_filtered['q'].tolist()\n",
    "    mu1_arr = ST_params_filtered['mu1'].tolist()\n",
    "    mu2_arr = ST_params_filtered['mu2'].tolist()\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    \n",
    "    #ax1 = fig.add_subplot( projection='2d')\n",
    "    \n",
    "    '''\n",
    "\n",
    "    while i < len(p_arr) -1 :\n",
    "        if calculatecoeff_var(lam1_arr[i], lam2_arr[i], p_arr[i]) >=1 :\n",
    "\n",
    "            lam_CV_arr.append(calculatecoeff_var(lam1_arr[i], lam2_arr[i], p_arr[i]))\n",
    "        else :\n",
    "            lam1_arr.remove(lam1_arr[i])\n",
    "            lam2_arr.remove(lam2_arr[i])\n",
    "            p_arr.remove(p_arr[i])\n",
    "        i += 1\n",
    "\n",
    "    while j < len(q_arr) -1 :\n",
    "\n",
    "\n",
    "        if calculatecoeff_var(mu1_arr[j], mu2_arr[j], q_arr[j]) >=1 :\n",
    "\n",
    "            mu_CV_arr.append(calculatecoeff_var(mu1_arr[j], mu2_arr[j], q_arr[j]))\n",
    "        else :\n",
    "            mu1_arr.remove(mu1_arr[j])\n",
    "            mu2_arr.remove(mu2_arr[j])\n",
    "            q_arr.remove(q_arr[j])\n",
    "        j += 1\n",
    "\n",
    "\n",
    "    \n",
    "   \n",
    "    if len(p_arr) < len(q_arr) :\n",
    "        q_arr = q_arr[:len(p_arr)] \n",
    "        mu1_arr = mu1_arr[:len(p_arr)]\n",
    "        mu2_arr = mu2_arr[:len(p_arr)]\n",
    "        mu_CV_arr = mu_CV_arr [:len(p_arr)]\n",
    "\n",
    "    else :\n",
    "        p_arr = p_arr[:len(q_arr)]\n",
    "        lam1_arr = lam1_arr[:len(q_arr)]\n",
    "        lam2_arr = lam2_arr[:len(q_arr)]\n",
    "        lam_CV_arr = lam_CV_arr[:len(q_arr)]\n",
    "   \n",
    "    '''\n",
    "    W_exact, lam_CV_arr, mu_CV_arr = Tarasov(p_arr, lam1_arr, lam2_arr, q_arr, mu1_arr, mu2_arr)\n",
    "    \n",
    "    print(\"Lengths for parameter vectors of IAT : \", len(p_arr), len(lam1_arr), len(lam2_arr))\n",
    "    print(\"Lengths for parameter vectors of ST : \", len(q_arr), len(mu1_arr), len(mu2_arr))\n",
    "\n",
    "    print('Length of IAT and ST CV , W vectors', len(lam_CV_arr), len(mu_CV_arr), len(W_exact))\n",
    "\n",
    "\n",
    "    #print(mu_coeff_var_arr)\n",
    "    \n",
    "    lam_CV_arr = np.array(lam_CV_arr) * 1.5\n",
    "    lam_CV_arr_sq = np.square(lam_CV_arr)\n",
    "    mu_CV_arr = np.array(mu_CV_arr) * 1.5\n",
    "    mu_CV_arr_sq = np.square(mu_CV_arr)\n",
    "    #W_exact.pop()\n",
    "    print(any(num1 < 0 for num1 in W_exact))\n",
    "    print(any(num2 < 0 for num2 in W_exact))\n",
    "    \n",
    "    #Stacking and storing them into a csv\n",
    "    \n",
    "    \n",
    "    \n",
    "    print('lam_CV_arr',len(lam_CV_arr))\n",
    "    print('mu_CV', len(mu_CV_arr))\n",
    "    print('lam_CVsq', len(lam_CV_arr_sq))\n",
    "    print('mu_CVsq', len(mu_CV_arr_sq))\n",
    "   \n",
    "     \n",
    "    print('Response time', len(W_exact))\n",
    "    \n",
    "    \n",
    "\n",
    "    if moment4 == 20 :\n",
    "        \n",
    "        store_df = pd.DataFrame({'lam_CV' : lam_CV_arr,\n",
    "                            'mu_CV' : mu_CV_arr,\n",
    "                            'lam_CVsq' : lam_CV_arr_sq,\n",
    "                            'mu_CVsq' : mu_CV_arr_sq,\n",
    "                            'lam_kurt' : [30] * len(W_exact),\n",
    "                            'mu_kurt' : [20] * len(W_exact),\n",
    "                            'Response time' : W_exact}\n",
    "                            )\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'red', label = 'Kurta = 30, Kurts = 20')\n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'red', label = 'Kurta = 1.5, Kurts = 1.5')\n",
    "        plt.xlabel('CV sq of ST curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "       \n",
    "    elif moment4 == 30 :\n",
    "        store_df = pd.DataFrame({'lam_CV' : lam_CV_arr,\n",
    "                            'mu_CV' : mu_CV_arr,\n",
    "                            'lam_CVsq' : lam_CV_arr_sq,\n",
    "                            'mu_CVsq' : mu_CV_arr_sq,\n",
    "                            'lam_kurt' : [30] * len(W_exact),\n",
    "                            'mu_kurt' : [50] * len(W_exact),\n",
    "                            'Response time' : W_exact}\n",
    "                            )\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'yellow', label = 'Kurta = 30, Kurts = 50')\n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'blue', label = 'Kurta = 1.5, Kurts = 2.5')\n",
    "        plt.xlabel('CV sq of ST curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "       \n",
    "    elif moment4 == 40 :\n",
    "        #W_exact = (np.array(W_exact)) * + 10\n",
    "        \n",
    "        store_df = pd.DataFrame({'lam_CV' : lam_CV_arr,\n",
    "                            'mu_CV' : mu_CV_arr,\n",
    "                            'lam_CVsq' : lam_CV_arr_sq,\n",
    "                            'mu_CVsq' : mu_CV_arr_sq,\n",
    "                            'lam_kurt' : [30] * len(W_exact),\n",
    "                            'mu_kurt' : [40] * len(W_exact),\n",
    "                            'Response time' : W_exact}\n",
    "                            )\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'green', label = 'Kurta = 30, Kurts = 40')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'green', label = 'Kurta = 1.5, Kurts = 20')\n",
    "        plt.xlabel('CV sq of ST curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "        \n",
    "    elif moment4 == 50 :\n",
    "        #W_exact = (np.array(W_exact)) *   10\n",
    "        \n",
    "        store_df = pd.DataFrame({'lam_CV' : lam_CV_arr,\n",
    "                            'mu_CV' : mu_CV_arr,\n",
    "                            'lam_CVsq' : lam_CV_arr_sq,\n",
    "                            'mu_CVsq' : mu_CV_arr_sq,\n",
    "                            'lam_kurt' : [30] * len(W_exact),\n",
    "                            'mu_kurt' : [30] * len(W_exact),\n",
    "                            'Response time' : W_exact}\n",
    "                            )\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'blue', label = 'Kurta = 30, Kurts = 30')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'black', label = 'Kurta = 1.5, Kurts = 25')\n",
    "        plt.xlabel('CV sq of ST curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "        \n",
    "    \n",
    "        \n",
    "       \n",
    "    plt.legend()\n",
    "    plt.xlim(0, 25)\n",
    "    plt.ylim(2, 10)\n",
    "    final_df = final_df.append(store_df, ignore_index = True)\n",
    "\n",
    "'''\n",
    "\n",
    "    ax1.set_xlabel('CV of IAT curve')\n",
    "    ax1.set_ylabel('CV of ST curve')\n",
    "    ax1.set_zlabel('RT for H2/H2/1 as per Tarasov for given skewness of IAT and ST dists ')\n",
    "    #ax1.set_xlim(0, 70)\n",
    "    #ax1.set_ylim(0,70)\n",
    "    ax1.set_zlim(0,200)\n",
    "'''\n",
    "\n",
    "\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "final_df = final_df.append(store_df, ignore_index = True)\n",
    "final_df.to_csv('DetailsH2_H2_1_fixedmeanKurt_30Kurta_large(2servers).csv', index= False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "df79f61a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IAT DF             p      lam1      lam2  kurt\n",
      "182  0.681521  0.793532  0.194058    30\n",
      "185  0.752235  3.860255  0.107484    30\n",
      "192  0.706687  1.180466  0.154266    30\n",
      "193  0.693672  0.987764  0.170397    30\n",
      "200  0.711312  1.262325  0.149077    30\n",
      "Lengths for parameter vectors of IAT :  1 1 1\n",
      "For Kurtosis 30\n",
      "ST DF             q       mu1       mu2  kurt\n",
      "168  0.691491  2.395065  0.433735    30\n",
      "171  0.702179  2.772309  0.398841    30\n",
      "178  0.704154  2.848570  0.392992    30\n",
      "192  0.723829  3.885792  0.339391    30\n",
      "195  0.723525  3.863712  0.340177    30\n",
      "Lengths for parameter vectors of IAT :  1 1 1\n",
      "Lengths for parameter vectors of ST :  327 327 327\n",
      "Length of IAT and ST CV , W vectors 327 327 327\n",
      "False\n",
      "False\n",
      "lam_CV_arr 327\n",
      "mu_CV 327\n",
      "lam_CVsq 327\n",
      "mu_CVsq 327\n",
      "Response time 327\n",
      "For Kurtosis 40\n",
      "ST DF              q       mu1       mu2  kurt\n",
      "940   0.805994  2.810914  0.271998    40\n",
      "943   0.823020  6.342222  0.203371    40\n",
      "990   0.818796  4.780493  0.218655    40\n",
      "1004  0.826343  8.741994  0.191786    40\n",
      "1011  0.803073  2.551008  0.287403    40\n",
      "Lengths for parameter vectors of IAT :  1 1 1\n",
      "Lengths for parameter vectors of ST :  161 161 161\n",
      "Length of IAT and ST CV , W vectors 161 161 161\n",
      "False\n",
      "False\n",
      "lam_CV_arr 161\n",
      "mu_CV 161\n",
      "lam_CVsq 161\n",
      "mu_CVsq 161\n",
      "Response time 161\n",
      "For Kurtosis 50\n",
      "ST DF              q        mu1       mu2  kurt\n",
      "2088  0.862624   5.246068  0.164411    50\n",
      "2098  0.869497  33.999611  0.133928    50\n",
      "2116  0.867069  11.041942  0.144259    50\n",
      "2187  0.863568   5.869285  0.159969    50\n",
      "2198  0.851287   2.290175  0.236696    50\n",
      "Lengths for parameter vectors of IAT :  1 1 1\n",
      "Lengths for parameter vectors of ST :  98 98 98\n",
      "Length of IAT and ST CV , W vectors 98 98 98\n",
      "False\n",
      "False\n",
      "lam_CV_arr 98\n",
      "mu_CV 98\n",
      "lam_CVsq 98\n",
      "mu_CVsq 98\n",
      "Response time 98\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "#Using H2/H2/1\n",
    "\n",
    "moment4_arr = [30, 40, 50]\n",
    "\n",
    "#IAT_params_filtered = IAT_params[IAT_params['kurt'] == 1.5]\n",
    "#print('IAT DF', IAT_params_filtered.head())\n",
    "\n",
    "p_arr = [0.80366]\n",
    "lam1_arr = [1.04062]\n",
    "lam2_arr = [0.11364]\n",
    "\n",
    "#IAT_params_filtered = IAT_params[IAT_params['kurt'] == 1.5]\n",
    "print('IAT DF', IAT_params.head())\n",
    "#p_arr = IAT_params_filtered['p'].tolist()\n",
    "#lam1_arr = IAT_params_filtered['lam1'].tolist()\n",
    "#lam2_arr = IAT_params_filtered['lam2'].tolist()\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(8, 8))\n",
    "\n",
    "final_df = pd.DataFrame(columns = ['lam_CV', 'mu_CV', 'lam_CVsq', 'mu_CVsq', 'lam_kurt', 'mu_kurt', 'Response time'])\n",
    "\n",
    "print(\"Lengths for parameter vectors of IAT : \", len(p_arr), len(lam1_arr), len(lam2_arr))\n",
    "\n",
    "for moment4 in moment4_arr : \n",
    "\n",
    "    print('For Kurtosis', moment4)\n",
    "    i = 0\n",
    "    j = 0\n",
    "    #For IAT where mean service time is 5\n",
    "    q_arr= []\n",
    "    mu1_arr = []\n",
    "    mu2_arr = []\n",
    "    #mu_CV_arr = []\n",
    "    \n",
    "\n",
    "    \n",
    "    #lam_CV_arr = []\n",
    "\n",
    "    ST_params_filtered = ST_params[ST_params['kurt'] == moment4]\n",
    "    print('ST DF', ST_params_filtered.head())\n",
    "    q_arr = ST_params_filtered['q'].tolist()\n",
    "    mu1_arr = ST_params_filtered['mu1'].tolist()\n",
    "    mu2_arr = ST_params_filtered['mu2'].tolist()\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    \n",
    "    #ax1 = fig.add_subplot( projection='2d')\n",
    "    \n",
    "    '''\n",
    "\n",
    "    while i < len(p_arr) -1 :\n",
    "        if calculatecoeff_var(lam1_arr[i], lam2_arr[i], p_arr[i]) >=1 :\n",
    "\n",
    "            lam_CV_arr.append(calculatecoeff_var(lam1_arr[i], lam2_arr[i], p_arr[i]))\n",
    "        else :\n",
    "            lam1_arr.remove(lam1_arr[i])\n",
    "            lam2_arr.remove(lam2_arr[i])\n",
    "            p_arr.remove(p_arr[i])\n",
    "        i += 1\n",
    "\n",
    "    while j < len(q_arr) -1 :\n",
    "\n",
    "\n",
    "        if calculatecoeff_var(mu1_arr[j], mu2_arr[j], q_arr[j]) >=1 :\n",
    "\n",
    "            mu_CV_arr.append(calculatecoeff_var(mu1_arr[j], mu2_arr[j], q_arr[j]))\n",
    "        else :\n",
    "            mu1_arr.remove(mu1_arr[j])\n",
    "            mu2_arr.remove(mu2_arr[j])\n",
    "            q_arr.remove(q_arr[j])\n",
    "        j += 1\n",
    "\n",
    "\n",
    "    \n",
    "   \n",
    "    if len(p_arr) < len(q_arr) :\n",
    "        q_arr = q_arr[:len(p_arr)] \n",
    "        mu1_arr = mu1_arr[:len(p_arr)]\n",
    "        mu2_arr = mu2_arr[:len(p_arr)]\n",
    "        mu_CV_arr = mu_CV_arr [:len(p_arr)]\n",
    "\n",
    "    else :\n",
    "        p_arr = p_arr[:len(q_arr)]\n",
    "        lam1_arr = lam1_arr[:len(q_arr)]\n",
    "        lam2_arr = lam2_arr[:len(q_arr)]\n",
    "        lam_CV_arr = lam_CV_arr[:len(q_arr)]\n",
    "   \n",
    "    '''\n",
    "    W_exact, lam_CV_arr, mu_CV_arr = Tarasov(p_arr, lam1_arr, lam2_arr, q_arr, mu1_arr, mu2_arr)\n",
    "    \n",
    "    print(\"Lengths for parameter vectors of IAT : \", len(p_arr), len(lam1_arr), len(lam2_arr))\n",
    "    print(\"Lengths for parameter vectors of ST : \", len(q_arr), len(mu1_arr), len(mu2_arr))\n",
    "\n",
    "    print('Length of IAT and ST CV , W vectors', len(lam_CV_arr), len(mu_CV_arr), len(W_exact))\n",
    "\n",
    "\n",
    "    #print(mu_coeff_var_arr)\n",
    "    \n",
    "    lam_CV_arr = np.array(lam_CV_arr) * 1.5\n",
    "    lam_CV_arr_sq = np.square(lam_CV_arr)\n",
    "    mu_CV_arr = np.array(mu_CV_arr) * 1.5\n",
    "    mu_CV_arr_sq = np.square(mu_CV_arr)\n",
    "    #W_exact.pop()\n",
    "    print(any(num1 < 0 for num1 in W_exact))\n",
    "    print(any(num2 < 0 for num2 in W_exact))\n",
    "    \n",
    "    #Stacking and storing them into a csv\n",
    "    \n",
    "    \n",
    "    \n",
    "    print('lam_CV_arr',len(lam_CV_arr))\n",
    "    print('mu_CV', len(mu_CV_arr))\n",
    "    print('lam_CVsq', len(lam_CV_arr_sq))\n",
    "    print('mu_CVsq', len(mu_CV_arr_sq))\n",
    "   \n",
    "     \n",
    "    print('Response time', len(W_exact))\n",
    "    \n",
    "    store_df = pd.DataFrame({'lam_CV' : lam_CV_arr,\n",
    "                            'mu_CV' : mu_CV_arr,\n",
    "                            'lam_CVsq' : lam_CV_arr_sq,\n",
    "                            'mu_CVsq' : mu_CV_arr_sq,\n",
    "                            'lam_kurt' : [30] * len(W_exact),\n",
    "                            'mu_kurt' : [moment4] * len(W_exact),\n",
    "                            'Response time' : W_exact}\n",
    "                            )\n",
    "\n",
    "    if moment4 == 20 :\n",
    "        W_exact = (np.array(W_exact)) *   2\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'red', label = 'Kurta = 40, Kurts = 20')\n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'red', label = 'Kurta = 1.5, Kurts = 1.5')\n",
    "        plt.xlabel('CV sq of ST curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "       \n",
    "    elif moment4 == 30 :\n",
    "        W_exact = (np.array(W_exact)) *   2\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'yellow', label = 'Kurta = 40, Kurts = 50')\n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'blue', label = 'Kurta = 1.5, Kurts = 2.5')\n",
    "        plt.xlabel('CV sq of ST curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "       \n",
    "    elif moment4 == 40 :\n",
    "        W_exact = (np.array(W_exact)) *   2\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'green', label = 'Kurta = 40, Kurts = 40')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'green', label = 'Kurta = 1.5, Kurts = 20')\n",
    "        plt.xlabel('CV sq of ST curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "        \n",
    "    elif moment4 == 50 :\n",
    "        W_exact = (np.array(W_exact)) *   2\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'blue', label = 'Kurta = 40, Kurts = 30')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'black', label = 'Kurta = 1.5, Kurts = 25')\n",
    "        plt.xlabel('CV sq of ST curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "        \n",
    "    \n",
    "        \n",
    "       \n",
    "    plt.legend()\n",
    "    plt.xlim(0, 25)\n",
    "    plt.ylim(2, 10)\n",
    "    final_df = final_df.append(store_df, ignore_index = True)\n",
    "\n",
    "'''\n",
    "\n",
    "    ax1.set_xlabel('CV of IAT curve')\n",
    "    ax1.set_ylabel('CV of ST curve')\n",
    "    ax1.set_zlabel('RT for H2/H2/1 as per Tarasov for given skewness of IAT and ST dists ')\n",
    "    #ax1.set_xlim(0, 70)\n",
    "    #ax1.set_ylim(0,70)\n",
    "    ax1.set_zlim(0,200)\n",
    "'''\n",
    "\n",
    "\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "final_df = final_df.append(store_df, ignore_index = True)\n",
    "final_df.to_csv('DetailsH2_H2_1_fixedmeanKurt_40Kurta_large.csv', index= False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29c85405",
   "metadata": {},
   "source": [
    "# For Kurts = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "60b83448",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ST DF              q        mu1       mu2  kurt\n",
      "2088  0.862624   5.246068  0.164411    50\n",
      "2098  0.869497  33.999611  0.133928    50\n",
      "2116  0.867069  11.041942  0.144259    50\n",
      "2187  0.863568   5.869285  0.159969    50\n",
      "2198  0.851287   2.290175  0.236696    50\n",
      "Lengths for parameter vectors of ST :  1 1 1\n",
      "For Kurtosis 30\n",
      "IAT DF             p      lam1      lam2  kurt\n",
      "182  0.681521  0.793532  0.194058    30\n",
      "185  0.752235  3.860255  0.107484    30\n",
      "192  0.706687  1.180466  0.154266    30\n",
      "193  0.693672  0.987764  0.170397    30\n",
      "200  0.711312  1.262325  0.149077    30\n",
      "Lengths for parameter vectors of IAT :  76 76 76\n",
      "Lengths for parameter vectors of ST :  1 1 1\n",
      "Length of IAT and ST CV , W vectors 76 76 76\n",
      "False\n",
      "False\n",
      "lam_CV_arr 76\n",
      "mu_CV 76\n",
      "lam_CVsq 76\n",
      "mu_CVsq 76\n",
      "Response time 76\n",
      "For Kurtosis 40\n",
      "IAT DF             p      lam1      lam2  kurt\n",
      "740  0.811040  1.342771  0.099663    40\n",
      "756  0.803661  1.040625  0.113641    40\n",
      "766  0.822230  2.387058  0.082471    40\n",
      "774  0.806203  1.132259  0.108389    40\n",
      "783  0.812984  1.449250  0.096448    40\n",
      "Lengths for parameter vectors of IAT :  38 38 38\n",
      "Lengths for parameter vectors of ST :  1 1 1\n",
      "Length of IAT and ST CV , W vectors 38 38 38\n",
      "False\n",
      "False\n",
      "lam_CV_arr 38\n",
      "mu_CV 38\n",
      "lam_CVsq 38\n",
      "mu_CVsq 38\n",
      "Response time 38\n",
      "For Kurtosis 50\n",
      "IAT DF              p      lam1      lam2  kurt\n",
      "1447  0.866250  3.635543  0.059136    50\n",
      "1454  0.865011  2.888298  0.061345    50\n",
      "1468  0.863660  2.375833  0.063815    50\n",
      "1497  0.857975  1.399670  0.075264    50\n",
      "1509  0.863561  2.345629  0.064001    50\n",
      "Lengths for parameter vectors of IAT :  23 23 23\n",
      "Lengths for parameter vectors of ST :  1 1 1\n",
      "Length of IAT and ST CV , W vectors 23 23 23\n",
      "False\n",
      "False\n",
      "lam_CV_arr 23\n",
      "mu_CV 23\n",
      "lam_CVsq 23\n",
      "mu_CVsq 23\n",
      "Response time 23\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "#Using H2/H2/1\n",
    "\n",
    "moment4_arr = [30, 40, 50]\n",
    "\n",
    "#IAT_params_filtered = IAT_params[IAT_params['kurt'] == 1.5]\n",
    "#print('IAT DF', IAT_params_filtered.head())\n",
    "\n",
    "q_arr = [0.6867]\n",
    "mu1_arr = [2.23038]\n",
    "mu2_arr = [0.4525]\n",
    "\n",
    "#ST_params_filtered = ST_params[ST_params['kurt'] == 1.5]\n",
    "print('ST DF', ST_params_filtered.head())\n",
    "#q_arr = ST_params_filtered['q'].tolist()\n",
    "#mu1_arr = ST_params_filtered['mu1'].tolist()\n",
    "#mu2_arr = ST_params_filtered['mu2'].tolist()\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(8, 8))\n",
    "\n",
    "final_df = pd.DataFrame(columns = ['lam_CV', 'mu_CV', 'lam_CVsq', 'mu_CVsq', 'lam_kurt', 'mu_kurt', 'Response time'])\n",
    "\n",
    "print(\"Lengths for parameter vectors of ST : \", len(q_arr), len(mu1_arr), len(mu2_arr))\n",
    "\n",
    "for moment4 in moment4_arr : \n",
    "\n",
    "    print('For Kurtosis', moment4)\n",
    "    i = 0\n",
    "    j = 0\n",
    "    #For IAT where mean service time is 5\n",
    "    p_arr= []\n",
    "    lam1_arr = []\n",
    "    lam2_arr = []\n",
    "    #mu_CV_arr = []\n",
    "    \n",
    "\n",
    "    \n",
    "    #lam_CV_arr = []\n",
    "\n",
    "    IAT_params_filtered = IAT_params[IAT_params['kurt'] == moment4]\n",
    "    print('IAT DF', IAT_params_filtered.head())\n",
    "    p_arr = IAT_params_filtered['p'].tolist()\n",
    "    lam1_arr = IAT_params_filtered['lam1'].tolist()\n",
    "    lam2_arr = IAT_params_filtered['lam2'].tolist()\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    \n",
    "    #ax1 = fig.add_subplot( projection='2d')\n",
    "    \n",
    "    '''\n",
    "\n",
    "    while i < len(p_arr) -1 :\n",
    "        if calculatecoeff_var(lam1_arr[i], lam2_arr[i], p_arr[i]) >=1 :\n",
    "\n",
    "            lam_CV_arr.append(calculatecoeff_var(lam1_arr[i], lam2_arr[i], p_arr[i]))\n",
    "        else :\n",
    "            lam1_arr.remove(lam1_arr[i])\n",
    "            lam2_arr.remove(lam2_arr[i])\n",
    "            p_arr.remove(p_arr[i])\n",
    "        i += 1\n",
    "\n",
    "    while j < len(q_arr) -1 :\n",
    "\n",
    "\n",
    "        if calculatecoeff_var(mu1_arr[j], mu2_arr[j], q_arr[j]) >=1 :\n",
    "\n",
    "            mu_CV_arr.append(calculatecoeff_var(mu1_arr[j], mu2_arr[j], q_arr[j]))\n",
    "        else :\n",
    "            mu1_arr.remove(mu1_arr[j])\n",
    "            mu2_arr.remove(mu2_arr[j])\n",
    "            q_arr.remove(q_arr[j])\n",
    "        j += 1\n",
    "\n",
    "\n",
    "    \n",
    "   \n",
    "    if len(p_arr) < len(q_arr) :\n",
    "        q_arr = q_arr[:len(p_arr)] \n",
    "        mu1_arr = mu1_arr[:len(p_arr)]\n",
    "        mu2_arr = mu2_arr[:len(p_arr)]\n",
    "        mu_CV_arr = mu_CV_arr [:len(p_arr)]\n",
    "\n",
    "    else :\n",
    "        p_arr = p_arr[:len(q_arr)]\n",
    "        lam1_arr = lam1_arr[:len(q_arr)]\n",
    "        lam2_arr = lam2_arr[:len(q_arr)]\n",
    "        lam_CV_arr = lam_CV_arr[:len(q_arr)]\n",
    "   \n",
    "    '''\n",
    "    W_exact, lam_CV_arr, mu_CV_arr = Tarasov(p_arr, lam1_arr, lam2_arr, q_arr, mu1_arr, mu2_arr)\n",
    "    \n",
    "    print(\"Lengths for parameter vectors of IAT : \", len(p_arr), len(lam1_arr), len(lam2_arr))\n",
    "    print(\"Lengths for parameter vectors of ST : \", len(q_arr), len(mu1_arr), len(mu2_arr))\n",
    "\n",
    "    print('Length of IAT and ST CV , W vectors', len(lam_CV_arr), len(mu_CV_arr), len(W_exact))\n",
    "\n",
    "\n",
    "    #print(mu_coeff_var_arr)\n",
    "    W_exact, lam_CV_arr, mu_CV_arr = Tarasov(p_arr, lam1_arr, lam2_arr, q_arr, mu1_arr, mu2_arr)\n",
    "    lam_CV_arr = np.array(lam_CV_arr) * 1.5\n",
    "    lam_CV_arr_sq = np.square(lam_CV_arr)\n",
    "    mu_CV_arr = np.array(mu_CV_arr) * 1.5\n",
    "    mu_CV_arr_sq = np.square(mu_CV_arr)\n",
    "    #W_exact.pop()\n",
    "    print(any(num1 < 0 for num1 in W_exact))\n",
    "    print(any(num2 < 0 for num2 in W_exact))\n",
    "    \n",
    "    #Stacking and storing them into a csv\n",
    "    \n",
    "    \n",
    "    \n",
    "    print('lam_CV_arr',len(lam_CV_arr))\n",
    "    print('mu_CV', len(mu_CV_arr))\n",
    "    print('lam_CVsq', len(lam_CV_arr_sq))\n",
    "    print('mu_CVsq', len(mu_CV_arr_sq))\n",
    "   \n",
    "    \n",
    "    print('Response time', len(W_exact))\n",
    "    \n",
    "    store_df = pd.DataFrame({'lam_CV' : lam_CV_arr,\n",
    "                            'mu_CV' : mu_CV_arr,\n",
    "                            'lam_CVsq' : lam_CV_arr_sq,\n",
    "                            'mu_CVsq' : mu_CV_arr_sq,\n",
    "                            'lam_kurt' : [moment4] * len(W_exact),\n",
    "                            'mu_kurt' : [30] * len(W_exact),\n",
    "                            'Response time' : W_exact}\n",
    "                            )\n",
    "\n",
    "    if moment4 == 20 :\n",
    "        W_exact = (np.array(W_exact)) *   1.75\n",
    "        plt.scatter(lam_CV_arr_sq, W_exact, color = 'red', label = 'Kurta = 20, Kurts = 30')\n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'red', label = 'Kurta = 1.5, Kurts = 1.5')\n",
    "        plt.xlabel('CV sq of IAT curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "       \n",
    "    elif moment4 == 30 :\n",
    "        W_exact = (np.array(W_exact)) *   1.75\n",
    "        plt.scatter(lam_CV_arr_sq, W_exact, color = 'yellow', label = 'Kurta = 50, Kurts = 30')\n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'blue', label = 'Kurta = 1.5, Kurts = 2.5')\n",
    "        plt.xlabel('CV sq of IAT curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "       \n",
    "    elif moment4 == 40 :\n",
    "        W_exact = (np.array(W_exact)) *   1.75\n",
    "        plt.scatter(lam_CV_arr_sq, W_exact, color = 'green', label = 'Kurta = 40, Kurts = 30')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'green', label = 'Kurta = 1.5, Kurts = 20')\n",
    "        plt.xlabel('CV sq of IAT curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "        \n",
    "    elif moment4 == 50 :\n",
    "        W_exact = (np.array(W_exact)) *   1.75\n",
    "        plt.scatter(lam_CV_arr_sq, W_exact, color = 'blue', label = 'Kurta = 30, Kurts = 30')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'black', label = 'Kurta = 1.5, Kurts = 25')\n",
    "        plt.xlabel('CV sq of IAT curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "        \n",
    "    \n",
    "        \n",
    "       \n",
    "    plt.legend()\n",
    "    plt.xlim(0, 25)\n",
    "    plt.ylim(0, 15)\n",
    "    final_df = final_df.append(store_df, ignore_index = True)\n",
    "\n",
    "'''\n",
    "\n",
    "    ax1.set_xlabel('CV of IAT curve')\n",
    "    ax1.set_ylabel('CV of ST curve')\n",
    "    ax1.set_zlabel('RT for H2/H2/1 as per Tarasov for given skewness of IAT and ST dists ')\n",
    "    #ax1.set_xlim(0, 70)\n",
    "    #ax1.set_ylim(0,70)\n",
    "    ax1.set_zlim(0,200)\n",
    "'''\n",
    "\n",
    "\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "final_df = final_df.append(store_df, ignore_index = True)\n",
    "final_df.to_csv('DetailsH2_H2_1_fixedmeanKurt_30Kurts(2servers).csv', index= True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d0c87dc",
   "metadata": {},
   "source": [
    "# For Kurts = 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "f2e353b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ST DF             q       mu1       mu2  kurt\n",
      "168  0.691491  2.395065  0.433735    30\n",
      "171  0.702179  2.772309  0.398841    30\n",
      "178  0.704154  2.848570  0.392992    30\n",
      "192  0.723829  3.885792  0.339391    30\n",
      "195  0.723525  3.863712  0.340177    30\n",
      "Lengths for parameter vectors of ST :  1 1 1\n",
      "For Kurtosis 30\n",
      "IAT DF             p      lam1      lam2  kurt\n",
      "182  0.681521  0.793532  0.194058    30\n",
      "185  0.752235  3.860255  0.107484    30\n",
      "192  0.706687  1.180466  0.154266    30\n",
      "193  0.693672  0.987764  0.170397    30\n",
      "200  0.711312  1.262325  0.149077    30\n",
      "Lengths for parameter vectors of IAT :  76 76 76\n",
      "Lengths for parameter vectors of ST :  1 1 1\n",
      "Length of IAT and ST CV , W vectors 76 76 76\n",
      "False\n",
      "False\n",
      "lam_CV_arr 76\n",
      "mu_CV 76\n",
      "lam_CVsq 76\n",
      "mu_CVsq 76\n",
      "Response time 76\n",
      "For Kurtosis 40\n",
      "IAT DF             p      lam1      lam2  kurt\n",
      "740  0.811040  1.342771  0.099663    40\n",
      "756  0.803661  1.040625  0.113641    40\n",
      "766  0.822230  2.387058  0.082471    40\n",
      "774  0.806203  1.132259  0.108389    40\n",
      "783  0.812984  1.449250  0.096448    40\n",
      "Lengths for parameter vectors of IAT :  38 38 38\n",
      "Lengths for parameter vectors of ST :  1 1 1\n",
      "Length of IAT and ST CV , W vectors 38 38 38\n",
      "False\n",
      "False\n",
      "lam_CV_arr 38\n",
      "mu_CV 38\n",
      "lam_CVsq 38\n",
      "mu_CVsq 38\n",
      "Response time 38\n",
      "For Kurtosis 50\n",
      "IAT DF              p      lam1      lam2  kurt\n",
      "1447  0.866250  3.635543  0.059136    50\n",
      "1454  0.865011  2.888298  0.061345    50\n",
      "1468  0.863660  2.375833  0.063815    50\n",
      "1497  0.857975  1.399670  0.075264    50\n",
      "1509  0.863561  2.345629  0.064001    50\n",
      "Lengths for parameter vectors of IAT :  23 23 23\n",
      "Lengths for parameter vectors of ST :  1 1 1\n",
      "Length of IAT and ST CV , W vectors 23 23 23\n",
      "False\n",
      "False\n",
      "lam_CV_arr 23\n",
      "mu_CV 23\n",
      "lam_CVsq 23\n",
      "mu_CVsq 23\n",
      "Response time 23\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "\n",
    "#Using H2/H2/1\n",
    "\n",
    "moment4_arr = [30, 40, 50]\n",
    "\n",
    "#IAT_params_filtered = IAT_params[IAT_params['kurt'] == 1.5]\n",
    "#print('IAT DF', IAT_params_filtered.head())\n",
    "\n",
    "q_arr = [0.8230]\n",
    "mu1_arr = [6.34222]\n",
    "mu2_arr = [0.2033]\n",
    "\n",
    "#ST_params_filtered = ST_params[ST_params['kurt'] == 1.5]\n",
    "print('ST DF', ST_params_filtered.head())\n",
    "#q_arr = ST_params_filtered['q'].tolist()\n",
    "#mu1_arr = ST_params_filtered['mu1'].tolist()\n",
    "#mu2_arr = ST_params_filtered['mu2'].tolist()\n",
    "\n",
    "\n",
    "fig = plt.figure(figsize=(8, 8))\n",
    "\n",
    "final_df = pd.DataFrame(columns = ['lam_CV', 'mu_CV', 'lam_CVsq', 'mu_CVsq', 'lam_kurt', 'mu_kurt', 'Response time'])\n",
    "\n",
    "print(\"Lengths for parameter vectors of ST : \", len(q_arr), len(mu1_arr), len(mu2_arr))\n",
    "\n",
    "for moment4 in moment4_arr : \n",
    "\n",
    "    print('For Kurtosis', moment4)\n",
    "    i = 0\n",
    "    j = 0\n",
    "    #For IAT where mean service time is 5\n",
    "    p_arr= []\n",
    "    lam1_arr = []\n",
    "    lam2_arr = []\n",
    "    #mu_CV_arr = []\n",
    "    \n",
    "\n",
    "    \n",
    "    #lam_CV_arr = []\n",
    "\n",
    "    IAT_params_filtered = IAT_params[IAT_params['kurt'] == moment4]\n",
    "    print('IAT DF', IAT_params_filtered.head())\n",
    "    p_arr = IAT_params_filtered['p'].tolist()\n",
    "    lam1_arr = IAT_params_filtered['lam1'].tolist()\n",
    "    lam2_arr = IAT_params_filtered['lam2'].tolist()\n",
    "\n",
    "\n",
    "    \n",
    "\n",
    "    \n",
    "    #ax1 = fig.add_subplot( projection='2d')\n",
    "    \n",
    "    '''\n",
    "\n",
    "    while i < len(p_arr) -1 :\n",
    "        if calculatecoeff_var(lam1_arr[i], lam2_arr[i], p_arr[i]) >=1 :\n",
    "\n",
    "            lam_CV_arr.append(calculatecoeff_var(lam1_arr[i], lam2_arr[i], p_arr[i]))\n",
    "        else :\n",
    "            lam1_arr.remove(lam1_arr[i])\n",
    "            lam2_arr.remove(lam2_arr[i])\n",
    "            p_arr.remove(p_arr[i])\n",
    "        i += 1\n",
    "\n",
    "    while j < len(q_arr) -1 :\n",
    "\n",
    "\n",
    "        if calculatecoeff_var(mu1_arr[j], mu2_arr[j], q_arr[j]) >=1 :\n",
    "\n",
    "            mu_CV_arr.append(calculatecoeff_var(mu1_arr[j], mu2_arr[j], q_arr[j]))\n",
    "        else :\n",
    "            mu1_arr.remove(mu1_arr[j])\n",
    "            mu2_arr.remove(mu2_arr[j])\n",
    "            q_arr.remove(q_arr[j])\n",
    "        j += 1\n",
    "\n",
    "\n",
    "    \n",
    "   \n",
    "    if len(p_arr) < len(q_arr) :\n",
    "        q_arr = q_arr[:len(p_arr)] \n",
    "        mu1_arr = mu1_arr[:len(p_arr)]\n",
    "        mu2_arr = mu2_arr[:len(p_arr)]\n",
    "        mu_CV_arr = mu_CV_arr [:len(p_arr)]\n",
    "\n",
    "    else :\n",
    "        p_arr = p_arr[:len(q_arr)]\n",
    "        lam1_arr = lam1_arr[:len(q_arr)]\n",
    "        lam2_arr = lam2_arr[:len(q_arr)]\n",
    "        lam_CV_arr = lam_CV_arr[:len(q_arr)]\n",
    "   \n",
    "    '''\n",
    "    W_exact, lam_CV_arr, mu_CV_arr = Tarasov(p_arr, lam1_arr, lam2_arr, q_arr, mu1_arr, mu2_arr)\n",
    "    \n",
    "    print(\"Lengths for parameter vectors of IAT : \", len(p_arr), len(lam1_arr), len(lam2_arr))\n",
    "    print(\"Lengths for parameter vectors of ST : \", len(q_arr), len(mu1_arr), len(mu2_arr))\n",
    "\n",
    "    print('Length of IAT and ST CV , W vectors', len(lam_CV_arr), len(mu_CV_arr), len(W_exact))\n",
    "\n",
    "\n",
    "    #print(mu_coeff_var_arr)\n",
    "    W_exact, lam_CV_arr, mu_CV_arr = Tarasov(p_arr, lam1_arr, lam2_arr, q_arr, mu1_arr, mu2_arr)\n",
    "    lam_CV_arr = np.array(lam_CV_arr) * 1.5\n",
    "    lam_CV_arr_sq = np.square(lam_CV_arr)\n",
    "    mu_CV_arr = np.array(mu_CV_arr) * 1.5\n",
    "    mu_CV_arr_sq = np.square(mu_CV_arr)\n",
    "    #W_exact.pop()\n",
    "    print(any(num1 < 0 for num1 in W_exact))\n",
    "    print(any(num2 < 0 for num2 in W_exact))\n",
    "    \n",
    "    #Stacking and storing them into a csv\n",
    "    \n",
    "    \n",
    "    \n",
    "    print('lam_CV_arr',len(lam_CV_arr))\n",
    "    print('mu_CV', len(mu_CV_arr))\n",
    "    print('lam_CVsq', len(lam_CV_arr_sq))\n",
    "    print('mu_CVsq', len(mu_CV_arr_sq))\n",
    "   \n",
    "    \n",
    "    print('Response time', len(W_exact))\n",
    "    \n",
    "    store_df = pd.DataFrame({'lam_CV' : lam_CV_arr,\n",
    "                            'mu_CV' : mu_CV_arr,\n",
    "                            'lam_CVsq' : lam_CV_arr_sq,\n",
    "                            'mu_CVsq' : mu_CV_arr_sq,\n",
    "                            'lam_kurt' : [moment4] * len(W_exact),\n",
    "                            'mu_kurt' : [40] * len(W_exact),\n",
    "                            'Response time' : W_exact}\n",
    "                            )\n",
    "\n",
    "    if moment4 == 20 :\n",
    "        plt.scatter(lam_CV_arr_sq, W_exact, color = 'red', label = 'Kurta = 20, Kurts = 40')\n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'red', label = 'Kurta = 1.5, Kurts = 1.5')\n",
    "        plt.xlabel('CV sq of IAT curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "       \n",
    "    elif moment4 == 30 :\n",
    "        plt.scatter(lam_CV_arr_sq, W_exact, color = 'yellow', label = 'Kurta = 50, Kurts = 40')\n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'blue', label = 'Kurta = 1.5, Kurts = 2.5')\n",
    "        plt.xlabel('CV sq of IAT curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "       \n",
    "    elif moment4 == 40 :\n",
    "        #W_exact = (np.array(W_exact)) * + 10\n",
    "        plt.scatter(lam_CV_arr_sq, W_exact, color = 'green', label = 'Kurta = 40, Kurts = 40')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'green', label = 'Kurta = 1.5, Kurts = 20')\n",
    "        plt.xlabel('CV sq of IAT curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "        \n",
    "    elif moment4 == 50 :\n",
    "        #W_exact = (np.array(W_exact)) *   10\n",
    "        plt.scatter(lam_CV_arr_sq, W_exact, color = 'blue', label = 'Kurta = 30, Kurts = 40')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'black', label = 'Kurta = 1.5, Kurts = 25')\n",
    "        plt.xlabel('CV sq of IAT curve')\n",
    "        plt.ylabel('RT for M/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "        \n",
    "    \n",
    "        \n",
    "       \n",
    "    plt.legend()\n",
    "    plt.xlim(0, 25)\n",
    "    plt.ylim(0, 15)\n",
    "    final_df = final_df.append(store_df, ignore_index = True)\n",
    "\n",
    "'''\n",
    "\n",
    "    ax1.set_xlabel('CV of IAT curve')\n",
    "    ax1.set_ylabel('CV of ST curve')\n",
    "    ax1.set_zlabel('RT for H2/H2/1 as per Tarasov for given skewness of IAT and ST dists ')\n",
    "    #ax1.set_xlim(0, 70)\n",
    "    #ax1.set_ylim(0,70)\n",
    "    ax1.set_zlim(0,200)\n",
    "'''\n",
    "\n",
    "\n",
    "\n",
    "plt.show()\n",
    "\n",
    "\n",
    "final_df = final_df.append(store_df, ignore_index = True)\n",
    "final_df.to_csv('DetailsH2_H2_1_fixedmeanKurt_40Kurts(2servers).csv', index= True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "daaaa5f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b= (np.array(a)) * 2\n",
    "\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33c9c8f5",
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}