IRAS Galaxies - (Improve MCMC) MC minimization with proposal function using L.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Freq: 5000000000000.0 \n",
      "r_s: 5 \n",
      "Flux Limit: 1.0791812460476249\n",
      "Luminosity cut-off (L_s): 1695173937237548.8 \n",
      "R_max: 80\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import random\n",
    "from math import sqrt\n",
    "from math import e\n",
    "from math import log\n",
    "import matplotlib.pyplot as plt\n",
    "import array\n",
    "import time\n",
    "\n",
    "'''IMP:\n",
    "Units: h * dist - km/s\n",
    "       h = 100 km/(s*Mpc)'''\n",
    "\n",
    "pi = np.pi\n",
    "freq = 5 * 1e12 #Hz. Freq of 60um band\n",
    "r_s = 5 #in Mpc r_s/h\n",
    "fm = np.log10(12) #log_10 of 1.2Jy in 0.1 Jy. Flux limit of the sample\n",
    "L_s = 4*pi*r_s**2 * freq * fm\n",
    "R_max = 80 #in Mpc\n",
    "print('Freq:', freq, '\\nr_s:', r_s, '\\nFlux Limit:', fm)\n",
    "print('Luminosity cut-off (L_s):', L_s, '\\nR_max:', R_max)\n",
    "\n",
    "data = pd.read_csv(\"Data/HEASARC/IRAS Galaxies_1.tsv\", delimiter = \"\\t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5667\n"
     ]
    }
   ],
   "source": [
    "'''Sorting Data to be used - Part 1'''\n",
    "\n",
    "objclass = data[\"class\"]\n",
    "objext = data[\"extend_flag\"]\n",
    "objredshift = data[\"helio_velocity\"]\n",
    "objf60qual = data[\"micron_flux_60_flag\"]\n",
    "objf12_1, objf25_1, objf100_1 = [], [], []\n",
    "objf60_1 = []\n",
    "\n",
    "#czarr_i = c * z units km/s\n",
    "czarr1, czarr = [], []\n",
    "for i in range(len(objclass)):\n",
    "    if (objclass[i] == \"GALAXY\" and objext[i] == 0 and objf60qual[i] == 2 or objf60qual[i] == 3):\n",
    "        if objredshift[i] == 0.0: continue\n",
    "        czarr1.append(float(objredshift[i]))\n",
    "        objf12_1.append(float(data[\"micron_flux_12\"][i]))\n",
    "        objf25_1.append(float(data[\"micron_flux_25\"][i]))\n",
    "        objf60_1.append(float(data[\"micron_flux_60\"][i]))\n",
    "        objf100_1.append(float(data[\"micron_flux_100\"][i]))\n",
    "\n",
    "objf12, objf25, objf100 = [], [], []\n",
    "objf60 = []\n",
    "for i in range(len(czarr1)):\n",
    "    if (float(czarr1[i]) >= 0.0 and str(czarr1[i]) != 'nan'):\n",
    "        czarr.append(czarr1[i]) #final zarr to be used\n",
    "        objf12.append(objf12_1[i])\n",
    "        objf25.append(objf25_1[i])\n",
    "        objf60.append(objf60_1[i])\n",
    "        objf100.append(objf100_1[i])\n",
    "        \n",
    "c = 299792458 #m/s Speed of light\n",
    "\n",
    "zarr = [float(1e3*x/c) for x in czarr] #redshift array\n",
    "print(len(zarr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5667\n"
     ]
    }
   ],
   "source": [
    "'''Comoving distance from redshift, Chi(z)'''\n",
    "\n",
    "H0 = 100.\n",
    "OM_m, OM_r, OM_de, OM_k = 0.28, 8.24e-5, 0.72, 0\n",
    "\n",
    "def H(z):\n",
    "    Hz = H0 * (1+z) * sqrt(OM_m*(1+z) + OM_r*(1+z)**2. + OM_de/(1+z)**2. + OM_k)\n",
    "    return Hz\n",
    "\n",
    "def dist(z1_, z2_):\n",
    "    n = 1000\n",
    "    ztemp = np.empty(n+1)\n",
    "    h = (z2_ - z1_)/float(n)\n",
    "    ztemp[0] = z1_\n",
    "    f_even, f_odd = 0., 0.\n",
    "    for i in range(1, n+1):\n",
    "        ztemp[i] = z1_ + float(i) * h\n",
    "    for i in range(1, int(n/2)):\n",
    "        zz = ztemp[2*i]\n",
    "        f_even = f_even + (1. / H(zz))\n",
    "    for i in range(1, int(n/2)+1):\n",
    "        zz = ztemp[2*i-1]\n",
    "        f_odd = f_odd + (1. / H(zz))\n",
    "    fz1 = (1. / H(z1_))\n",
    "    fz2 = (1. / H(z2_))\n",
    "    integral = h/3. * c / 1e3 * (fz1 + 2.*f_even + 4.*f_odd + fz2)\n",
    "    return integral\n",
    "\n",
    "#Comoving distance array\n",
    "distarr = [float(dist(0., x)) for x in zarr] #values in Mpc\n",
    "print(len(distarr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3375\n"
     ]
    }
   ],
   "source": [
    "'''Sorting Data to be used - Part 2'''\n",
    "\n",
    "#subset distances in [r_s, R_max] for use in fitting\n",
    "darr1, obj1f60 = [], []\n",
    "for i in range(len(distarr)):\n",
    "    if (distarr[i] >= r_s and distarr[i] <= R_max and objf60[i] >= fm):\n",
    "        darr1.append(distarr[i])\n",
    "        obj1f60.append(objf60[i])\n",
    "print(len(darr1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax1 = fig.add_subplot(111)\n",
    "ax1.hist(100*np.array(darr1), bins=np.logspace(np.log10(1e2),np.log10(1e5), 45), histtype = 'step')\n",
    "#ax1.plot(distvals, phivals)\n",
    "ax1.set_xscale('log')\n",
    "#ax1.set_ylim(0, 20)\n",
    "#ax1.set_xlim(0, 1000)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#f60 = [0.1*10**x for x in obj1f60] #in Jy.\n",
    "darr1 = np.array(darr1)\n",
    "f60 = np.array(obj1f60) #in log_10 of flux in 0.1 Jy.\n",
    "lumino = 4*pi*darr1**2 * freq * f60\n",
    "#fm = 1.2\n",
    "\n",
    "#Only for testing until we get flux limit:\n",
    "#fm = min(f60) #log_10 of 1.2Jy in 0.1 Jy. Flux limit of the sample\n",
    "#L_s = 4*np.pi*r_s**2 * freq * fm\n",
    "#--\n",
    "\n",
    "#Yet to convert to numpy arrays\n",
    "def phi(r, alpha, beta, r_star): #Galaxy Selection function\n",
    "    A = r_s**(2*alpha) * (1 + (r_s**2./r_star**2.))**beta\n",
    "    return A * r**(-2*alpha) * (1 + (r**2./r_star**2.))**-beta\n",
    "#------------------------------\n",
    "\n",
    "def PSI(L_arr, alpha, beta, r_star): #Cumulative Luminosity function\n",
    "    L_star = 4*pi*r_star**2. * freq * fm\n",
    "    C = 1 #\n",
    "    return C * (L_arr/L_star)**-alpha * (1 + L_arr/L_star)**-beta\n",
    "\n",
    "def PHI(L_arr, alpha, beta, r_star): #Luminosity function\n",
    "    L_star = 4*pi*r_star**2. * freq * fm\n",
    "    return (alpha/L_arr + beta/(L_star + L_arr)) * PSI(L_arr, alpha, beta, r_star)\n",
    "\n",
    "def probf(r_arr, L_arr, alpha, beta, r_star): #Probability function \"f(Li|ri)\"\n",
    "    size = len(r_arr)\n",
    "    Lm = np.maximum(L_s, 4*pi*r_arr**2 * freq * fm)\n",
    "    return_array = (L_arr >= Lm) * PHI(L_arr, alpha, beta, r_star) / PSI(Lm, alpha, beta, r_star)\n",
    "    return return_array\n",
    "    \n",
    "#Likelihood function\n",
    "#returns a POSITIVE value (COST that the algorithm pays at the given vales of parameters)\n",
    "def lhdfunc(params):\n",
    "    alpha, beta, r_star = params[0], params[1], params[2]\n",
    "    f = probf(darr1, lumino, alpha, beta, r_star)\n",
    "    value = np.sum(np.log(f))\n",
    "    #print('COST:', -2 * value)\n",
    "    return -2 * value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Getting L matrix\n",
    "\n",
    "L = np.load('Cholesky_decomp_L.npy')\n",
    "scale_fac = 2*0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "####---- Monte-Carlo Minimization Functions----####\n",
    "\n",
    "def mcmc_min(niter, ini_vals):\n",
    "    #niter = 1e6\n",
    "    i, k = 0, 0\n",
    "    \n",
    "    alpha, beta, r_star = ini_vals[0], ini_vals[1], ini_vals[2] #initial guess\n",
    "    \n",
    "    acc_alphas, acc_betas, acc_r_stars = np.empty(0), np.empty(0), np.empty(0) #arrays to store all accepted parameter values\n",
    "    costarr = np.empty(0) #array to store cost (from likelihood func) at all accepted values\n",
    "    \n",
    "    f_old = lhdfunc(array.array('f', [alpha, beta, r_star])) #OLD COST (from likelihood func)\n",
    "    \n",
    "    while i < int(niter):\n",
    "        eta = np.random.normal(size = (3, 1))\n",
    "        inc = scale_fac * np.dot(L, eta)\n",
    "        inc_alpha, inc_beta, inc_r_star = inc[0, 0], inc[1, 0], inc[2, 0] #increments to parameters\n",
    "        #increments based on new proposal function:\n",
    "        #params[i+1] = params[i] + scale_fac * matmul(L x eta)\n",
    "        #where, eta is a vector of Gaussian variates\n",
    "    \n",
    "        guess = array.array('f', [alpha + inc_alpha, beta + inc_beta, r_star + inc_r_star]) #new parameters\n",
    "        f_new = lhdfunc(guess) #NEW COST (from likelihood func)\n",
    "    \n",
    "        #print('f_old =', f_old, 'f_new =', f_new)\n",
    "        #f_ratio = e**(-f_new) / e**(-f_old) #\"Gives wrong value due to large power of e\"\n",
    "        #print('f_ratio =', f_ratio)\n",
    "    \n",
    "        differ_f = f_new - f_old #Using difference method as above commented code doesn't work\n",
    "    \n",
    "        #if (f_ratio >= 1): #Accept if f_ratio >= 1\n",
    "        if differ_f <= 0: #\"OR\" Accept if differ_f <= 0\n",
    "            alpha, beta, r_star = alpha + inc_alpha, \\\n",
    "            beta + inc_beta, r_star + inc_r_star #Accept the parameters\n",
    "            acc_alphas = np.insert(acc_alphas, k, alpha)\n",
    "            acc_betas = np.insert(acc_betas, k, beta)\n",
    "            acc_r_stars = np.insert(acc_r_stars, k, r_star)\n",
    "            costarr = np.insert(costarr, k, f_new)\n",
    "            f_old = f_new #Set new COST as old COST for next iteration\n",
    "            k += 1\n",
    "    \n",
    "        else: #Accept if uniform random number(u) <= f_ratio\n",
    "            #\"OR\" Accept if u <= e**(-differ_f)\n",
    "            u = random.uniform(0, 1)\n",
    "            #if (u <= f_ratio):\n",
    "            if (u <= e**(-differ_f)):\n",
    "                alpha, beta, r_star = alpha + inc_alpha, beta + inc_beta, r_star + inc_r_star #Accept the parameters\n",
    "                acc_alphas = np.insert(acc_alphas, k, alpha)\n",
    "                acc_betas = np.insert(acc_betas, k, beta)\n",
    "                acc_r_stars = np.insert(acc_r_stars, k, r_star)\n",
    "                costarr = np.insert(costarr, k, f_new)\n",
    "                f_old = f_new #Set new COST as old COST for next iteration\n",
    "                k += 1\n",
    "    \n",
    "        i += 1\n",
    "        if (i % 2e4 == 0): print('Iter: %d K, \\tcurrent acc_ratio = %.3f' % (i/1e3, k/i))\n",
    "    \n",
    "    accratio = k/niter\n",
    "    print(\"Number of accepted values: %d out of %d\" % (k, niter))\n",
    "    print(\"Acceptance ratio is %.3f\" % accratio)\n",
    "    \n",
    "    return [k, acc_alphas, acc_betas, acc_r_stars, costarr]\n",
    "\n",
    "def plot_min(params, se, ini_vals, mean, std): #se = [start, end]\n",
    "    costarr, acc_alphas, acc_betas, acc_r_stars = params[0], params[1], params[2], params[3]\n",
    "    \n",
    "    figure = plt.figure(figsize = (12, 7))\n",
    "    \n",
    "    ax1 = figure.add_subplot(221)\n",
    "    ax1.plot(costarr[se[0]:se[1]])\n",
    "    ax1.set_title('COST')\n",
    "    \n",
    "    ax2 = figure.add_subplot(222)\n",
    "    ax2.plot(acc_alphas[se[0]:se[1]])\n",
    "    ax2.set_title('alpha')\n",
    "    \n",
    "    ax3 = figure.add_subplot(223)\n",
    "    ax3.plot(acc_betas[se[0]:se[1]])\n",
    "    ax3.set_title('beta')\n",
    "    \n",
    "    ax4 = figure.add_subplot(224)\n",
    "    ax4.plot(acc_r_stars[se[0]:se[1]])\n",
    "    ax4.set_title('r_star')\n",
    "    \n",
    "    figure.suptitle('Initial parameter values: alpha = %.2f, beta = %.2f, rstar = %.2f\\\n",
    "    \\nBest-fit values: alpha = %.3f +- %.3f, beta = %.3f +- %.3f, rstar = %.3f +- %.3f' \\\n",
    "                    % (ini_vals[0], ini_vals[1], ini_vals[2], mean[0], std[0], \\\n",
    "                       mean[1], std[1], mean[2], std[2]), fontsize = 14)\n",
    "    \n",
    "    plt.savefig('IC_alpha_%.2f_beta_%.2f_rstar_%.2f.png' % (ini_vals[0], ini_vals[1], ini_vals[2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting Chain 1\n",
      "IC: alpha = 0.20, beta = 1.20, r_star = 30.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.621\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.622\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.624\n",
      "Number of accepted values: 37457 out of 60000\n",
      "Acceptance ratio is 0.624\n",
      "\n",
      "Mean +- sigma parameter values for Chain 1:\n",
      "alpha \t= 0.4653 +- 0.0288\n",
      "beta \t= 2.0584 +- 0.1340\n",
      "r_star \t= 71.8736 +- 5.9203\n",
      "\n",
      "\n",
      "Starting Chain 2\n",
      "IC: alpha = 0.25, beta = 1.36, r_star = 38.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.626\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.628\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.627\n",
      "Number of accepted values: 37609 out of 60000\n",
      "Acceptance ratio is 0.627\n",
      "\n",
      "Mean +- sigma parameter values for Chain 2:\n",
      "alpha \t= 0.4639 +- 0.0282\n",
      "beta \t= 2.0541 +- 0.1314\n",
      "r_star \t= 71.5342 +- 5.7093\n",
      "\n",
      "\n",
      "Starting Chain 3\n",
      "IC: alpha = 0.30, beta = 1.52, r_star = 46.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.630\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.629\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.626\n",
      "Number of accepted values: 37549 out of 60000\n",
      "Acceptance ratio is 0.626\n",
      "\n",
      "Mean +- sigma parameter values for Chain 3:\n",
      "alpha \t= 0.4659 +- 0.0280\n",
      "beta \t= 2.0578 +- 0.1300\n",
      "r_star \t= 71.8915 +- 5.7588\n",
      "\n",
      "\n",
      "Starting Chain 4\n",
      "IC: alpha = 0.35, beta = 1.68, r_star = 54.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.629\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.630\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.629\n",
      "Number of accepted values: 37738 out of 60000\n",
      "Acceptance ratio is 0.629\n",
      "\n",
      "Mean +- sigma parameter values for Chain 4:\n",
      "alpha \t= 0.4652 +- 0.0286\n",
      "beta \t= 2.0582 +- 0.1328\n",
      "r_star \t= 71.8467 +- 5.8433\n",
      "\n",
      "\n",
      "Starting Chain 5\n",
      "IC: alpha = 0.40, beta = 1.84, r_star = 62.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.630\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.629\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.625\n",
      "Number of accepted values: 37504 out of 60000\n",
      "Acceptance ratio is 0.625\n",
      "\n",
      "Mean +- sigma parameter values for Chain 5:\n",
      "alpha \t= 0.4650 +- 0.0279\n",
      "beta \t= 2.0567 +- 0.1315\n",
      "r_star \t= 71.7337 +- 5.7589\n",
      "\n",
      "\n",
      "Starting Chain 6\n",
      "IC: alpha = 0.45, beta = 2.00, r_star = 70.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.624\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.625\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.625\n",
      "Number of accepted values: 37499 out of 60000\n",
      "Acceptance ratio is 0.625\n",
      "\n",
      "Mean +- sigma parameter values for Chain 6:\n",
      "alpha \t= 0.4642 +- 0.0287\n",
      "beta \t= 2.0510 +- 0.1315\n",
      "r_star \t= 71.4880 +- 5.7870\n",
      "\n",
      "\n",
      "Starting Chain 7\n",
      "IC: alpha = 0.50, beta = 2.16, r_star = 78.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.630\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.629\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.629\n",
      "Number of accepted values: 37739 out of 60000\n",
      "Acceptance ratio is 0.629\n",
      "\n",
      "Mean +- sigma parameter values for Chain 7:\n",
      "alpha \t= 0.4648 +- 0.0282\n",
      "beta \t= 2.0565 +- 0.1329\n",
      "r_star \t= 71.7491 +- 5.8591\n",
      "\n",
      "\n",
      "Starting Chain 8\n",
      "IC: alpha = 0.55, beta = 2.32, r_star = 86.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.625\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.627\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.627\n",
      "Number of accepted values: 37600 out of 60000\n",
      "Acceptance ratio is 0.627\n",
      "\n",
      "Mean +- sigma parameter values for Chain 8:\n",
      "alpha \t= 0.4642 +- 0.0280\n",
      "beta \t= 2.0567 +- 0.1307\n",
      "r_star \t= 71.6896 +- 5.7055\n",
      "\n",
      "\n",
      "Starting Chain 9\n",
      "IC: alpha = 0.60, beta = 2.48, r_star = 94.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.628\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.627\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.627\n",
      "Number of accepted values: 37601 out of 60000\n",
      "Acceptance ratio is 0.627\n",
      "\n",
      "Mean +- sigma parameter values for Chain 9:\n",
      "alpha \t= 0.4647 +- 0.0288\n",
      "beta \t= 2.0565 +- 0.1309\n",
      "r_star \t= 71.7277 +- 5.8049\n",
      "\n",
      "\n",
      "Starting Chain 10\n",
      "IC: alpha = 0.65, beta = 2.64, r_star = 102.00\n",
      "Iter: 20 K, \tcurrent acc_ratio = 0.624\n",
      "Iter: 40 K, \tcurrent acc_ratio = 0.626\n",
      "Iter: 60 K, \tcurrent acc_ratio = 0.625\n",
      "Number of accepted values: 37521 out of 60000\n",
      "Acceptance ratio is 0.625\n",
      "\n",
      "Mean +- sigma parameter values for Chain 10:\n",
      "alpha \t= 0.4640 +- 0.0284\n",
      "beta \t= 2.0531 +- 0.1317\n",
      "r_star \t= 71.5419 +- 5.7995\n",
      "\n",
      "\n",
      "10 chain(s) done successfully!\n"
     ]
    }
   ],
   "source": [
    "#Run MCMC Minimization for N_chain chains\n",
    "\n",
    "N_chain = 10\n",
    "niter = int(6e4)\n",
    "\n",
    "'''actual values are:\n",
    "alpha = 0.527 +- 0.034, beta = 1.78 +- 0.078, r_star = 44.00 +- 2.30'''\n",
    "\n",
    "'''my values for Initial Chain:\n",
    "alpha = 0.4640 +- 0.0294, beta = 2.0477 +- 0.1321, r_star = 71.3751 +- 5.8127'''\n",
    "\n",
    "#Initial values within 10 sigma of Initial Chain\n",
    "initialal = np.linspace(0.2, 0.7, N_chain+1)\n",
    "initialbt = np.linspace(1.2, 2.8, N_chain+1)\n",
    "initialrs = np.linspace(30, 110, N_chain+1)\n",
    "\n",
    "#Arrays to store accepted parameter values\n",
    "alpha2Darr, beta2Darr, rstar2Darr, cost2Darr = np.zeros([N_chain, niter]), \\\n",
    "np.zeros([N_chain, niter]), np.zeros([N_chain, niter]), np.zeros([N_chain, niter])\n",
    "#different chains are stored in rows\n",
    "#1st column in each row denotes the number of accepted values in the chain\n",
    "#2nd column onwards, accepted values in that chain are stored.\n",
    "\n",
    "#Mean and std for each chain.\n",
    "u_al, u_bt, u_rs = np.zeros(N_chain), np.zeros(N_chain), np.zeros(N_chain)\n",
    "std_al, std_bt, std_rs = np.zeros(N_chain), np.zeros(N_chain), np.zeros(N_chain)\n",
    "\n",
    "np.random.seed(0)\n",
    "\n",
    "for i in range(N_chain):\n",
    "    print('Starting Chain', i+1)\n",
    "    print('IC: alpha = %.2f, beta = %.2f, r_star = %.2f' % (initialal[i], initialbt[i], initialrs[i]))\n",
    "    \n",
    "    ini_vals = [initialal[i], initialbt[i], initialrs[i]] #initial values\n",
    "    \n",
    "    return_arr = mcmc_min(niter, ini_vals) #MCMC minimization\n",
    "    \n",
    "    #Store accepted parameter values\n",
    "    k, alphas, betas, rstars, costarr = return_arr[0], return_arr[1], return_arr[2], return_arr[3], return_arr[4]\n",
    "    alpha2Darr[i, 0], beta2Darr[i, 0], rstar2Darr[i, 0], cost2Darr[i, 0] = k, k, k, k\n",
    "    alpha2Darr[i, 1:k+1], beta2Darr[i, 1:k+1], rstar2Darr[i, 1:k+1] = alphas, betas, rstars\n",
    "    cost2Darr[i, 1:k+1] = costarr\n",
    "    \n",
    "    burn_end = 1500\n",
    "    \n",
    "    #Calculate, store mean and std\n",
    "    u_al[i], u_bt[i], u_rs[i] = np.mean(alphas[burn_end:]), np.mean(betas[burn_end:]), np.mean(rstars[burn_end:])\n",
    "    std_al[i], std_bt[i], std_rs[i] = np.std(alphas[burn_end:]), np.std(betas[burn_end:]), np.std(rstars[burn_end:])\n",
    "    u_params, std_params = [u_al[i], u_bt[i], u_rs[i]], [std_al[i], std_bt[i], std_rs[i]] #bundle mean, std for further use\n",
    "    \n",
    "    #plot_params = [costarr, alphas, betas, rstars]\n",
    "    #plot_min(plot_params, [0, k], ini_vals, u_params, std_params) #Save plots\n",
    "    \n",
    "    print('\\nMean +- sigma parameter values for Chain %d:' % (i+1))\n",
    "    print('alpha \\t= %.4f +- %.4f' % (u_al[i], std_al[i]))\n",
    "    print('beta \\t= %.4f +- %.4f' % (u_bt[i], std_bt[i]))\n",
    "    print('r_star \\t= %.4f +- %.4f' % (u_rs[i], std_rs[i]))\n",
    "    \n",
    "    #temp = input('%d chain(s) done! Plot saved.\\nPress <ENTER> to proceed.' % (i+1))\n",
    "    print('\\n')\n",
    "\n",
    "print(N_chain, 'chain(s) done successfully!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "alpha \t= 0.4648 +- 0.0284\n",
      "beta \t= 2.0560 +- 0.1317\n",
      "r_star \t= 71.7144 +- 5.7952\n"
     ]
    }
   ],
   "source": [
    "#Overall mean and std\n",
    "\n",
    "al_list, bt_list, rs_list = [], [], []\n",
    "num_all = 0\n",
    "burn_end = 2000\n",
    "for i in range(N_chain):\n",
    "    k = int(alpha2Darr[i, 0])\n",
    "    al_list.extend(alpha2Darr[i, burn_end:k+1])\n",
    "    bt_list.extend(beta2Darr[i, burn_end:k+1])\n",
    "    rs_list.extend(rstar2Darr[i, burn_end:k+1])\n",
    "mean_alpha, std_alpha = np.mean(al_list), np.std(al_list)\n",
    "mean_beta, std_beta = np.mean(bt_list), np.std(bt_list)\n",
    "mean_r_star, std_r_star = np.mean(rs_list), np.std(rs_list)\n",
    "print('alpha \\t= %.4f +- %.4f' % (mean_alpha, std_alpha))\n",
    "print('beta \\t= %.4f +- %.4f' % (mean_beta, std_beta))\n",
    "print('r_star \\t= %.4f +- %.4f' % (mean_r_star, std_r_star))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Okay! Saved!\n"
     ]
    }
   ],
   "source": [
    "#Save accepted parameter lists\n",
    "\n",
    "np.savez('MC_%dchains_iter_%deach.npz' % (N_chain, niter),\n",
    "         burn = burn_end,\n",
    "         ini_alpha = initialal,\n",
    "         ini_beta = initialbt,\n",
    "         ini_r_star = initialrs,\n",
    "         mean_alpha = u_al,\n",
    "         std_alpha = std_al,\n",
    "         mean_beta = u_bt,\n",
    "         std_beta = std_bt,\n",
    "         mean_r_star = u_rs,\n",
    "         std_r_star = std_rs,\n",
    "         alpha_arr = alpha2Darr,\n",
    "         beta_arr = beta2Darr,\n",
    "         r_star_arr = rstar2Darr,\n",
    "         cost_arr = cost2Darr\n",
    "        )\n",
    "print('Okay! Saved!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3deXxcVfn48c8zmcm+NVuXpCXp3hJKadMClqWUIossilWpgCAgX1FU+Lp89etXRJSfiriAoMim4AKyCRXQsqqUrTtdKd3bpEvStNmbZWae3x/3Jp2W7MlkMpPn/Xrd19x77pk7z81Anznn3HuuqCrGGGMMgCfSARhjjBk8LCkYY4xpY0nBGGNMG0sKxhhj2lhSMMYY08aSgjHGmDaWFEzUEREVkfFhOG6diIwNw3EnichqEakVka/29/E7+dwx7jnFDdRnmuhnScFEhIicJiJviUi1iBwUkTdFZNYAfv6/ROS60DJVTVXVbWH4uG8Br6tqmqreHYbjAyAiO0Rkfuu2qu5yzykQrs80sceSghlwIpIOPA/8GsgC8oEfAE2RjCuMjgPWRzoIY7rDkoKJhIkAqvqYqgZU9bCqvqSqa1oriMg1IrJRRA6JyGIROa69A4lIgojcKSK7RGS/iNwnIkkh+y9xu25qRGSriJwnIrcDpwP3uN0r97h127qlRCRDRB4VkQoR2Ski/yciHnff1SKyxP3cQyKyXUTO7yC+14CzQj5r4rGtlNbjhWyriHxRRDaLSJWI3CsiErL/C+7fplZENojIDBH5IzAG+Lv7Od8SkUL3WF73faNEZJHbMtsiIl8IOeatIvKEe861IrJeREq6/5WaWGFJwUTCB0BARB4RkfNFZFjoThG5BPhf4FIgF3gDeKyDY/0EJ8lMB8bjtDpucY8zG3gU+CaQCZwB7FDV77rHvNHtXrmxneP+GsgAxgJnAp8DPh+y/2RgE5AD3AE8FPoPdytVnXfMZ33Q2R8mxIXALGAa8GngXPecPgXc6saTDlwMVKrqlcAu4CL3c+5o55iPA6XAKGAB8P9EZF7I/ovdOpnAIuCebsZqYoglBTPgVLUGOA1Q4AGgwv0FO9yt8kXgx6q6UVX9wP8Dph/bWnD/Eb4euFlVD6pqrVv3MrfKtcDDqvqyqgZVtUxV3+8qPndg9jLgO6paq6o7gJ8DV4ZU26mqD7j99Y8AI4HhHzpY7/1EVatUdRfwOk7SA7gOuENVl6lji6ru7MY5jQbmAP+jqo2quhp4ECe5tFqiqi+65/RH4MR+PB8TJSwpmIhw/8G/WlULgGKcX6+/cncfB9zldp1UAQcBwWkFhMoFkoEVIXX/6ZYDjAa29iK8HMAHhP5ju/OYz98Xci4N7mpqLz6rI/tC1htCjt3bcxoFtCbOVh2ek/uZia1dT2bosKRgIs799f4HnOQAsBv4L1XNDFmSVPWtY956ADgMHB9SL0NVU0OOM66jj+0kpANAC05yajUGKOv+WXWqHieZtRrRg/f29pz2AFkikhZS1p/nZGKEJQUz4ERksoh8XUQK3O3RwELgHbfKfcB3ROR4d3+G25d+FFUN4nQ//VJE8ty6+SJyrlvlIeDzInK2iHjcfZPdfftxxgs+xO0+eQK4XUTS3G6r/wb+1PezB2A1cKmIJLsD29f24L0PAt8QkZniGB/SrdbZOe0G3gJ+LCKJIjLN/dz+OicTIywpmEioxRmofVdE6nGSwTrg6wCq+jfgp8DjIlLj7mv36h7gf4AtwDtu3VeASe5xluIMDv8SqAb+zZFf/3cBC9yrh9q7d+ArOL/otwFLgL8AD/fhnEP9EmjG+Uf8EeDP3X2jqj4J3O7GUws8i3NZL8CPgf9zu9K+0c7bFwKFOK2GvwHfV9VXenkOJkaJPWTHGGNMK2spGGOMaWNJwRhjTBtLCsYYY9pYUjDGGNMm6m5MycnJ0cLCwkiHYYwxUWXFihUHVDW3q3pRlxQKCwtZvnx5pMMwxpioIiJdTocC1n1kjDEmhCUFY4wxbSwpGGOMaRN1YwrGGNOZlpYWSktLaWxsjHQoEZGYmEhBQQE+n69X77ekYIyJKaWlpaSlpVFYWEg7zz2KaapKZWUlpaWlFBUV9eoYYes+EpGHRaRcRNZ1sF9E5G73sYBrRGRGuGIxxgwdjY2NZGdnD7mEACAiZGdn96mVFM4xhT8A53Wy/3xggrtcD/w2jLEYY4aQoZgQWvX13MPWfaSq/xGRwk6qXAI8qs40re+ISKaIjFTVveGIZ+O7i6leu7jX79c4HxMv+ArZwwv6MSpjjBlcIjmmkI/zFKlWpW7Zh5KCiFyP05pgzJgxvfqw6g/eZPbu3k2H7xFnevF3Xk0l+7Pf69UxjDEmGkTFQLOq3g/cD1BSUtKrB0CccuVtwG29+/xgkOYf5CG1+7qubIwxA8jv9+P19t8/5ZG8T6EM5yHkrQoYpM+LFY+HShmGr6E80qEYY6LAjh07mDx5MpdffjlTpkxhwYIFNDQ0cNtttzFr1iyKi4u5/vrraX3I2dy5c/na177G9OnTKS4uZunSpQDU19dzzTXXMHv2bE466SSee+45AP7whz9w8cUXM2/ePM4+++x+jT2SLYVFwI0i8jjOoxmrwzWe0B+q4rJIbKqIdBjGmB74wd/Xs2FPTb8ec+qodL5/0fFd1tu0aRMPPfQQc+bM4ZprruE3v/kNN954I7fccgsAV155Jc8//zwXXXQRAA0NDaxevZr//Oc/XHPNNaxbt47bb7+defPm8fDDD1NVVcXs2bOZP38+ACtXrmTNmjVkZWV1GENvhC0piMhjwFwgR0RKge8DPgBVvQ94EbgA5/m6DTjP0h206n3ZDG/Z3XVFY4wBRo8ezZw5cwC44ooruPvuuykqKuKOO+6goaGBgwcPcvzxx7clhYULFwJwxhlnUFNTQ1VVFS+99BKLFi3izjvvBJzLbXft2gXAOeec0+8JAcJ79dHCLvYr8OVwfX5/a0zMJbPxvUiHYYzpge78og+XYy8NFRG+9KUvsXz5ckaPHs2tt9561P0E7dVXVZ5++mkmTZp01L53332XlJSUsMRtcx91kz85j3TqoGVo3jpvjOmZXbt28fbbbwPwl7/8hdNOOw2AnJwc6urqeOqpp46q/9e//hWAJUuWkJGRQUZGBueeey6//vWv28YeVq1aFfa4o+Lqo8FAU4cD0FS1l4Tc3t0+bowZOiZNmsS9997LNddcw9SpU7nhhhs4dOgQxcXFjBgxglmzZh1VPzExkZNOOomWlhYefti5fP573/seN910E9OmTSMYDFJUVMTzzz8f1rgtKXRTXPoIAKoPlJFnScEY0wWv18uf/vSno8p+9KMf8aMf/ajd+ldccQW/+tWvjipLSkrid7/73YfqXn311Vx99dX9Fmso6z7qpoRh+QA0VJZGOBJjjAkfayl0U3L2KACaDg3aq2aNMYNEYWEh69a1Oxdou/71r3+FL5gespZCN2VkjySgQrDGkoIxJnZZUuim7PRkDpABdfsjHYoxxoSNJYVuSomPowKb6sIYE9ssKXSTiFBtU10YY2KcJYUeqPPlkNpSGekwjDEmbCwp9EBjYg5pgSoIBiIdijEmRvn9/oh+viWFHvAn5RFHEOqtC8kY07lf/OIXFBcXU1xczK9+9St27NhBcXFx2/4777yTW2+9FXCmzr7pppsoKSnhrrvu4sknn6S4uJgTTzyRM844Y0DjtvsUeqB1qgut3YukjYhwNMaYLv3j27Bvbf8ec8QJcP5POq2yYsUKfv/73/Puu++iqpx88smceeaZnb6nubmZ5cuXA3DCCSewePFi8vPzqaqq6rfQu8NaCj3QOtVFo93AZozpxJIlS/jEJz5BSkoKqampXHrppbzxxhudvuczn/lM2/qcOXO4+uqreeCBBwgEBra72loKPXBkqosykiIcizGmG7r4RT+QqqqqCAaDbduh02YDR02Ffd999/Huu+/ywgsvMHPmTFasWEF2dvaAxGkthR5IzhoJODOlGmNMR04//XSeffZZGhoaqK+v529/+xvnn38+5eXlVFZW0tTU1Olsp1u3buXkk0/mtttuIzc3l927B+4BX9ZS6IGsjDQOaSqBaksKxpiOzZgxg6uvvprZs2cDcN111zFr1ixuueUWZs+eTX5+PpMnT+7w/d/85jfZvHkzqsrZZ5/NiSeeOFChI60Pb4gWJSUl2joYM9DKqg5T94sSkkdOYvQNz0QkBmNM5zZu3MiUKVMiHUZEtfc3EJEVqlrS1Xut+6gHslPiKddMm+rCGBOzLCn0QKIvjoOeYTbVhTEmZllS6KH61qkuoqzbzZihJNq6xftTX8/dkkIPHU7MxastcPhQpEMxxrQjMTGRysrKIZkYVJXKykoSExN7fQy7+qiH/Em5UIfzXIXkrEiHY4w5RkFBAaWlpVRUDM1u3sTERAoKCnr9fksKPaSpw6ECqN0HeUP7CgdjBiOfz0dRUVGkw4ha1n3UQ3Hpzg1sWrsvwpEYY0z/s6TQQwnDRgHQeGhPhCMxxpj+Z0mhh9IzhlGlKTRX7ox0KMYY0+8sKfRQdmo8uzQPPbQj0qEYY0y/s6TQQ9kpCezSPHzVOyIdijHG9DtLCj3ktBSGk1hfZo/lNMbEHEsKPZSVEs9uzSNO/VBjg83GmNgS1qQgIueJyCYR2SIi325n/xgReV1EVonIGhG5IJzx9AdfnIeaROdhO9i4gjEmxoQtKYhIHHAvcD4wFVgoIlOPqfZ/wBOqehJwGfCbcMXTn1oyCp2VQ9sjGocxxvS3cLYUZgNbVHWbqjYDjwOXHFNHgXR3PQOIiv6YhOzR+ImzloIxJuaEMynkA6HPkCt1y0LdClwhIqXAi8BX2juQiFwvIstFZPlgmM9k5LBUyjTHLks1xsScSA80LwT+oKoFwAXAH0XkQzGp6v2qWqKqJbm5uQMe5LHyM5PYGczDf2BbpEMxxph+Fc6kUAaMDtkucMtCXQs8AaCqbwOJQE4YY+oXozKT2KV5iLUUjDExJpxJYRkwQUSKRCQeZyB50TF1dgFnA4jIFJykEPn+oS7ku0nB23QIGqsjHY4xxvSbsCUFVfUDNwKLgY04VxmtF5HbRORit9rXgS+IyHvAY8DVGgVPxnCSwnBn45DNgWSMiR1hfZ6Cqr6IM4AcWnZLyPoGYE44YwiH9CQvFV5nCm0ObYeR0yIbkDHG9JNIDzRHJREhkDnG2bBxBWNMDLGk0EuZw3KolnRLCsaYmGJJoZfyM5PYrblw0O5qNsbEDksKvTQqM4ltgTyC1lIwxsQQSwq9VDDMvVehejcE/JEOxxhj+oUlhV5qu4Et6IeaY+/JM8aY6GRJoZeOvlfBxhWMMbHBkkIv5aUlUEprUtgR0ViMMaa/WFLoJW+cB0kbiR+vXYFkjIkZlhT6YOSwVPZ486Hi/UiHYowx/cKSQh+MykxkU3A07N8Q6VCMMaZfWFLog/xhSbzXnA/Vu6CxJtLhGGNMn1lS6INRmUlsDBY4G+UbIxuMMcb0A0sKfZCfmcQmdSfGK18f2WCMMaYfWFLog/zMJEo1hxZvio0rGGNigiWFPhiVmQQIlcnjoNySgjEm+llS6IOUBC/Dkn3s9BbC/vUw+B8aZ4wxnbKk0EfjclNZ11IAjVVQuzfS4RhjTJ9YUuijcbmpvFPvTndh4wrGmChnSaGPxuelsrTBfV6zXYFkjIlylhT6aHxeKtWk0pw83FoKxpioZ0mhj8blpgJQmTzeWgrGmKhnSaGP8oclkeD1sMN7HFR8YE9hM8ZENUsKfRTnEYpyUpwrkAJNcHBrpEMyxphes6TQD8bnpfJO/QhnY791IRljopclhX4wLjeVJdVZqMTZnc3GmKhmSaEfjM9LpUnjac4cB3vXRDocY4zpNUsK/aD1CqT9acVQusymuzDGRC1LCv1gbG4KIvBB/GQ4fBAqbbDZGBOdLCn0g0RfHAXDkni3ZbxTULo0sgEZY0wvhTUpiMh5IrJJRLaIyLc7qPNpEdkgIutF5C/hjCecxuem8mZ1DiSkw25LCsaY6OQN14FFJA64FzgHKAWWicgiVd0QUmcC8B1gjqoeEpG8cMUTbuNyU3lrayU6cSZSuizS4RhjTK+Es6UwG9iiqttUtRl4HLjkmDpfAO5V1UMAqloexnjCanxeKk3+IDU5JzmXpTbVRjokY4zpsXAmhXxgd8h2qVsWaiIwUUTeFJF3ROS89g4kIteLyHIRWV5RURGmcPtmXJ5zBdKOpONBg1C2IsIRGWNMz0V6oNkLTADmAguBB0Qk89hKqnq/qpaoaklubu4Ah9g9493LUt9Td7B5t3UhGWOiTziTQhkwOmS7wC0LVQosUtUWVd0OfICTJKLOsJR4slLiWX/QAzmT7AokY0xUCmdSWAZMEJEiEYkHLgMWHVPnWZxWAiKSg9OdtC2MMYXV1JHprN9bDaNn2U1sxpioFLakoKp+4EZgMbAReEJV14vIbSJysVttMVApIhuA14FvqmpluGIKtxMKMti0r5aWkSVw+JDdxGaMiTphuyQVQFVfBF48puyWkHUF/ttdot60/AxaAsrWxOOZDE4XUs74SIdljDHdFumB5phyQkEGAMvqcyEhw25iM8ZEHUsK/Sg/M4mslHjWltXA6NmwY0mkQzLGmB6xpNCPRIQT8jNYU1oN4+ZB5Wao2hXpsIwxptssKfSzaQUZbC6vo3HMmU7B1tcjG5AxxvRAtwaaRaQEOB0YBRwG1gEvt05PYY44IT+DQFBZ3zKSmWmjYOurMPOqSIdljDHd0mlLQUQ+LyIrcSatSwI2AeXAacArIvKIiIwJf5jRY1qBc0P22jK3C2nbvyAYiGxQxhjTTV21FJJxZjA93N5OEZmOcweydZy7hqcnkJuWwJqyapg6D1b/CfasgoKSSIdmjDFd6rSloKr3As0icnMH+1er6qthiSxKiQjT8jNYW1oNRXMBga2vRTosY4zpli4HmlU1AHx2AGKJGScUZLCloo56bwaMmm5JwRgTNbp79dESEblHRE4XkRmtS1gji2LTCjJQhfV7apxxhd1LobEm0mEZY0yXupsUpgPHA7cBP3eXO8MVVLQrznfubF5TWuUkBQ3AjjciHJUxxnStW5ekqupZ4Q4kluSlJTIyI9G5ie3U2RCf6nQhTf5YpEMzxphOdXVJ6hUi0mEdERknIqf1f1jRb8aYYSzbcRCN80HRGfDBYptK2xgz6HXVUsgGVonICmAFUAEkAuOBM4EDwLfDGmGUOmVcNi+s3cvOygYKp1wEm16EspVQMDPSoRljTIe6uiT1LmAG8BiQC5ztbpcBV6rqJ1V1c9ijjEKnjs0G4O1tlTDpfPD4YMOzEY7KGGM61+WYgntJ6svuYrppXG4KuWkJvLOtkoWzx8DYuU5SOOc2EIl0eMYY065Ok4KIfEtV7xCRXwMf6hBX1a+GLbIoJyKcMjabt7dWoqrI8R+H574Me1fDqJMiHZ4xxrSrq5bCRvd1ebgDiUWnjs3m7+/tYduBesZNugA8Xlj/rCUFY8yg1WlSUNW/u6+PDEw4seXUcc64wjvbKhl38nFQdCZseA7m32pdSMaYQalbN6+JyEQRuV9EXhKR11qXcAcX7QqzkxmRnsjbWyudgqmXwKHtsG9NZAMzxpgOdOvmNeBJ4D7gQcDmge4mEeHUcdm8sfmAM64w+UJ4/mantTDyxEiHZ4wxH9LdaS78qvpbVV2qqital7BGFiNOGZvFgbomtlbUQUo2FJ0O656xG9mMMYNSV3c0Z4lIFvB3EfmyiIxsLXPLTRdOHZsDcKQL6cSFThfSzjcjGJUxxrSvq5bCCpwrj64CvgG86W63LqYLo7OSyM9Mcm5iA5hyMSRkwMpHIxuYMca0o6s7motUdSwwFbgHeA9YDfwaZ9ZU0wUR4bTxObyx+QAtgSDEJ8O0TznjCoftEdfGmMGlu2MKjwBTgLtxEsJUt8x0w/ypw6lt9LN0+0GnYMbnwN8Ia5+KbGDGGHOM7iaFYlW9TlVfd5cvAMXhDCyWnDY+h0Sfh5c37HcKRp7oLCsesQFnY8yg0t2ksFJETmndEJGTsTGFbkuKj+P0Cbm8vGE/2poEZnwO9q91pr0wxphBortJYSbwlojsEJEdwNvALBFZKyJ2J1Y3nDNlOGVVh9mw130sZ/EC8CbZgLMxZlDp7s1r54U1iiFg3pQ8RODlDfs5flQGJGXC8R+HNU86014kZkQ6RGOM6V5LQVV3draEO8hYkJOawMwxw3hl4/4jhSd/EZprnbEFY4wZBLrbfdQrInKeiGwSkS0i0uET2kTkkyKiIlISzngi7Zypw1lXVsOeqsNOwajpzqM63/kt+JsjG5wxxhDGpCAiccC9wPk4l7AuFJGp7dRLA74GvBuuWAaL+VOHAxzdWvjIV6F2D6x/JkJRGWPMEeFsKcwGtqjqNlVtBh4HLmmn3g+BnwKNYYxlUBiXm8rY3BReWh+SFMbPh7yp8ObddnmqMSbiwpkU8oHdIdulblkbEZkBjFbVFzo7kIhcLyLLRWR5RUVF/0c6gM4vHsHb2yopr3VzoAiceiOUr4etNhu5MSaywjqm0BkR8QC/AL7eVV1VvV9VS1S1JDc3N/zBhdEnTiogEFQWrd5zpPCET0HaSHjr7sgFZowxhDcplAGjQ7YL3LJWaTh3Rf/LvffhFGBRrA82j89L5cTRmTy9MuRP4Y13rkTa9i/YFfNDK8aYQSycSWEZMEFEikQkHrgMWNS6U1WrVTVHVQtVtRB4B7hYVWP+TulPzshn494aNuypOVI4+wuQkgev3mZjC8aYiAlbUlBVP3AjsBjYCDyhqutF5DYRuThcnxsNLpw2Cl+c8LdVpUcK41PgjG/CziWw7fXIBWeMGdLCOqagqi+q6kRVHaeqt7tlt6jqonbqzh0KrQSArJR4zpqUx7Or9+APBI/smHkVZIyx1oIxJmIiNtA81F06o4CK2iaWbDlwpNCbAHO/DXtWwfvPRy44Y8yQZUkhQs6anEtmsu/oAWeAaZ+BnInw2o8g4I9McMaYIcuSQoQkeOO4+MRRLF6/j8q6piM74rww73tQ8T6s+H3kAjTGDEmWFCLoylOOo9kf5PFlu4/eMeUiKDoTXvsh1B9o/83GGBMGlhQiaMLwNE6fkMMf397pPL+5lQhc8DNorodXbo1YfMaYoceSQoRd/ZFC9tU08o91+47ekTsJTrkBVv0RSofERVnGmEHAkkKEnTUpj8LsZH7/5vYP7zzzfyB1BLzwdQgGBj44Y8yQY0khwjwe4aqPFLJqVxWrd1cdvTMhDc693XmO8zu/jUyAxpghxZLCILBgZgGpCd72WwvFn4RJFziDzhUfDHxwxpghxZLCIJCW6OPTJaN5Yc1eSg81HL1TBC78FfiS4NkbrBvJGBNWlhQGiS+cUYRHhHtf3/LhnWnD4YI7oWw5vPXrgQ/OGDNkWFIYJEZmJHHZ7NE8ubyU3QcbPlyh+JPO/Quv3w771g18gMaYIcGSwiDypbnjO24tiMDHfglJWfDkVdBUO/ABGmNiniWFQWRERiILZ4/mqRUdtBZSc+GTD8LBbfD8zTaTqjGm31lSGGS+dNZ4PB7hntfaaS0AFJ0Oc/8X1j4JKx8Z2OCMMTHPksIgMzw9kc/OHsNTK0vZUl7XfqXTvw5jz4IXvwV7Vg9sgMaYmGZJYRC6cd54kn1x3P7ChvYreDxw6QOQkguPfxZq97VfzxhjesiSwiCUk5rA1+ZP4PVNFbz+fnn7lVJz4bOPw+EqJzG0HB7YII0xMcmSwiD1uVMLGZuTwg9f2ECzP9h+pREnOAPPZSvhuS/bwLMxps8sKQxS8V4P37twKtsq6nn07R0dV5x8Acy/FdY9Da/+YGCCM8bELEsKg9hZk/M4c2Iud72ymfLaxo4rzvkazPw8LPml3fFsjOkTSwqD3C0XTaUpEOR7z65DO+oeEoGP/Rymfhxe+j9Y9eeBDdIYEzMsKQxy43JTuXn+RBav388La/d2XNETB5fe71yquugrsOG5gQvSGBMzLClEgS+cXsS0ggxueW49lXVNHVf0JsBn/gQFJfDk52H93wYuSGNMTLCkEAW8cR5+tuBEahtb+P6i9Z1XTkiFK56G0bPhqWth7VMDE6QxJiZYUogSk0ak8ZV5E3h+zV4Wvben88oJaXD5UzDmFHjmC7D6sYEJ0hgT9SwpRJEb5o5j5nHD+N9n1rLjQH3nlRNS4fInofB0ePaL8OZddh+DMaZLlhSiiC/Ow90LTyLOI3z5LytpbOniKWzxKU5iOP5SePkWWPxdCHZwI5wxxmBJIerkZybx80+dyPo9Nfy/Fzd2/QZvAnzyITj5i/DOvfDU56G5nWm5jTEGSwpRaf7U4Vx3WhGPvr2T51aXdf0GjwfO+wmc80PnUtXfnw81XYxLGGOGJEsKUepb501mdlEW33xqDSt3Her6DSIw56uw8DGo3AL3nwWly8MfqDEmqoQ1KYjIeSKySUS2iMi329n/3yKyQUTWiMirInJcOOOJJfFeD/ddMZMR6Ylc/+gKyqq6OUvqpPPh2pfBGw8PnwdLH7ABaGNMm7AlBRGJA+4FzgemAgtFZOox1VYBJao6DXgKuCNc8cSirJR4HrqqhKaWANf+YRl1Tf7uvXH4VLj+3zDuLHjxG/D0tfbMZ2MMEN6Wwmxgi6puU9Vm4HHgktAKqvq6qraOer4DFIQxnpg0YXga91w+gw/21/Jff1xOk7+LK5JaJWfBwr/C2bc4dz7/7kxnCm5jzJAWzqSQD+wO2S51yzpyLfCP9naIyPUislxElldUVPRjiLHhzIm53LHgRN7cUslXH1uFP9DNy049HufRnlf9HfxN8NA58J87IdjNxGKMiTmDYqBZRK4ASoCftbdfVe9X1RJVLcnNzR3Y4KLEgpkF3HLhVBav38//PL2WYLAH4wSFp8ENS2DKxfDaD+H3F8CBLeEL1hgzaIUzKZQBo0O2C9yyo4jIfOC7wMWq2slsb6Yr15xWxM3zJ/L0ylK+++y6niWGpGGw4GH4xP1QsRHumwNv3m2tBmOGmHAmhWXABBEpEpF44DJgUWgFETkJ+B1OQujgYcSmJ7569ni+NHccjy3dxdgolyQAABaySURBVDeefK/7XUngXLZ64mfgy0th3Nnw8vfgwfmwZ3X4AjbGDCphSwqq6gduBBYDG4EnVHW9iNwmIhe71X4GpAJPishqEVnUweFMN4kI3zpvMt/46ESeWVXGVx9f1fEznjuSNgIu+7NzJ3R1KTxwFrz4TWisDk/QxphBQzp8mtcgVVJSosuX201X3fHQku388PkNnD4hh3svn0F6oq/nBzlcBa/9CJY9CCm5cPb3YPrlzkN9jDFRQ0RWqGpJV/UGxUCzCY9rTyviZwum8fbWSj7127e7f4NbqKRM+NidcP3rkFXkPNXt/jNh+xv9H7AxJuIsKcS4T5WM5pFrZrOn6jCfuPdN1pRW9e5Ao06CaxY7XUoNh+CRC+FPC2Df2v4N2BgTUZYUhoA543N46oaP4IvzsOC+t3li+e6u39QeEThhAXxlOcy/FUqXwn2nw9PX2SWsxsQISwpDxKQRaSy6cQ6zCofxrafW8J1n1nb/7udj+ZLgtJvha+/BaTfBxufh3lnwzH9ZcjAmytlA8xDjDwS586UPuO/fWynOT+euy05iXG5q3w5aVw5v3Q1LH4RAE0y9BObcBKOm90/Qxpg+6+5AsyWFIeql9fv41tNraGwJcMuFx7Nw9mhEpG8HrSuHt++F5Q9DUw2Mmwen3ui89vXYxpg+saRgurS/ppGvP/EeS7YcYP6UPH708RMYkZHY9wM3VjuJ4Z3fQt1+yJ0Mp9wAJ3wa4pP7fnxjTI9ZUjDdEgwqD7+5nTtf2oTP4+F/PzaFy2b1Q6sBnEn21j3jPAZ031pIzIDpV8CsayF7XN+Pb4zpNksKpkd2HKjn28+s4Z1tBzm5KIsfXHI8k0ek98/BVWHnm7DsIdi4CIJ+KDoDZlwFky8EXz+0TowxnbKkYHpMVfnrst385J/vU9vo58pTjuPmcyaSkdSLO6E7UrsfVj0KK/8IVTshMRNO+BRMXwijZtjYgzFhYknB9Nqh+mZ+/vIm/vLuLjKSfHxl3gQuP2UMCd5+nNoiGIQd/4GVjzqXtAaaIGeiM+5QfKl1LxnTzywpmD5bv6eaH7/4Pku2HGB0VhJfP2cSF504ijhPP/+aP1wFG56D9x6HXW85ZaNmOMlhysUwzB7dbUxfWVIw/eY/H1Twk3+8z4a9NYzNTeEr88Zz0bRReOPCcO9j1W7n8aDrnoK97zllo2bAlIuc8Yfcif3/mcYMAZYUTL8KBpXF6/dx16ubeX9fLYXZyVx3+lgWzCwg0RemGVMPboMNi2DDs7BnlVOWPQEmnQ8Tz4XRJ0NcP453GBPDLCmYsAgGlZc27Oc3/9rCmtJqslLiueKU47ji5DHkpYfxKqLqMtj0Irz/AuxYAsEWSMiA8fOcBwKNPxvSR4Xv842JcpYUTFipKku3H+SBN7bxysZyvB7h3OIRfO6U45hdlNU/9zl0pKkWtr4OmxfD5legbp9TnjcVis6EsXPhuI9AYj9dUmtMDLCkYAbM9gP1/OmdnTy5fDc1jX6KclL4VEkBC2YUhLf1AM49EOUbYMsrTqLY9Tb4G0HinLmXCk+DwtNh9Gzn5jljhihLCmbAHW4O8PyaPTy5vJSlOw7iEWfa7o9Pz+fc4hGkJnjDH0RLozOl97Z/OzfMlS53upoQGF4Mx53qjEWMng0Zo+2+CDNkWFIwEbWtoo6nV5by3Oo9lB46TILXw9xJuZxfPJJ5U/J692jQ3mhugNJlTgti51vOekuDsy9tJOTPdJaCEhg53bqcTMyypGAGBVVl5a4qFq0u45/r97G/pon4OA8nj81i/pThnD0lj4JhAzhJXsAP+9c5yWH3Uihb7lzl1Cp7gvOUuVHTYcQ0GHGC80hSY6KcJQUz6ASDyqrdh/jH2n28+n452w/UAzAhL5UzJuZyxsRcTi7KCt8lrh1pOAhlK2DPatiz0rn8tXbvkf2ZY2D4CTCiGIYfD3nHO8+r9gxwnMb0gSUFM+htq6jj1Y3l/GdzBe9uP0izP0h8nIfpYzL5yLhsTi7K5qQxmQOfJMB5NsTeNbDvPWeG133r4OBW0KCz35voTMuRNwVyJznTg+dMgmGFEDcAYyfG9JAlBRNVDjcHeGd7JW9vdZZ1e6pRBV+cUJyfwazCLE4anclJY4b1zzMfeqO5ASreh/KNzhVP5Rud7ZqyI3U8PsgaC9njIWc8ZI1z5nHKGgdpI2xg20SMJQUT1aobWlix6yBLtx9i2Y6DrC2rptnv/EofkZ7ICQUZTMvPoLggg+NHppOblhDeeyM601jtPJv6wAdwYBMc2AyVW5yxikDzkXq+ZKclMazI6X7KPM6Z1ynzOMgcDfEpkYnfDAmWFExMafIH2Li3lpU7D7G2rJr3SqvYVlHftj8nNZ4pI9OZNDyNiSPSmDwijXG5qaQMxGWwHQkGoHo3VG51EsTB7XBou/u6A/yHj66fnOMkh4wC53LZjAJIzz/ymppn4xim1ywpmJhX09jCxj01bNhbw4Y9NWzcV8Pm/XU0uS0KgPzMJMblpTI2J4WxuSkU5aRQmJ3CyIzE8Ezo112qUF/hJIdDO6F6F1TtciYErC51kknrpbOtJM7pgkobCekjnde0EZA6HFJHQNpwZz0525KH+RBLCmZICgSVnZX1fLC/li3ldWwur2NLeR07DtRT3xxoq+eLEwqGJVMwLIkxWcmMzkomPzOJ/GFJFGQmkZOagKe/pwjvCVU4fMgZr6guc15r90LNHmep3Qe1e5yuq2OJB1JyISUPUnKcFkZKrpMsUnKdsuQcSM5y1hPSbaxjCOhuUrDLJExMifMIY3NTGZubelS5qlJe28S2inp2HaxnR2UDOyvr2X3wMGvL9lLV0HJUfV+cMDw9kVEZSQzPSGREegLD0xPJS08kLy2BXHdJS/CGZyxDxPlHOznLuVeiI80NULffWWr3Oa2P1u26Cmf74FaoP/DhlkcrjxeS3M9KyoKkYZA8zHlNGuY8HS8p88h6YoaznpBuV1rFIGspGAPUNrZQVnWYPVWHKTt0mD3Vjeytcl731zSyr7rxqG6pVgleDzmpCeSkxpOVEk92agLZKfEMS4knK9l5HZbsIzM5nsxkHxlJPnyR6rZqrneSQ8MB596M+gPQUAmHDzqvDZXOA48aDjplh6s+PO5xLF+Kcxd4QvqHXxPS3NdUdz0N4tOc7fjUI6/xKc4lvtZaCStrKRjTA2mJPiaP8DF5RPvTXKgq1YdbqKhtory2ifLaRg7UNlNR18SB2iYO1DdTXtvE+/tqqaxvbrtSqj0p8XFkJseTluglPclHeqKP9CQv6Yk+0hK9pCV6SU3wkZroJS3BS0qCl5SEOFJb1+O9JPo8PW+hxKc4S0+eZNfS6HRjNVY5SaKxyumyaqx2tptqjpQ11Tp1q3Y66021HbdOjiWeIwnCl3wkVl8yxCc7r21LkrPEpziv3qQjZd7ED796E8HnvtpYS5fCmhRE5DzgLiAOeFBVf3LM/gTgUWAmUAl8RlV3hDMmY3pDRNxf+/FMGJ7WaV1VpaE5wMH6Zg41NHOooYWqhmaqGlqoPtzS9lrT2ELN4RZKDzVQu9dPbWMLtU1+utN49wgkx3tJjo8jOT6OpJD1RF8cSe6S6POQGB9HotcpT/R52l4TvEde470eErwe99XZjo/zEO+NIyEpj/jUEb0bYwn4obkWmuqcBNJc7ySL5jpnvXW7pcGp01znrLfua6x2xlKa653ylsPOq3acdDv/w/ncRJHgvsYfvR0X76y3vSY4deJCFm+C83CnuNZ6oft9zqvH5663bnuddY/P6XILreOJC1n3RrzFFLakICJxwL3AOUApsExEFqnqhpBq1wKHVHW8iFwG/BT4TLhiMmYgiIj7697L6KyezeukqtQ3B6hrdJJEXZOfuiY/9U1+6psCNDT7qXNfG5pDX531+iY/B+qaOdzsp7ElyOGWAIebAzQHevmPaAivR/DFOYnDF+ckEV+c4I1ztuPb1p16Xs+Rba/HgzdO8HkSiYtLwucZTpzH2RfnEbweIc7nwZvorntCyj0e4jwceRXBpy34tJH4YBM+bcQbaMKnTXiDzro32ERcsIm4QBPeQCOeQCNx2oIn0ERcoBEJNuMJNLUtEmxG/E1I02GkoRpPoAkCTUigGQLNba/4mxANdP3H6guJO5IgWpfW7bNvgWmfDuvHh7OlMBvYoqrbAETkceASIDQpXALc6q4/BdwjIqLRNtBhTD8REVITvKQmePv1zu1gUGnyB2lsCdDoD9DUEqTRH6CxJUizP0iTW9YccNab/a3lztIScJZmf5CWgHOsZn8Qf7C1XNvWW/xKnd+PP6C0BIL4g4o/4LwvEGytd2TdH1D8wf76X94DJLlLeHgI4sNPPH58+EkQPwkSIFH8+CSATwIkiJ94CTh1xI+PIPHix9v26uzzSgCvezyvBPESwItTzxsM4NUAXn+AOAngJUBauY+PhO3MHOFMCvnA7pDtUuDkjuqoql9EqoFs4EBoJRG5HrgeYMyYMeGK15iY5fEISfFxJMUP3j71QNBJIkF1kkTATRah2wF1kknr0ravdT2gqB6pF1QlGISAKsGgElRnXUOOowpB9z1t68Fj1sE9Vmu5cxz0yL5AEBR3f8h7nGpHtv0KzQr1rftw4gqtd6T+0WWXDcC/f1Ex0Kyq9wP3g3P1UYTDMcaEgdNlNHiT1lARzmvjyoDRIdsFblm7dUTEC2TgDDgbY4yJgHAmhWXABBEpEpF44DJg0TF1FgFXuesLgNdsPMEYYyInbN1H7hjBjcBinEtSH1bV9SJyG7BcVRcBDwF/FJEtwEGcxGGMMSZCwjqmoKovAi8eU3ZLyHoj8KlwxmCMMab7IjhNpDHGmMHGkoIxxpg2lhSMMca0saRgjDGmTdRNnS0iFcDOXr49h2Pulh4ihuJ5D8VzhqF53kPxnKHn532cquZ2VSnqkkJfiMjy7swnHmuG4nkPxXOGoXneQ/GcIXznbd1Hxhhj2lhSMMYY02aoJYX7Ix1AhAzF8x6K5wxD87yH4jlDmM57SI0pGGOM6dxQaykYY4zphCUFY4wxbYZMUhCR80Rkk4hsEZFvRzqevhCR0SLyuohsEJH1IvI1tzxLRF4Wkc3u6zC3XETkbvfc14jIjJBjXeXW3ywiV3X0mYOFiMSJyCoRed7dLhKRd91z+6s7TTsikuBub3H3F4Yc4ztu+SYROTcyZ9J9IpIpIk+JyPsislFETo3171pEbnb/214nIo+JSGIsftci8rCIlIvIupCyfvtuRWSmiKx133O3iEiXQan7aLpYXnCm7t4KjAXigfeAqZGOqw/nMxKY4a6nAR8AU4E7gG+75d8GfuquXwD8AxDgFOBdtzwL2Oa+DnPXh0X6/Lo49/8G/gI8724/AVzmrt8H3OCufwm4z12/DPiruz7V/f4TgCL3v4u4SJ9XF+f8CHCdux4PZMbyd43zmN7tQFLId3x1LH7XwBnADGBdSFm/fbfAUreuuO89v8uYIv1HGaA//KnA4pDt7wDfiXRc/Xh+zwHnAJuAkW7ZSGCTu/47YGFI/U3u/oXA70LKj6o32Bacp/e9CswDnnf/Qz8AeI/9nnGe43Gqu+5168mx331ovcG44DyNcDvuRSHHfoex+F1z5NntWe539zxwbqx+10DhMUmhX75bd9/7IeVH1etoGSrdR63/kbUqdcuinttUPgl4FxiuqnvdXfuA4e56R+cfbX+XXwHfAoLudjZQpap+dzs0/rZzc/dXu/Wj7ZyLgArg92632YMikkIMf9eqWgbcCewC9uJ8dyuI/e+6VX99t/nu+rHlnRoqSSEmiUgq8DRwk6rWhO5T56dBzFxvLCIXAuWquiLSsQwwL073wm9V9SSgHqdLoU0MftfDgEtwEuIoIAU4L6JBRUgkvtuhkhTKgNEh2wVuWdQSER9OQvizqj7jFu8XkZHu/pFAuVve0flH099lDnCxiOwAHsfpQroLyBSR1icIhsbfdm7u/gygkug6Z3B+3ZWq6rvu9lM4SSKWv+v5wHZVrVDVFuAZnO8/1r/rVv313Za568eWd2qoJIVlwAT36oV4nMGoRRGOqdfcKwgeAjaq6i9Cdi0CWq88uApnrKG1/HPu1QunANVu83Qx8FERGeb+OvuoWzboqOp3VLVAVQtxvr/XVPVy4HVggVvt2HNu/VsscOurW36Ze8VKETABZzBuUFLVfcBuEZnkFp0NbCCGv2ucbqNTRCTZ/W+99Zxj+rsO0S/frbuvRkROcf+Onws5VsciPcgygIM5F+BcpbMV+G6k4+njuZyG06RcA6x2lwtw+lFfBTYDrwBZbn0B7nXPfS1QEnKsa4At7vL5SJ9bN89/LkeuPhqL8z/6FuBJIMEtT3S3t7j7x4a8/7vu32IT3bgaI9ILMB1Y7n7fz+JcYRLT3zXwA+B9YB3wR5wriGLuuwYewxk3acFpFV7bn98tUOL+DbcC93DMBQvtLTbNhTHGmDZDpfvIGGNMN1hSMMYY08aSgjHGmDaWFIwxxrSxpGCMMaaNJQUTdUQkICKr3Vk03xORr4uIx91XIiJ3d/LeQhH57MBF+6HPTxKRf4sz2+tccWd77cPxLhOR73awL1dE/tmX45uhx5KCiUaHVXW6qh6PMxHg+cD3AVR1uap+tZP3FgIRSwo415M/o6qBfjre+UC7//CragWwV0Tm9NNnmSHAkoKJaqpaDlwP3Oje6dn261tEznRbFKvdyeTSgJ8Ap7tlN7sthzdEZKW7fMR971wR+ZcceY7Bn1vnoheRWSLylttKWSoiae4v/5+JyDJ3rvv/6iDky2nnrlL3mKtEZJyI3Coij7hx7RSRS0XkDnde/H+6U5y03tk+HVjZwbmCc7Pb5f33FzcxL9J39NliS08XoK6dsiqc2STncuRu578Dc9z1VJzJ5dr2u+XJQKK7PgFY7q7PxZltswDnx9PbOHeSx+PMVz/LrZfuHvd64P/csgScO5CLjokxHtgXsj0XZ1roj+DMAjrGLb8VWAL4gBOBBty7cYG/AR9312cAj3Z0ru56PrA20t+ZLdGztE4uZUwsehP4hYj8GafLplQ+/OApH3CPiEwHAsDEkH1LVbUUQERW43Q9VQN7VXUZgLqz04rIR4FpItI6N08GTpLZHnK8HJzkFWoKcD/wUVXdE1L+D1VtEZG1OA+Jau0iWuvGAc7Mof/o6Fzd8nKcmUaN6RbrPjJRT0TG4vyDXh5arqo/Aa4DkoA3RWRyO2+/GdiP84u8BOfXfKumkPUAdPojSoCvqDPWMV1Vi1T1pWPqHMaZpyfUXqAR55kYoZrccwgCLaraOh9NMCSOjwIvdXGuie7nGtMtlhRMVBORXJxHM94T8g9n675xqrpWVX+KM1PuZKAW5xGmrTJwfvkHgStxfpV3ZhMwUkRmuZ+RJs50zYuBG0L6+yeK8zCcNqp6CIgTkdDEUAV8DPixiMztwXln4HQRVXZyruC0fNZ1cBhjPsS6j0w0SnK7c3yAH2cWzV+0U+8mETkL59f1epyuliAQEJH3gD8AvwGeFpHP4XTR1Hf2waraLCKfAX4tIkk4v8LnAw/idOusdAeAK4CPt3OIl3DGJl4JOeZ+cR4i9A8RuaZbfwHnqqtXQrbbO1eAs4AXunlMY2yWVGMGkojMAG5W1Sv7eJwHgQdV9Z0u6v0HuMRtpRjTJUsKxgwwtzXwiPbfvQodfU4uzhVJz4bzc0xssaRgjDGmjQ00G2OMaWNJwRhjTBtLCsYYY9pYUjDGGNPGkoIxxpg2/x/gtRaQh3AtzwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plot Selection Function\n",
    "\n",
    "#distvals = np.logspace(np.log10(1e2),np.log10(1e5), 45)\n",
    "distvals = np.arange(5, 100, 1)\n",
    "distvalsplot = np.arange(0, 10000, 100)\n",
    "\n",
    "alpha_val, beta_val, r_star_val = 0.527, 1.78, 44\n",
    "phivals_paper = [phi(x, alpha_val, beta_val, r_star_val) for x in distvals]\n",
    "phivals_paper = np.insert(phivals_paper, 0, [1, 1, 1, 1, 1])\n",
    "\n",
    "alpha_val, beta_val, r_star_val = mean_alpha, mean_beta, mean_r_star\n",
    "phivals_mine = [phi(x, alpha_val, beta_val, r_star_val) for x in distvals]\n",
    "phivals_mine = np.insert(phivals_mine, 0, [1, 1, 1, 1, 1])\n",
    "\n",
    "plt.plot(distvalsplot, phivals_paper, label = 'paper')\n",
    "plt.plot(distvalsplot, phivals_mine, label = 'ours')\n",
    "\n",
    "#plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.title('Selection function')\n",
    "plt.xlabel('Distance (km/s)')\n",
    "plt.ylabel('phi(r)')\n",
    "plt.savefig('selection_fn_paper+ours')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-0adfe394d296>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mparameterdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'10 Chain Results\\MC_%dchains_iter_%deach.npz'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m#Get histogram\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mhistogram\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mparam\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchain_num\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnbins\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m11\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m#param is 2D array\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mburn_end\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1500\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "#Get histogram\n",
    "def histogram(param, chain_num, nbins=11): #param is 2D array\n",
    "    burn_end = 1500\n",
    "    nvals = int(param[chain_num-1, 0])\n",
    "    parr = param[chain_num-1, 1+burn_end:nvals+1]\n",
    "    \n",
    "    tot_counts = nvals - burn_end\n",
    "    counts, bins = np.histogram(parr, bins = nbins)\n",
    "    plotcounts = np.insert(counts, -1, counts[-1])\n",
    "    \n",
    "    binwidth = bins[1] - bins[0]\n",
    "    #plt.hist(parr, bins = 25)\n",
    "    plt.step(bins, plotcounts, where = 'post')\n",
    "    plt.xlim(bins[0]-binwidth, bins[-1]+binwidth)\n",
    "    plt.show()\n",
    "    \n",
    "    return [bins, counts, tot_counts]\n",
    "\n",
    "#Plot Selection function\n",
    "def plot_phi(alpha, beta, r_star):\n",
    "    distvals = np.arange(5, 100, 1)\n",
    "    distvalsplot = np.arange(0, 10000, 100)\n",
    "    \n",
    "    phivals = [phi(x, alpha, beta, r_star) for x in distvals]\n",
    "    phivals = np.insert(phivals, 0, [1, 1, 1, 1, 1])\n",
    "    \n",
    "    plt.plot(distvalsplot, phivals, label = \\\n",
    "             'alpha=%.2f, beta=%.2f, r_star=%.2f' % (alpha, beta, r_star))\n",
    "    #plt.yscale('log')\n",
    "    plt.legend()\n",
    "    plt.title('Selection function')\n",
    "    plt.xlabel('Distance (km/s)')\n",
    "    plt.ylabel('phi(r)')\n",
    "    #plt.savefig('zzz.png')\n",
    "    plt.show()\n",
    "\n",
    "#Get median value and 1 sigma errorbars\n",
    "def find_errorbars(bins, counts, tot_counts):\n",
    "    if int(np.sum(counts)) != tot_counts: print('Oopsieee!!!')\n",
    "    sigmacount = 0.341 * tot_counts\n",
    "    medianbin = np.argmax(counts)\n",
    "    medianval = (bins[medianbin] + bins[medianbin+1])/2\n",
    "    \n",
    "    #upper-errorbar\n",
    "    sumcounts = counts[medianbin]/2\n",
    "    for i in range(medianbin+1, len(counts)):\n",
    "        sumcounts += counts[i]\n",
    "        if (sumcounts >= sigmacount):\n",
    "            upsigmaval = (bins[i] + bins[i+1])/2\n",
    "            break\n",
    "    uperror = upsigmaval - medianval\n",
    "    \n",
    "    #lower-errorbar\n",
    "    sumcounts = counts[medianbin]/2\n",
    "    for i in range(medianbin-1, 0, -1):\n",
    "        sumcounts += counts[i]\n",
    "        if (sumcounts >= sigmacount):\n",
    "            losigmaval = (bins[i] + bins[i+1])/2\n",
    "            break\n",
    "    loerror = losigmaval - medianval\n",
    "    \n",
    "    return [medianval, uperror, loerror]\n",
    "\n",
    "a = histogram(alpha2Darr, 5, 21)\n",
    "print(a)\n",
    "find_errorbars(a[0], a[1], a[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.optimize as so\n",
    "import scipy.ndimage\n",
    "\n",
    "def find_confidence_interval(x, pdf, confidence_level):\n",
    "    return pdf[pdf > x].sum() - confidence_level\n",
    "\n",
    "def density_contour(xdata, ydata, nbins_x, nbins_y, ax=None, **contour_kwargs):\n",
    "    \"\"\" Create a density contour plot.\n",
    "    Parameters\n",
    "    ----------\n",
    "    xdata : numpy.ndarray\n",
    "    ydata : numpy.ndarray\n",
    "    nbins_x : int\n",
    "        Number of bins along x dimension\n",
    "    nbins_y : int\n",
    "        Number of bins along y dimension\n",
    "    ax : matplotlib.Axes (optional)\n",
    "        If supplied, plot the contour to this axis. Otherwise, open a new figure\n",
    "    contour_kwargs : dict\n",
    "        kwargs to be passed to pyplot.contour()\n",
    "    \"\"\"\n",
    "\n",
    "    H, xedges, yedges = np.histogram2d(xdata, ydata, bins=(nbins_x,nbins_y), normed=True)\n",
    "    x_bin_sizes = (xedges[1:] - xedges[:-1]).reshape((1,nbins_x))\n",
    "    y_bin_sizes = (yedges[1:] - yedges[:-1]).reshape((nbins_y,1))\n",
    "\n",
    "    pdf = (H*(x_bin_sizes*y_bin_sizes))\n",
    "\n",
    "    one_sigma = so.brentq(find_confidence_interval, 0., 1., args=(pdf, 0.68))\n",
    "    two_sigma = so.brentq(find_confidence_interval, 0., 1., args=(pdf, 0.95))\n",
    "    three_sigma = so.brentq(find_confidence_interval, 0., 1., args=(pdf, 0.99))\n",
    "    levels = [three_sigma, two_sigma, one_sigma]\n",
    "\n",
    "    X, Y = 0.5*(xedges[1:]+xedges[:-1]), 0.5*(yedges[1:]+yedges[:-1])\n",
    "    Z = pdf.T\n",
    "\n",
    "    if ax == None:\n",
    "        contour = plt.contour(X, Y, Z, levels=levels, origin=\"lower\", **contour_kwargs)\n",
    "    else:\n",
    "        contour = ax.contour(X, Y, Z, levels=levels, origin=\"lower\", **contour_kwargs)\n",
    "\n",
    "    return contour\n",
    "\n",
    "def test_density_contour():\n",
    "    al_arr = alpha2Darr[0, 1501:int(alpha2Darr[0, 0])+1]\n",
    "    bt_arr = beta2Darr[0, 1501:int(beta2Darr[0, 0])+1]\n",
    "    al_arr = scipy.ndimage.zoom(al_arr, 1)\n",
    "    bt_arr = scipy.ndimage.zoom(bt_arr, 1)\n",
    "    density_contour(al_arr, bt_arr, 100, 100)\n",
    "    plt.show()\n",
    "\n",
    "test_density_contour()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# REDUNDANT CODES START HERE!!!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'acc_alphas' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-29-13bc8c048128>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mburn_end\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1500\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmean_alpha\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_alpha\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_alphas\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mburn_end\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mlimit\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_alphas\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mburn_end\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mlimit\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mmean_beta\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_beta\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_betas\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mburn_end\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mlimit\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_betas\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mburn_end\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mlimit\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mmean_r_star\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstd_r_star\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_r_stars\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mburn_end\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mlimit\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_r_stars\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mburn_end\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mlimit\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'acc_alphas' is not defined"
     ]
    }
   ],
   "source": [
    "#Mean and Standard-deviation of Accepted Parameter Values\n",
    "\n",
    "burn_end = 1500\n",
    "mean_alpha, std_alpha = np.mean(acc_alphas[burn_end:limit]), np.std(acc_alphas[burn_end:limit])\n",
    "mean_beta, std_beta = np.mean(acc_betas[burn_end:limit]), np.std(acc_betas[burn_end:limit])\n",
    "mean_r_star, std_r_star = np.mean(acc_r_stars[burn_end:limit]), np.std(acc_r_stars[burn_end:limit])\n",
    "print('alpha \\t= %.4f +- %.4f' % (mean_alpha, std_alpha))\n",
    "print('beta \\t= %.4f +- %.4f' % (mean_beta, std_beta))\n",
    "print('r_star \\t= %.4f +- %.4f' % (mean_r_star, std_r_star))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 0.01)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "distvals = np.logspace(np.log10(1e2),np.log10(1e5), 45)\n",
    "phivals = [phi(x, alpha, beta, r_star) for x in distvals]\n",
    "\n",
    "\n",
    "hist, bin_edges = np.histogram(100*np.array(distarr), bins = distvals)\n",
    "plt.plot(bin_edges[:-1], hist)\n",
    "plt.plot(bin_edges[:-1], np.array(phivals[:-1]))\n",
    "plt.xscale('log')\n",
    "plt.ylim(0, 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n1 = \n",
    "\n",
    "#byphivals = [1/x for x in phivals]\n",
    "plt.plot(distvals, phivals)\n",
    "plt.xscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'<' not supported between instances of 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-116-de7d0a6d0e85>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdistarr\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0mr_s\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'list' and 'int'"
     ]
    }
   ],
   "source": [
    "for i in range(len(distarr)):\n",
    "    if distarr[i] < r_s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''nintbin = 10\n",
    "intdistarr = []\n",
    "for i in range(len(distvals) - 1):\n",
    "    intdistarr.extend(np.linspace(distvals[i], distvals[i+1], nintbin))\n",
    "lumintdist = [4*np.pi*intdistarr[i]**2 * freq * f60[i] for i in range(len(distarr))]\n",
    "    \n",
    "densityvals = []\n",
    "i, k = 0, 0\n",
    "while i < len(distvals):\n",
    "    for j in range(nintbin):\n",
    "        densityvals[k] += PHI()'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5, 0.5])"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2])/np.array([2, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 20)"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plt.plot(objf12, 'ro')\n",
    "#plt.plot(objf25, 'bo')\n",
    "plt.plot(np.array(objf12[:-1])/np.array(objf12[1:]), 'r+')\n",
    "plt.plot(np.array(objf25[:-1])/np.array(objf25[1:]), 'b+')\n",
    "plt.plot(np.array(objf60[:-1])/np.array(objf60[1:]), 'g+')\n",
    "plt.plot(np.array(objf100[:-1])/np.array(objf100[1:]), 'y+')\n",
    "#plt.plot(objf100, 'go')\n",
    "plt.ylim(0, 10)\n",
    "plt.xlim(0, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.003216231249070716"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.normalvariate(0, 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "integer argument expected, got float",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-90-d65209490c4c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0marray\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'i'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1.\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: integer argument expected, got float"
     ]
    }
   ],
   "source": [
    "array.array('', [1., 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "172"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "less = 0\n",
    "for i in range(len(f60)):\n",
    "    if np.log10(12) > f60[i]: less += 1\n",
    "less"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3547"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(f60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/pallav/.local/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in log\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-inf"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}