fixedmeanKurtosis_large.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "9de32406",
   "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": 21,
   "id": "6c583da8",
   "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": 22,
   "id": "220188b3",
   "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[j], mu2_arr[j], q_arr[j]) >=1 :\n",
    "                mu_CV_arr.append(calculatecoeff_var(mu1_arr[k2], mu2_arr[k2], q_arr[k2]))\n",
    "            else :\n",
    "                continue\n",
    "                \n",
    "            a_0 = (lam1_arr[k1]*lam2_arr[k1])\n",
    "            a_1 = p_arr[k1]*lam1_arr[k1] + (1-p_arr[k1])*lam2_arr[k1]\n",
    "            b_0 = (mu1_arr[k2]*mu2_arr[k2])\n",
    "            b_1 = q_arr[k2]*mu1_arr[k2] + (1-q_arr[k2])*mu2_arr[k2]\n",
    "\n",
    "            c_0 = a_0*b_1 - a_1*b_0 - a_0*(mu1_arr[k2]+mu2_arr[k2]) + b_0*(lam1_arr[k1] + lam2_arr[k1])\n",
    "            c_1 = -a_1*b_1 -a_0 - b_0  + (lam1_arr[k1] + lam2_arr[k1])*(mu1_arr[k2] + mu2_arr[k2])\n",
    "            c_2 = lam1_arr[k1] + lam2_arr[k1] - mu1_arr[k2] - mu2_arr[k2]\n",
    "\n",
    "            x = symbols('x')\n",
    "            expr = x**3-c_2*x**2-c_1*x-c_0\n",
    "\n",
    "\n",
    "            sol = solve(expr)\n",
    "            #print(sol)\n",
    "\n",
    "            #calculate wait time in queue Wq\n",
    "\n",
    "            Wq = (-1/re(sol[0])) + (-1/re(sol[1])) - (1/mu1_arr[k2]) - (1/mu2_arr[k2]) \n",
    "\n",
    "            #calculate response time in queue W\n",
    "\n",
    "            W = Wq + (q_arr[k2]/mu1_arr[k2]+ (1-q_arr[k2])/mu2_arr[k2])\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": "markdown",
   "id": "b8e07d25",
   "metadata": {},
   "source": [
    "# For Kurta = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3886f4bd",
   "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",
    "    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",
    "        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 of ST curve')\n",
    "        plt.ylabel('RT for H2/H2/1 as per Tarasov for given kurtosis of IAT and ST dists')\n",
    "        \n",
    "       \n",
    "    elif moment4 == 30 :\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'blue', label = 'Kurta = 30, 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 of ST curve')\n",
    "        plt.ylabel('RT for H2/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(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 of ST curve')\n",
    "        plt.ylabel('RT for H2/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(mu_CV_arr_sq, W_exact, color = 'yellow', label = 'Kurta = 30, Kurts = 50')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'black', label = 'Kurta = 1.5, Kurts = 25')\n",
    "        plt.xlabel('CV of ST curve')\n",
    "        plt.ylabel('RT for H2/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.csv', index= False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a45b5d3",
   "metadata": {},
   "source": [
    "# For Kurta = 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c5f81884",
   "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)) *   1.5\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 of ST curve')\n",
    "        plt.ylabel('RT for H2/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.5\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'blue', label = 'Kurta = 40, 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 of ST curve')\n",
    "        plt.ylabel('RT for H2/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.5\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 of ST curve')\n",
    "        plt.ylabel('RT for H2/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.5\n",
    "        plt.scatter(mu_CV_arr_sq, W_exact, color = 'yellow', label = 'Kurta = 40, Kurts = 50')\n",
    "        \n",
    "        #ax1.scatter3D(lam_CV_arr, mu_CV_arr, W_exact, color = 'black', label = 'Kurta = 1.5, Kurts = 25')\n",
    "        plt.xlabel('CV of ST curve')\n",
    "        plt.ylabel('RT for H2/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, 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_40Kurta_large.csv', index= False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "336ac98e",
   "metadata": {},
   "source": [
    "# For Kurts = 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "64e050a9",
   "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_large.csv', index= False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b89c3598",
   "metadata": {},
   "source": [
    "# For Kurts = 40"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "63d7e523",
   "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": "iVBORw0KGgoAAAANSUhEUgAAAfQAAAHgCAYAAABTkZ8HAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABDvUlEQVR4nO3deXxcdb3/8dcnbbGkYKRpWS6QTBFRgbJIFWXRQlERoSAgiGGrXGNZBNSfijd4Ab3hunAVsFe5QZZCR1bZyqq3UsCLWlsohE0BacpSaSkSKYGStp/fH+dMmExmJmeWMzOZvJ+Pxzwmc2bmnM/MI+0n5/v9ns/H3B0REREZ2RqqHYCIiIiUTgldRESkDiihi4iI1AEldBERkTqghC4iIlIHlNBFRETqwNhqBxDFpEmTPJFIVDsMERGRiliyZMkr7j65kPeMiISeSCRYvHhxtcMQERGpCDPrKfQ9GnIXERGpA0roIiIidUAJXUREpA6MiDl0EZFa0t/fzwsvvMBbb71V7VBkhBs/fjzbbLMN48aNK3lfSugiIgV64YUX2HTTTUkkEphZtcOREcrdWb16NS+88AJTpkwpeX8achcRKdBbb71Fc3OzkrmUxMxobm4u20iPErqISBGUzKUcyvl7pIQuIjICbbLJJgM/33nnneywww709ES/dPmWW27hiSeeiCO0AdOnT+f9738/u+22G7vtthsrV64EYO3atRx99NFsv/327LnnnixbtmzYfY2Ezwtw+umnD4q1mM9aLCV0EZERbMGCBZx++uncddddtLa2RnrPunXrKpbgkskkS5cuZenSpWy++eYAXHbZZWy22WY888wzfO1rX+Pb3/525P3V8uddvHgx//jHPwZtK+WzFszda/62xx57uIhIrXjiiScKfMc8d291dwvv55Ucw4QJE/y+++7zKVOm+JNPPunu7s8995zvtNNOA6/58Y9/7Oecc467u3/iE5/wM844w/fYYw//j//4D99ss808kUj4rrvu6s8884x3dXX5tGnTfJdddvHDDz/c33jjjZJj/MQnPuF//vOfh2z/1Kc+5Q8++KC7u/f393tzc7Nv2LChop/3oosu8g9+8IM+depUP/roo0v+rOvWrfPp06f7Sy+95BMmTCjos2b7fQIWe4G5UqvcRURilQTagb7wcU/4GKCt6L2uXbuWww47jIULF/KBD3wg0nvefvvtgTLaTz/9NAcffDBHHnkkAO95z3v48pe/DMDZZ5/NZZddxle/+tVB77/33nv52te+NmS/jY2NPPjgg1mPOWvWLMaMGcMRRxzB2WefjZnx4osvsu222wIwduxYmpqaWL16NZMmTarY5/3BD37Ac889x7ve9S5ee+21Ie/9y1/+wtFHH511vwsXLuQ973nPoG1z5sxh5syZbLXVVoO2F/NZi6WELiISqw7eSeYpfeH24hP6uHHj2Guvvbjsssu46KKLIr0nV4ICeOyxxzj77LN57bXXWLNmDZ/+9KeHvGa//fZj6dKlkWNMJpNsvfXWvP766xxxxBFcffXVHH/88ZHfn67cn3eXXXahra2Nww47jMMOO2zI8+9///sjf9aXXnqJG264gYULF0Z6fVw0hy4iEqvlBW6PpqGhgeuvv55FixZx/vnnA8EZ4IYNGwZek3k51IQJE3Lu78QTT2TOnDl0d3dzzjnnZL2U6t577x1Y4JZ+22uvvbLuc+uttwZg00035Ytf/CKLFi0a2P78888Dwfx2b28vzc3NFf28d9xxB6eeeioPPfQQH/7wh1m3bt2g5//yl79k/ay77bbbkDP6hx9+mGeeeYbtt9+eRCJBX18f22+/fdGftVg6QxcRiVULwTB7tu2laWxs5I477mDfffdliy224Pjjj2flypWsXr2aTTbZhNtvv50DDzww63s33XRTXn/99YHHr7/+OltttRX9/f0DZ9aZCjlDX7duHa+99hqTJk2iv7+f22+/nQMOOACAmTNnMnfuXD72sY9x4403sv/++w8MxR9//PEsWLAg1s+7YcMGnn/+efbbbz/22Wcfrr32WtasWTNoGL2QM/TPfvaz/P3vfx94vMkmm/DMM8/k/axxUEIXEYlVJ4Pn0AEaw+2lmzhxInfffTcf//jHmTx5Mv/+7//ORz7yEbbeeuu8c81f+MIX+PKXv8zFF1/MjTfeyPe//3323HNPJk+ezJ577jko2Rdj7dq1fPrTn6a/v5/169dzwAEHDMzRn3TSSRx33HFsv/32TJw4kWuvvRaAFStWMHZs/rRUjs977bXXctJJJ9Hb24u7c/rppw+ZEy+XXJ81DhYspqtt06ZNc/VDF5Fa8eSTT/LBD36wgHckCebMlxOcmXdSyvx5vZozZw4tLS3MnDmz2qFUVLbfJzNb4u7TCtmPztBFRGLXhhL48E477bRqhzCiaVGciIhIHVBCFxERqQNK6CIiInVACV1ERKQOKKGLiIjUASV0EZERaKS0E4WguMrOO+888PjVV1/lk5/8JO973/v45Cc/OaRDWaZly5YNev+ll17KHnvsMez70l155ZW89NJLhQdfoFI/ayliS+hmdrmZrTSzx7I89w0zczMrf3V6EZFRpJbbiQLcdNNNg/74gKAxyowZM3j66aeZMWMGP/jBDyLv7+qrr+ZnP/sZ99xzD5tttlmk96xfv74iCb3cn7VghbZni3oDPg58CHgsY/u2wD0EtRAnRdmX2qeKSC0ptH3qvEfneetPW93ONW/9aavPe3R0tE99/fXXfe+99/bHH398UFw77LCDv/TSS+7u/tJLL/kOO+yQdz+pz3Xdddf5jjvu6CtWrHB393vvvdc/+9nPDrzu1FNP9SuuuMLd3VtbW/1b3/qW77777n711Vf7hAkTfIcddvBdd93V+/r6/Nvf/vZA+9RvfOMbVf2sNd8+1d3vN7NElqd+CnwLuDWuY4uI1Ipkd5L2+e309QelX3t6e2ifH7RPbZta3+1Tv/vd7/KNb3yDxsbGQdtffvnlgTajW265JS+//PKwsff09HDaaafx8MMPs+WWW0b4tNDc3MxDDz0EwC9/+UsuuOACpk2bxurVq7n55pt56qmnMLOs7VOr+VmLVdFKcWZ2KPCiuz8SV3F6EZFa0rGgYyCZp/T199GxoKOkhF7r7VOXLl3Ks88+y09/+lOWLVuW83VmFqlZyeTJk5k4cSLXX3991kSbTa7P29TUxPjx4znppJM4+OCDOfjgg4e8ppqftVgVS+hm1gj8G/CpiK9vJ+hoQEtL6V2JRESqYXlv9japubZHlWonOmPGDM4//3z+7d/+reT2qbfccgu77rorV155Zdbe3oWctf7hD39g8eLFJBIJ1q1bx8qVK5k+fToLFy5kiy22YMWKFWy11VasWLGCzTfffNjP29jYyJ133sm+++7L5ptvTltbW9Gfd+zYsSxatIgFCxZw4403MmfOHH73u9/VzGctViXP0N8LTAFSZ+fbAA+Z2Ufc/e+ZL3b3LqALguYsFYxTRKRsWppa6Okduvq8pam+26eefPLJnHzyyUCwSv3ggw8e+CMh1VL0rLPOYu7cuRx66KEALFq0iDlz5nDVVVdl3efmm2/O3XffzfTp05k0aRI77rgjTzzxBGvXruXNN99kwYIF7LPPPsN+3jVr1tDX18dBBx3E3nvvzXbbbVfxzxqHiiV0d+8GBv40MbNlwDR3f6VSMYiIVFrnjM5Bc+gAjeMa6ZxR3+1T8znrrLM46qijuOyyy2htbeX6668HYPny5Wy88cZ53ztlyhRuu+02DjroIG6++WaOOuoodt55Z6ZMmcLuu++e830nnngis2fPZuONN+auu+7i0EMP5a233sLd+clPflLWz5cu12eNQ2ztU83sGmA6MAl4GTjH3S9Le34ZERO62qeKSC0ptH1qsjtJx4IOlvcup6Wphc4ZnSXNn9erb37zmxx33HHssssu1Q6losrVPlX90EVEClR4P3SR3MqV0FUpTkREpA4ooYuIiNQBJXQREZE6oIQuIiJSB5TQRURE6oASuojICDQS2qceeOCB7Lrrruy0007Mnj2b9evXA2qfGhcldBGREayW26def/31PPLIIzz22GOsWrWKG264AVD71NgU2p6tGje1TxWRWlJw+9R57q2t7mbB/bzSu6eOiPapKW+//bYffPDBfu2117q72qdmqvn2qSIiAskktLdDX1j5tacneAzQVkKxuJHQPhXg05/+NIsWLeIzn/nMwLHUPjUeGnIXEYlRR8c7yTylry/YXor09qlRDdc+dd9992Xq1Kkkk0kef/zxIa9JNSzJvOVK5gD33HMPK1asYO3atUM6mkFh7VNbWloKqoUepX3qTTfdNCQJQ2GfNdU+9XOf+1zeeOJun6qELiISo+U5uqTm2h5Vqn3qokWLOP/88wFKbp86Z84curu7Oeecc4a8F4Kz1t12223Iba+99sob6/jx4zn00EO59dZbAQZaigIFt0+95JJLSCaTJX3eVPvUI488MmdHukI+a3r71H322Ye//vWvTJ8+vejPWiwNuYuIxKilJRhmz7a9VLXcPnXNmjUD+1y3bt1AnKD2qXFRQhcRiVFn5+A5dIDGxmB7OdRq+9Q33niDmTNnsnbtWjZs2MB+++3H7NmzAbVPjYu6rYmIFKjg9qnJYM58+fLgzLyzs7QFcfVK7VPfUUy3NZ2hi4jErK1NCTyKH//4x9UOYUTTojgREZE6oIQuIiJSB5TQRUSKMBLWH0ntK+fvkRK6iEiBxo8fz+rVq5XUpSTuzurVqxk/fnxZ9qdFcSIiBdpmm2144YUXWLVqVbVDkRFu/PjxbLPNNmXZlxK6iEiBxo0bx5QpU6odhsggww65m9kEM2sIf97BzGaa2bj4QxMREZGoosyh3w+MN7Otgd8AxwFXxhmUiIiIFCZKQjd37wMOB37u7p8Hdoo3LBERESlEpIRuZh8D2oA7wm1j4gtJREREChUloZ8BfAe42d0fN7PtgHvjDUtEREQKEWWV+xbuPjP1wN3/ZmYPxBiTiIiIFCjKGfp3Im4TERGRKsl5hm5mnwEOArY2s4vTnno3sC7uwERERCS6fEPuLwGLgZnAkrTtrwNfizMoERERKUzOhO7ujwCPmNmv3L0fwMw2A7Z1939UKkAREREZXpQ59N+a2bvNbCLwEHCpmf005rhERESkAFESepO7/5OgsMxV7r4nMCPesERERKQQURL6WDPbCjgKuD3meERERKQIURL694B7gGfc/c9hYZmn4w1LRERECjFsYRl3vwG4Ie3x34Aj4gxKRERECpPvOvRvufuPzOxngGc+7+6nxxqZiIiIRJbvDP3J8H5xJQIRERGR4uW7Dn1+eD+3cuGIiIhIMfINuc8ny1B7SnrDFhEREamufEPuF4T3hwNbAvPCx8cAL8cZlIiIiBQm35D7fQBm9l/uPi3tqflmpnl1ERGRGhLlOvQJ4bXnAJjZFGBCfCGJiIhIoYa9Dp2gs9pCM/sbYEAr0B5rVCIiIlKQKIVl7jaz9wEfCDc95e5r4w1LREREChHlDJ0wgT8ScywiIiJSpChz6CIiIlLjciZ0M2upZCAiIiJSvHxn6LdUKggREREpTb6EbqXs2MwuN7OVZvZY2rYfm9lTZvaomd1sZu8p5RgiIiISyLcobmszuzjXkxG6rV0JzAGuStv2W+A77r7OzH4IfAf4dsRYRUREJId8Cf1NYEmxO3b3+80skbHtN2kP/wgcWez+RURE5B35EvrqmDutfQm4Lsb9i4iIjBr55tDfjuugZtYBrAOSeV7TbmaLzWzxqlWr4gpFRESkLuRL6F8ws6bUAzPbz8wuMrOvm9lGxR7QzE4EDgba3D1fe9Yud5/m7tMmT55c7OFERERGhXwJ/TrCJixmthtwA7Ac2BX4eTEHM7MDgW8BM929r5h9iIiIyFD55tA3dveXwp+PBS539/8yswZg6XA7NrNrgOnAJDN7ATiHYFX7u4DfmhnAH919dvHhi4iICORP6OnXoe9PkIxx9w1hMs7L3Y/JsvmygqITERGRSPIl9N+Z2fXACmAz4HcAZrYVMS6YExERkcLlS+hnAkcDWwH7uHt/uH1LoCPmuERERKQAORN6uAL92izbH441IhERESmY2qeKiIjUASV0ERGROqCELiIiUgdyzqGbWTeQr5LbLrFEJCIiIgXLt8r94PD+1PD+6vC+Lb5wREREpBj5Vrn3AJjZJ91997SnzjKzh4Cz4g5OREREookyh25mtnfag70ivk9EREQqJN+Qe8pJwOVh5zUD/kHQy1xERERqxLAJ3d2XALumWqm6e2/sUYmIiEhBhk3oZvYu4AggAYxNNWZx9+/FGpmIiIhEFmXI/VagF1gCrI03HBERESlGlIS+jbsfGHskIiIiUrQoq9UfNLOpsUciIiIiRYtyhr4PcKKZPUcw5G4EzdhUKU5ERKRGREnon4k9ChERESlJlMvWUhXjNgfGxx6RiIiIFGzYOXQzm2lmTwPPAfcBy4C7Yo5LREREChBlUdz3gY8Cf3X3KcAM4I+xRiUiIiIFiZLQ+919NdBgZg3ufi8wLea4REREpABRFsW9ZmabAPcDSTNbCbwRb1giIiJSiChn6IcCfcDXgLuBZ4FD4gxKRERECjNsQnf3N9x9g7uvc/e57n5xOAQvIiJSk5LdSRIXJmg4r4HEhQmS3clqhxS7KEPuIiIiI0ayO0n7/Hb6+vsA6OntoX1+OwBtU9uqGVqsogy5i4iIjBgdCzoGknlKX38fHQs6qhRRZeRM6GZ2ZQXjEBERKYvlvcsL2l4v8p2hq1a7iIiMOC1NLQVtrxf5Enqjme1uZh/KdqtYhCIiIgXonNFJ47jGQdsaxzXSOaOzShFVRr5FcVsD/0XQXS2TA/vHEpGIiEgJUgvfOhZ0sLx3OS1NLXTO6KzrBXEA5u7ZnzB72N13r3A8WU2bNs0XL15c7TBEREQqwsyWuHtBVVmLWuVuZh8u5n0iIiISj3wJ/dvpD8xsRzP7vpk9A/wi3rBERESGGo0FY6LKOYfu7r8xswRwTHjrB1qBae6+rCLRiYiIhEZrwZio8l2H/gfgDoKkf4S77wG8rmQuIiLVMFoLxkSVb8j9ZWBTYAtgcrgt+wo6ERGRmNVCwZhkEhIJaGgI7pM1NOKfM6G7+2HAVGAJcK6ZPQdsZmYfqVBsIiIiA6pdMOaUU+C446CnB9yD+/b22knqeVe5u3uvu1/h7p8CPgr8O/BTM3u+ItGJiIiEqlkwJpmESy4JEnm6vj7oqJER/8iXrbn7y+7+M3ffG9gnxphERGQUy7WSvW1qG12HdNHa1IphtDa10nVIV0UWxHV0DE3mKctrpER8vsIy88kzZ+7uM+MKKpMKy4iIjA6ZK9khOAuvVOLOpaEhd0JvbYVly8p7vGIKy+Qr/XpBifGIiIgUJN9K9mom9JaWYM48kxl01kiJ+HzXod9XyUBERERqYSV7Np2dwQK4vrS/Ncxg9mxoq5FL4Isq/SoiIhKHaq9kz6WtDbq6guF1s+D+6qvh5z+valiDKKGLiEjNqOXWp21twVz5hg3Bfa2cmafkqxR3dXh/RuXCERGR0ayaK9lHunyr3J8ADgDuAqaT0Rfd3V+NO7gUrXIXEZHRpNyr3C8BFgDbEVSLS0/oHm4XERGRGpCv9OvF7v5B4HJ3387dp6TdlMxFRGREqeU67OWQ7wwdAHc/2cx2BfYNN93v7o8O9z4zuxw4GFjp7juH2yYC1wEJYBlwlLv/o7jQRUREokkmB192lqrDDrW3uK1Yw65yN7PTgSSweXhLmtlXI+z7SuDAjG1nAQvc/X0Ew/lnFRStiIhIETo6Bl9DDrVVh70chj1DB/4V2NPd3wAwsx8CfwB+lu9N7n6/mSUyNh9KsMAOYC6wEPh29HBFREQKl6veeq3UYS+HKNehG7A+7fF6Mla8F2ALd18R/vx3gl7rIiIisWrJUZcm1/aRKEpCvwL4k5mda2bnAn8ELiv1wB5cL5ez+YuZtZvZYjNbvGrVqlIPJyIio1hnJzQOrldDY2Pt1GEvh2ETurv/BJgFvBreZrn7hUUe72Uz2wogvF+Z57hd7j7N3adNnjy5yMOJiIhkL93a1VU/C+IgYulXd38ovIztYnd/uITj3QacEP58AnBrCfsSERGJfDlarZduLVWURXFFMbNrCBbATTKzF4BzgB8A15vZSUAPcFRcxxcRkfo3Gi5Hiypn6ddaotKvIiKSLpkMLjnL1qMcgiH1ZcsqGlJZFVP6Ncp16BPMrCH8eQczm2lm44oNUkREpFjJJEyaBMcemzuZQ31djhZVlDn0+4HxZrY18BvgOIKiMSIiIhWTGl5fvXr419bT5WhRRboO3d37gMOBn7v754Gd4g1LRERksGzV3rKpt8vRooqU0M3sY0AbcEe4bUx8IYmIiAwVZRi9Hi9HiypKQj8T+A5ws7s/bmbbAffGGpWIiNSEZHeSxIUJGs5rIHFhgmR39VqU5RtGb2yEefPq83K0qKIUlrnP3We6+w/Dx39z99PjD01ERKop2Z2kfX47Pb09OE5Pbw/t89urltSzVXsDaG4evWfl6XImdDO7MLyfb2a3Zd4qFqGIiFRFx4IO+voHT1r39ffRsaA6LcqyVXubNw9eeUXJHPIXlrk6vL+gEoGIiEhtWd6bfdI61/ZKaGtT8s4lZ0J39yXh/X2pbWa2GbCtuz9agdhERKSKWppa6OkderF3S9MovCZsBIhSWGahmb3bzCYCDwGXmtlP4g9NRESqqXNGJ43jBk9aN45rpHPGKLwmbASIssq9yd3/SXAd+lXuvidwQLxhiYhItbVNbaPrkC5am1oxjNamVroO6aJtaulj3lEbqkh0UZqzjA1bnR4FVGclhIiIlFWyO0nHgg6W9y6npamFzhmdWRN129S2siTwQcdWQ5VYRDlD/x5wD/Csu/85vA796XjDEhGRuFT7crRsFd/6+oLtUjx1WxMRGWUSFyayLnZrbWpl2ZnLYj9+QwNkSz1mQa9yia/b2jZmdrOZrQxvvzazbYoPU0REqqnal6Plqvg2GhuqlFOUIfcrgNuAfwlv88NtIiIyIAkkCP5bTYSPa1Ouy84qdTlatopvo7WhSjlFSeiT3f0Kd18X3q4EJsccl4jICJIE2oEewMP7dqqd1HPVYa/25WjZKr6pdGvpoqxyX21mxwLXhI+PASJ0oxURGS06gMy+nn3h9upkqdTCt1Tp1tTCN2Bg1XqUVe5xUcW38ht2UZyZtQI/Az5G8Kfng8BX3f35+MMLaFGciNSeJEHCXk7wX2M2BlRnlVe1F75JaYpZFBflDH0bd5+ZcaC9gYoldBGR2pIaYs88K89UvVVe1V74JpUXZQ79ZxG3iYiMAkngBIZP5o1A9VZ5VXvhm1RezjN0M/sYsBcw2cy+nvbUu4ExcQcmIlJ7Umfm6/O8xgjOzDup1vw5BAvf0ufQQXXY612+IfeNgE3C12yatv2fwJFxBiUiUpuyLX5L1wosq0wow6iFhW9SWXkXxZnZGOB6dz+iciENpUVxIlIbGsi9AK4R6KKaZ+VSP8peKc7d1xMUkxERkZyL3MagZC7VFmWV+1Izuw24AXgjtdHdb4otKhGRmtTJ0NXtOjOX2hAloY8nKCSzf9o2B5TQRWSUSSXt1PXn1V/8JpIybEJ391mVCEREpDakF4zJlrDbUAKXWhSl29oVZnZ55q0SwYmIVFZt1mSvhGQSEomgtWkiETyWkSXKkPvtaT+PBz4HvBRPOCIi1ZIqGJN5jXl1a7JXQjIJ7e3QFy4N6OkJHoPqrY8kw9ZyH/IGswbg9+6+VzwhDaXL1kQkXsOVcq1eTfZKSCSCJJ6ptRWWLat0NAIxXLaWw/uAzYt4n4hIjRquYEx9lUvNHF7PlswBlqvs+4gy7JC7mb3O4EoKfwe+HVtEIiIVEaVbGlS7Jnu5ZRteN4Nsg7Ut9fV3TN2LMoc+2d3fSt9gZhNjikdEpAKidkurv4IxHR3vJPMU96FJvbEROuvn75hRIcqQ+6/NbCDxm9mWwG/jC0lEJG7DDbFDcGY+l3pK5pB7GN09mDM3C+67urQgbqSJktBvAW4wszFmlgB+A3wnzqBEROKVb3LYCJqslP/MPNmdZNKPJmHnGXaeMelHk0h2V/b6sFzD6KkFcBs2BPdK5iNPlMIyl5rZRgSJPQF8xd0fjDkuEZEYtRBcY54pvm5pye4ks26ZRf+G/oFtq99czZdu/RJAxbqgdXYOnkMHDa/Xi5xn6Gb29dSN4PrzFmAp8NGM/ugiIiNMJ8GQerp4F791LOgYlMxT3l7/Nh0LOmI7bqa2tmA4XcPr9SffGfqmGY9vyrFdRGSEqXxN9uW9uYf58z0Xh7Y2JfB6lDOhu/t5lQxERKSyKluTvaWphZ7e7Bd8tzTp+jApXTGFZUREpECdMzoZ1zBuyPaNxmxE5wxNYEvplNBFRCqgbWobVxx2Bc0bNw9sa964mcsPvbxiC+KkvhVcy70aVMtdRPJLAmcAq8PHzcBF1Ns15DJ6FFPLPUrp18nAlwkuWRt4vbt/qdAARUTKLwnMAtJXkK8GUv9FxZvUk91JOhZ0sLx3OS1NLXTO6NQZt1RFlCH3W4Em4H+BO9JuIiI1oIPByTzl7fC5+CS7k7TPb6entwfH6entoX1+e9mKxahHuRRi2CF3M1vq7rtVJpzsNOQuIrk1kLu5SrxtTxMXJrKuXG9tamXZmctK2ndmExUICsDomvHRIa72qbeb2UFFxiQiUmZJYBJBsk7dcon3crBc14+X47rybE1U+vqC7SLZREnoZxAk9bfM7J9m9rqZ/TPuwEREhkrNl69O25brDHwj4m57muv68XJcV56riYp6lEsuwyZ0d9/U3Rvcfby7vzt8/O5KBCciMliu+XIYfKbeDFxO3AviOmd00jhucAnZxnGNZbmuPFcTFfUol1yGTegWONbMvhs+3tbMPlLKQc3sa2b2uJk9ZmbXmNn4UvYnIqPFcKenHt5eoRKXrLVNbaPrkC5am1oxjNamVroO6SrLKvfOzmDOPJ2aqEg+URbF/YJgTGt/d/+gmW0G/MbdP1zUAc22Bn4P7Ojub5rZ9cCd7n5lrvdoUZyIBBJk75IGcXZKq5ZkMpgzX748ODPv7NSCuNEirkVxe7r7qcBbAO7+D4LJqVKMBTY2s7EELY5eKnF/IjIqdAJDy6eWa7482Z0kcWGChvMaSFyYqHiv8kxtbepRLtFFSej9ZjaG8LqQsNBM0deBuPuLwAUEY2crgF53/02x+xOR0aQNuIJgjjylPPPlcV9TLhK3KAn9YuBmYHMz6yQYLj+/2AOGQ/aHAlOAfwEmmNmxWV7XbmaLzWzxqlWrij2ciNSdNoI58vLMl6fOyo+96Vj6+gdfJ9bX31fRXuUipRi29Ku7J81sCTCDYBnpYe7+ZAnHPAB4zt1XAZjZTcBewLyM43YBXRDMoZdwPBGRrFJn5ZmJPF2le5WLFCvKKveLgYnu/t/uPqfEZA7BUPtHzazRzIzgD4VS9ykiI1aSYLFbQ3hfuSHujgUdeZM5qFe5jBxRhtyXAGeb2bNmdoGZFbTqLpO7/wm4EXgI6A5j6CplnyIyUiWBdoKV6x7et1OppD7c2Xe5rikXqYQohWXmuvtBwIeBvwA/NLOnSzmou5/j7h9w953d/Th3X1vK/kRkpOoAMs+Q+4i7qUpKvrPvcl5TLlIJUc7QU7YHPkBwsedT8YQjIqNDapg91zXllZm3zlXpbd7h81h25jIlcxlRosyh/yg8I/8e8Bgwzd0PiT0yEalT6cPsuVRm3jrOSm8ilTbsKnfgWeBj7v5K3MGIyGiQbZg9XSNxN1VJ1za1TQlc6kLOhG5mH3D3p4A/Ay1mNuhPZnd/KO7gRKQe5RtObyVI5kqwIoXKd4b+dYJxsf/K8pwD+8cSkYjUuRayD7fXXy12kUrKOYfu7u3h/X5ZbkrmIpLHKQTnCxben5L2XCfBsHq6yg6zR5FMQiIBDQ3BfVIVYKXGDTuHbmaHZ9ncC3S7+8ryhyQiI9spwC/SHq9Pe/xz3hlO7yAYfm+h1obZk0lob4e+cKq/pyd4DGqQIrUrSvvUO4CPAfeGm6YTFJuZAnzP3a+OM0BQ+1SRkeEUghpR63M835DnueiS3Uk6FnSwvHc5LU0tdM7oLPuitkQiSOKZWluDrmcicSumfWqUVe5jgQ+6+8vhQbYArgL2BO4HYk/oIlLrMs/Ksym6SeM7R7njFC5ZfAkeNH8c6IgGlDWpL8+xbi/XdpFaEKWwzLapZB5aGW57FeiPJywRGRlSBWKGS+ZlOFJ3clAyT4mjI1pLjsvgc20XqQVREvpCM7vdzE4wsxOAW8NtE4DXYo1ORGrYKcBx5C8Qk25CSUfrWNAxJJmnlLsjWmcnNGas22tsDLaL1KooQ+6nAocD+4SPrwJ+7cHk+35xBSYitSoJnAGsLuA9Y4D/Kemo+ZJ2uTuipRa+dXQEw+wtLUEy14I4qWVR+qE78OvwJiKjWqpsa/6Wo4OVp1hMS1MLPb1DRwMMi6UjWlubEriMLIU0ZxGRUS0JnEC0ZD4GOJmgBtUyoibzZHeSxIUJGs5rIHFhgmT3Oxd/Z2ukYhizp81W6VYRog25i8iolzozH+6yMyO48KXwBJvsTtI+v52+/uAPhswV7KmkHfclayIjVd7r0M1sDHCVu1f1X4yuQxeptgTDL34zYDZB8ZgijnBhIuuQemtTK8vOXFbUPkVGqmKuQ8875O7u64FWM9uopMhEZIQbbhV5M8GZeXHJHHIveiv3CnaRehVlDv1vwP+Z2XfN7OupW9yBiUgtybWKfAwwD3iFKMPs+ebIc61UL/cKdpF6FSWhPwvcHr5207SbiIwauRqqzKWQBW/t89vp6e3B8YE58lRSz7borXFcYywr2EXq0bC13AdeaLYJgLuviTWiLDSHLlILkpTSUCXKHHkl6rSLjATFzKFHac6yM8Hk2MRw0yvA8e7+eFFRFkEJXWTkyUzO2ZI5BJeebTin9DrvIvUkruYsXcDX3f3e8CDTgUuBvQoNUERGh2yXoBmWtXSr5shFyiPKHPqEVDIHcPeFlFqUWUTqWseCjoFknuI4hg3apjlykfKJtMo9XOGeCG9nE6x8FxEBhq5ezzW87jitTa0YRmtTK12HdGmOXKRMogy5fwk4D7iJoI7jA+E2EZGChtdVJEYkPjnP0M3s6vDH4939dHf/kLvv4e5nuvs/KhSfiJTkFIK/2y28P6XsR9DwukhtyDfkvoeZ/QvwJTPbzMwmpt8qFaCIFOsU4Be8U399ffi4vEk9VyU3Da+LVFa+IfdLgAXAdsASGPTntofbRaQmJQmSdzZdlFKiNVOuS9I0vC5SWTnP0N39Ynf/IHC5u2/n7lPSbkrmIjUr1Rktl+E6pqXtKU+p1hRVeBOpDcMuinP3kysRiIiUSwf5e5aPGXYPye4kX5n/Fd7of2NgW2Y70xS1NRWpDZFLv1aTKsWJ5JKtHOtxkGWF+TtOJt+Qe7I7yaxbZtG/oT/r8xpKF4lf2dunikgtOwU4lqBPuYf3s3inSnM2+ZM5BGfauZI5qJ2pSK0adsg9bJV6nbu/WIF4RCSSXIve+oG3CDqhpQ+7NxIshhs6DJ7sTnLGXWew+s3VkY6sUq0itSnKGfqmwG/M7AEzO83Mtog7KBEZTkee594gSN6tBBentJIvmc+6ZVbkZG6YFruJ1KhhE7q7n+fuOwGnAlsB95nZ/8YemYjkMdywdxuwDNgQ3mdfoDbc8Hqm2dNma7GbSI0qZA59JfB3YDWweTzhiEg0+Ya9myPvJep8ePPGzcw7fB4//2z5rl8XkfKKMod+CnAUMBm4Afiyuz8Rd2Aikk8nQUuFtzO2jwEuiryXfH3KtZpdZGSJcoa+LXCmu+/k7ucqmYvELQkkCP55JsLHmdqAyxl8Nt4MzCV9eD3ZnWTSjyZh5xl2njHpR5MGFYfpnNHJuIZxQ/a+0ZiNNFcuMsJEKSzzHTPb1cxOCzc94O6PxByXyCiUBM4gmNVK6eGdqm+Zc9dtWbal7a07yZdu/RJvr3/nLH71m6uZdcus4N1T2wbmw9NXuTdv3MxFn7lIc+UiI8ywhWXM7HSC/1FuCjd9Duhy95/FHNsAFZaR+pYEZgNr8rymlWBxW3T5+pJrOF2kthVTWCZKP/R/BfZ09zfCg/wQ+ANQsYQuUr9SHdGGM/zitWR3clD51VzJHFQcRqQeRUnoxuBuDusho9GxiBQhSdDUMIr8xVyS3Una57cP9CXv6e3BMDxHCVgVhxGpP1ES+hXAn8zsZoJEfihwWaxRidS1VP313GfQgzUSrGrPrWNBx0AyT8mVzMc1jNOCN5E6FGVR3E/MbCGwT7hplrs/HGtUInXrFIKz8qhNkZoJLkMbvHI9cxFbvkpv6c9rwZtI/YpyHfp7gcfd/SEz2w/Y18yec/fXYo9OpK6khtijJvOhjVSydULLl8y1+E1k9IhyHfqvgfVmtj3B/0bbAr+KNSqRutRBtGQ+AZhHtq5o+Uq1WsbSlsZxjRpaFxlFoiT0De6+DjgcmOPu3ySo6S4iBRluZXkrQSJfQ67ry/OtTnec1qZWDKO1qZWuQ7o0tC4yikRZFNdvZscAxwOHhNuGlpYSkVBq0dtygtXpnQQJuoXsC+EMuJp8RWJSVKpVRHKJcoY+C/gY0Onuz5nZFIL/fURkiCRBHaYeguH1VKW3JEFib8x4vREUlYl2Jq1SrSKSS5T2qU+4++nufk34+Dl3/2EpBzWz95jZjWb2lJk9aWYfK2V/IrWjA+jL2NYXbm9jaJ/yq0l2703iwgQN5zWQuDAxqNZ6prapbVxx2BU0b/xODffmjZu5/NDLNbwuMspFKf36PuA/gR2B8ant7r5d0Qc1m0tQE/6XZrYR0Jhv1bxKv8rI0UD2hW9G0Jt8sMyCMBAsZtP8t8joVkzp1yhD7lcQ1KZcB+wHXEWwcqcoZtYEfJywOI27v61L4KR+5KrAln17toIwff19dCzoKHNcIlLvoiT0jd19AcHZfI+7nwt8toRjTgFWAVeY2cNm9kszm1DC/kRqSLZ58qDSW7I7OWRoPdeqddVaF5FCRUnoa82sAXjazE4zs88Bm5RwzLHAh4BfuPvuwBvAWZkvMrN2M1tsZotXrVpVwuFEKinbPHkXp9zxfxx303H09PbgOD29PbTPb2fixhOz7qWlqYVkEhIJaGgI7pO5p9ZFRCLNoX8YeBJ4D/B94N3Aj939j0Ud0GxL4I/unggf7wuc5e45z/o1hy4jTWZ51lyaN27mzXVvDplDP6HhHuZ+fx/60kbjGxuhqwvaNLUuUvfKPoduZmOAo919jbu/4O6z3P2IYpM5gLv/HXjezN4fbpoBPFHs/kTikQQSBP9EEuHjiO8My7MOl8wBXn3zVboO6RpSEObOSwYnc4C+PujQ1LqI5BDlDP2P7v7Rsh7UbDfgl8BGwN8IGr78I9frdYYulZW6ljw9ozYSDKUPf3qcuDCRtxd5ulzFYBoaINs/TTPYMHSxvIjUmWLO0KNUinvYzG4DbiCY7wbA3W8qML4B7r4UKChQkXglgTOAXGfV6deSZ7yzO0nHgg6W9y7PW8ktk2E5i8G0tEBPlt20qI25iOQQZVHceIL/5fYnKP16CHBwnEGJVE4SmAQcS+5knjJ05XnqOvL0xW6ZTVKyMYzZ02bnvNa8szOYM0/X2BhsFxHJJko/9FmVCESk8grtTd4y5Gx8zdtrhlxH7sPsr7Wplc4ZnXkLx6QWvnV0wPLlwZl5Z6cWxIlIblHm0McDJwE7MbhS3JfiDe0dmkOX8ksCxxE1mSe7x3HGXe9i9ZtrIh+heePmgYVxzRs3c9FnLlL1NxGJJK459KuBp4BPA98jmER8svDwRKotvQtarhKtWd7V3Uz7/Nfp64+ezNX5TEQqLUpC397dP29mh7r7XDP7FfBA3IGJlEcqifcQFHpJJfH1+d/VDR0LYHkvNNhrrPf8rwfg0WNgwfnQ28KarfpITtYQuYhUTs6EbmZj3X0d0B9ues3Mdgb+DmxeieBESpN5+VnUM3Jonw994W/+cMl8wpNf5s35P2BD32YQLohbvWIT2tuD55XURaQS8q1yXxTed5nZZsB3gdsIisD8KO7ARIqXvnI9s5VpPgacTMeC1oFkPpxxj59I/60/Z0PfRMhY3a5CMCJSSfmG3A3A3X8ZPr4PKLplqkj8ksBsIPpcN4whaGvaQtBYpY3lvVGu5gwWuvH7n7H6rdz/jJarx4qIVEi+hD7ZzL6e60l3/0kM8YgUYbiiMLlkr/6WqzjMGBvDBt9AS1PLwGVnDUPaCg2mQjAiUin5EvoYgq5qw1fJEKmaU4BfFPD61MK4VlJn5Jk6Z3Qy6/v/S/9vzoHeFmhazrhPnccV3z1gyGVnuSq6gQrBiEhl5UvoK9z9exWLRCSy9JXrhRgDzGXYeuyPtmHzj4bUUHpvApt/KRw6FqYOfmlnJ7S3M6SRSnMzXHSRFsSJSOXkmyzUmbnUmCSwKcFit0KT+UYMl8xT/cePPRbezpgXf/utsVkXuLW1BS1NW1uDximtrTBvHrzyipK5iFRWzkpxZjbR3V+tcDxZqVKcBMn8S8DbRbx3E4ISr/mTebYz7XTqdCYilVLWfui1ksxlNEvvSX4ChSfzZmAe8DrDDbN3dORP5qAFbiJS26JUihOpgszGKREqtQ2IOFeeZrjLy7TATURqXd4Lbs1sjJndW6lgRIJE3kCwcj1qF7R0zRSazCH/2XdrazBPrjlxEalleRO6u68HNphZU4XikVHtAIpL5CeH73HgFQpN5pC7//i8ebBsmZK5iNS+KEPua4BuM/st8EZqo7ufHltUMgolgQURXtdAUNkNgrPxiygmgWdS/3ERGemiJPSbwptImaS3MU2VXB16TVh6x7OWJuicAW1Tr6IcCTybtjYlcBEZuYZN6GHL1I2BFnf/SwVikrqW2QGtJ+Nx+KqMjmc9vdA+P/h1bcso7iIiIsPMoQOY2SHAUuDu8PFuZnZbzHFJ3UldgpatA1ofwcr0d3QsYEjHs77+dXQsUPsyEZFsorSVOhf4CPAagLsvRV3XJLL0Vqb5qrutJ2iWEljem/1Vy3vVvkxEJJsoCb3f3TP/e1W9LBnGKQRn3ccSrQtaK0Hns1bAaGkak/VVLU2q7iIikk2UhP64mX0RGGNm7zOznwEPxhyXjEipWutGcPlZ1L/7Gnmn89kyYAOdM+bSOG7wdWSN4xrpnKHqLiIi2URJ6F8FdgLWAtcA/wTOjDEmGZGSwIkEVzkWInVmPnh5edvUNroO6aK1qRXDaG1qpeuQriHtS0VEJJCzOcuQF5q9G3B3fz3ekIZSc5ZalQTOINqQeqZGsiVyEREpc3OWtJ1+2My6gUcJCsw8YmZ7FBuk1ItTiD4/nqkZJXMRkfKKMuR+GXCKuyfcPQGcClwRa1RSo1KXnqXmyAs1gaD7WXHlWUVEJLcoleLWu/sDqQfu/nszWxdjTFKTMgvCFMKA2cDPyxqRiIi8I0pCv8/M/odgQZwDRwMLzexDAO7+UIzxSVWll2htoLAWpqBELiJSOVES+q7h/TkZ23cnSPD7lzUiqQFJ4Cuk9eIhejIfRzAjoyF1EZFKilLLfb9KBCK1IgnMAvqHe2EWE4D/QclcRKTyoiyKk1EhvdZ61GRu4X0rwWK3NSiZi4hUR5Qhd6l7hSx4G0NQAS7V9lQJXESkFiihC8HCtyjJ3IC5KImLiNSeKIVlPm9mm4Y/n21mN6VWuMtIkRpObyDofDYp/DkRPhe1g9lslMxFRGpTlDn077r762a2D3AAQaGZYqqKSFWcAhxH0LrUCSq7rQ5/7iEYap84zD6aCebIdfmZiEitipLQU9crfRbocvc7gI3iC0nKJwlcQpC8c0kNtTdmbG8kSOKOKruJiNS+KAn9xbCwzNHAnWb2rojvk6rrIH8yT3mV9F7kuTqgiYhI7YqyKO4o4EDgAnd/zcy2Ar4Zb1hSHlHnxlsIkrcSuIjISDXsmba797n7TUCvmbUQlAJ7KvbIpAxaIrymkeDyMxERGcmirHKfaWZPA88B94X3d8UdmJRDJ0PnxiGo6KahdRGRehJlLvz7wEeBv7r7FIKV7n+MNSopkzaGzo2nKrptAJahZC4iUh+iJPR+d18NNJhZg7vfC0yLOS4pmzaCxK0ELiJSz6IsinvNzDYB7geSZraSwW24REREpMqinKEfSnCx8teAu4FngUPiDEpEREQKE6V9aupsfANBIW8RERGpMSoQIyIiUgeU0EVEROpA1RK6mY0xs4fN7PZqxSAiIlIvikroZlaOwjJnAE+WYT8iIiKjXs5FcXl6nhuwWykHNbNtCLq3dQJfL2VfIiIikn+V+58JSr1alufeU+JxLwS+BWxa4n5ERESE/An9SeAr7v505hNm9nyxBzSzg4GV7r7EzKbneV070A7Q0hKlyYiIiMjolW8O/dw8z3+1hGPuDcw0s2XAtcD+ZjYv80Xu3uXu09x92uTJk0s4nIiISP3Ll9BfBP6a7Ql3v6XYA7r7d9x9G3dPAF8Afufuxxa7PxEREcmf0I8HlpjZtWZ2opltWamgREREpDA559Dd/WQAM/sA8BngSjNrAu4lqOn+f+6+vpSDu/tCYGEp+xAREZEI16G7+1Pu/lN3PxDYH/g98HngT3EHJyIiItFEaZ86wN3fBO4MbyIiIlIjcp6hm9lUM/ujmT1vZl1mtlnac4sqE56IiIhEkW/I/RcEl65NJVjt/nsze2/43LiY4xIREZEC5Bty39Td7w5/vsDMlgB3m9lxgMcfmoiIiESVdw7dzJrcvRfA3e81syOAXwMTKxGciIiIRJNvyP2HwAfTN7j7o8AM4KY4gxIREZHC5LsO/Vc5ti8HvhxbRCIiIlKwfO1T55NnrtzdZ8YSkYiIiBQs3xz6BeG9AZcC/xp/OCIiIlKMfEPu96V+NrM16Y9FRESktgxb+jWky9RERERqWL459PRL08aEleIstcHdX40zMBEREYku3xz6kozHD6X97MB25Q9HREREipEvob/f3d+uWCQiIiJStHwJ/UEze4Gg9/nd7r6sMiGJiIhIofKtcp9mZgngQOBCM9uaoBf6XcB97r62MiGKiIjIcPKucnf3Ze5+ibsfBuwFzAcOAB4wszsqEJ+IiIhEkLc5Szp37wd+F94Iz9hFRESkBuS7bO3RfG90913KH46IiIgUI98Z+gaCy9N+RTDU/mZFIhIREZGC5ZxDd/fdgGOATQiSeiewE/Ciu/dUJDoRERGJZLhFcU+5+znu/iGCs/SrgK9VJDIRERGJLO+iuHDh2xeAzwH/IEjmN1cgLhERESlAvkVx9wGbAtcDs4DV4VMbmdlE1XIXERGpHfnO0FsJFsV9BWhP226olruIiEhNyVcpLlHBOERERKQEUfuhi4iISA1TQhcREakDSugiIiJ1IG9CN7MxZvZUpYIRERGR4gxXWGY98Bcza6lQPCIiIlKEKN3WNgMeN7NFwBupje4+M7aoREREpCBREvp3Y49CRERESjJsQnf3+8xsC+DD4aZF7r4y3rBERESkEMOucjezo4BFwOeBo4A/mdmRcQcmIiIi0UUZcu8APpw6KzezycD/AjfGGZiIiIhEF+U69IaMIfbVEd8nIiIiFRLlDP1uM7sHuCZ8fDRwZ3whiYiISKHytU99l7uvdfdvmtnhwD7hU13urp7oIiIiNSTfGfofgA+Z2dXufhxwU4ViEhERkQLlS+gbmdkXgb3CM/RB3F0JXkREpEbkS+izgTbgPcAhGc85OmMXERGpGTkTurv/Hvi9mS1298sqGJOIiIgUaNjLz5TMRUREap+uJxcREakDORO6WqaKiIiMHPnO0G+pVBAiIiJSmnwJ3SoWhYiIiJQk32VrW5vZxbmedPfTizmgmW0LXAVsQXD5W5e7X1TMvkRERCSQL6G/CSyJ4ZjrgG+4+0NmtimwxMx+6+5PxHAsERGRUSFfQl/t7nPLfUB3XwGsCH9+3cyeBLYGlNBFRESKlG8O/e1sG82swczaynFwM0sAuwN/Ksf+RERERqt8Cf3TZvYdM5tjZp+ywFeBvwFHlXpgM9sE+DVwprv/M8vz7Wa22MwWr1q1qtTDiYiI1DVz9+xPmN0K/IOg69oMYHOCle9nuPvSkg5qNg64HbjH3X8y3OunTZvmixcvLuWQIiIiI4aZLXH3aYW8J98c+nbuPjXc8S8J5r1b3P2tEmLEzAy4DHgySjIXERGR4eUbcu9P/eDu64EXSk3mob2B44D9zWxpeDuoDPsVEREZtfKdoe9qZqm5bQM2Dh8b4O7+7mIOGHZxU9EaERGRMsrXPnVMJQMRERGR4qnbmoiISB1QQhcREakDSugiIiJ1QAldRESkDiihi4iI1AEldBERkTqghC4iIlIHlNBFRETqgBK6iIhIHVBCFxERqQNK6CIiInVACV1ERKQOKKGLiIjUASV0ERGROqCELiIiUgeU0EVEROqAErqIiEgdUEIXERGpA0roIiIidUAJXUREpA4ooYuIiNQBJXQREZE6oIQuIiJSB5TQRURE6oASuoiISB1QQhcREakDSugiIiJ1QAldRESkDiihi4iI1AEldBERkTqghC4iIlIHlNBFRETqgBK6iIhIHVBCFxERqQNK6CIiInVACV1ERKQOKKGLiIjUASV0ERGROqCELiIiUgeU0EVEROqAErqIiEgdUEIXERGpA0roIiIidUAJXUREpA4ooYuIiNQBJXQREZE6oIQuIiJSB5TQRURE6kBVErqZHWhmfzGzZ8zsrGrEICIiUk8qntDNbAzw38BngB2BY8xsx0rHISIiUk+qcYb+EeAZd/+bu78NXAscWoU4RERE6kY1EvrWwPNpj18It4mIiEiRxlY7gFzMrB1oDx+uNbPHqhnPKDAJeKXaQYwC+p7jp+84fvqO4/f+Qt9QjYT+IrBt2uNtwm2DuHsX0AVgZovdfVplwhud9B1Xhr7n+Ok7jp++4/iZ2eJC31ONIfc/A+8zsylmthHwBeC2KsQhIiJSNyp+hu7u68zsNOAeYAxwubs/Xuk4RERE6klV5tDd/U7gzgLe0hVXLDJA33Fl6HuOn77j+Ok7jl/B37G5exyBiIiISAWp9KuIiEgdqOmErhKxlWFmy8ys28yWFrOyUoYys8vNbGX65ZZmNtHMfmtmT4f3m1UzxnqQ43s+18xeDH+fl5rZQdWMcaQzs23N7F4ze8LMHjezM8Lt+n0ukzzfcUG/yzU75B6WiP0r8EmC4jN/Bo5x9yeqGlgdMrNlwDR313WlZWJmHwfWAFe5+87hth8Br7r7D8I/UDdz929XM86RLsf3fC6wxt0vqGZs9cLMtgK2cveHzGxTYAlwGHAi+n0uizzf8VEU8Ltcy2foKhErI5a73w+8mrH5UGBu+PNcgn+wUoIc37OUkbuvcPeHwp9fB54kqO6p3+cyyfMdF6SWE7pKxFaOA78xsyVhhT6JxxbuviL8+e/AFtUMps6dZmaPhkPyGgouEzNLALsDf0K/z7HI+I6hgN/lWk7oUjn7uPuHCDrgnRoOY0qMPJjrqs35rpHvF8B7gd2AFcB/VTWaOmFmmwC/Bs5093+mP6ff5/LI8h0X9Ltcywk9UolYKZ27vxjerwRuJpjukPJ7OZwrS82ZraxyPHXJ3V929/XuvgG4FP0+l8zMxhEkmqS73xRu1u9zGWX7jgv9Xa7lhK4SsRVgZhPCRRiY2QTgU4Aa4cTjNuCE8OcTgFurGEvdSiWZ0OfQ73NJzMyAy4An3f0naU/p97lMcn3Hhf4u1+wqd4Bwif6FvFMitrO6EdUfM9uO4KwcgsqBv9L3XDozuwaYTtCV6mXgHOAW4HqgBegBjnJ3LegqQY7veTrBEKUDy4CvpM31SoHMbB/gAaAb2BBu/jeCOV79PpdBnu/4GAr4Xa7phC4iIiLR1PKQu4iIiESkhC4iIlIHlNBFRETqgBK6iIhIHVBCFxERqQNK6CIVZGZbmtm1ZvZsWGr3TjPbwcz+Zmbvz3jthWYWe7MLM3uXmf1v2M3p6IznrjSzI9MeTzKzfjObHT7+7/B9T5jZm2ldoY7MPI6IxGtstQMQGS3C4hE3A3Pd/Qvhtl0JamBfS1A86bxwewNwJLB3BULbHcDdd4vw2s8DfyS4PvYSdz8VBupP3x5xHwUxs7Huvq7c+xWpNzpDF6mc/YB+d78ktcHdH3H3B4BrgPSz448DPe7ek74DM9vKzO4Pz4IfM7N9w+2zzOyvZrbIzC41szmZBw/7V98SNnr4o5ntYmabA/OAD4f7fO8wn+EY4BvA1ma2TdQPbmZbmNnNZvZIeNvLzBI2uI/5/wtbn2JmC8MRisVAh5n1hH/kpKobPm9m48zsvWZ2dzja8YCZfSBqTCL1RgldpHJ2JuhzPIS7dwMbwjN2CM7Wr8ny0i8C94RnwrsCS8PykOcRnM3vA+yY4/jnAQ+7+y4EVaiuCuv3/yvwgLvv5u7P5grezLYl6Nm8iKBC2NG5XpvFxcB97r4r8CHg8Qjv2cjdp7n7ecBS4BPh9oMJvoN+oAv4qrvvAfw/4OcFxCRSV5TQRWrHNcAXzGwsQW/pG7K85s/ArPBMdmrYO3lPYKG7r3L3t4Hrcux/H+BqAHf/HdBsZu8uIL6jCRI5BFMExxTw3v0JOkcRNpvojfCe6zJ+Tv0B8QXgurAz1V7ADWa2FPgfYCtERinNoYtUzuME8+K5XAv8BrgPeNTdX858gbvfH7a3/SxwpZn9BPhn5uticgywpZm1hY//xcze5+5PF7m/dQw+qRif8fwbaT/fBpxvZhOBPYDfAROA1+KYtxcZiXSGLlI5vwPeZWbtqQ3hPPa+AOFw9yvAD8g+3I6ZtQIvu/ulwC8Jhq//BHzCzJrDFoyfz3H8B4C2cD/TgVcy+1rnYmY7AJu4+9bunnD3BPCfRD9LXwCcHO5rjJk1ETRT2TyM+10EQ+lZufsagtGJiwgW360PY3/OzD4f7tfSpixERh0ldJEK8aAT0ueAA8LL1h4nSIp/T3vZNcAHgJuy7AKCTmKPmNnDBEPQF4Xdl84F/gD8H/BkjveeC+xhZo8S/NFwQo7XZXMM73TlS/k10RP6GcB+ZtZNsI5gx3AO/HvAIuC3wFPD7OM64FgGD8W3ASeZ2SMEIyCHRoxHpO6o25pInTGzE4Fp7n5atWMRkcrRGbqIiEgd0Bm6iIhIHdAZuoiISB1QQhcREakDSugiIiJ1QAldRESkDiihi4iI1AEldBERkTrw/wHc4WxI5t/XRwAAAABJRU5ErkJggg==\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_large.csv', index= False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f6220a8",
   "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
}