mom-framework.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook to code up method of moments framework \n",
    "\n",
    "Here, I will use the method of moments framework used to track the trajectory of the site frequency spectrum through time given drift and selection from [Jouganous et. al. 2017](https://www.genetics.org/content/206/3/1549). Mostly, I will just use equations to start from a certain generation $t$ back in time and then iterate until generation 0. Then I will store this SFS as a data entry for allele age $t$ and certain selection coefficient $s$. This process will be repeated for each value of $\\{1,\\ldots,gen,\\ldots,12000\\}$ generations. \n",
    "\n",
    "These vectors need to be summed to marginalize over *all* generations $a$, to give $P(X, a | s)$.\n",
    "\n",
    "First, need to get a handle on what $\\Phi_n^k(i)$ really is - can just be represented as *np.array*\n",
    "\n",
    "$\\phi_n^k(i)$ is the expected number of sites where the alternate allele is observed exactly $i$ times in a sample of size $n$ at generation $k$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-06T16:10:17.280703Z",
     "iopub.status.busy": "2024-06-06T16:10:17.280169Z",
     "iopub.status.idle": "2024-06-06T16:10:22.821530Z",
     "shell.execute_reply": "2024-06-06T16:10:22.821085Z",
     "shell.execute_reply.started": "2024-06-06T16:10:17.280647Z"
    }
   },
   "outputs": [],
   "source": [
    "# numerics + rv stuff\n",
    "from numba import jit\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "from scipy.stats.distributions import chi2\n",
    "from scipy.sparse import coo_matrix\n",
    "from scipy.sparse import linalg\n",
    "from numpy.random import default_rng\n",
    "import moments\n",
    "# import dadi \n",
    "# import Selection\n",
    "# plotting + misc tools\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import itertools as it\n",
    "from copy import deepcopy\n",
    "import matplotlib.colors as colors\n",
    "import seaborn\n",
    "from matplotlib import cm \n",
    "from mom_functions import *\n",
    "\n",
    "# rng setup\n",
    "rng = default_rng(100496)\n",
    "\n",
    "# change matplotlib fonts\n",
    "plt.rcParams[\"font.family\"] = \"Arial\"\n",
    "plt.rcParams[\"font.sans-serif\"] = \"Arial\"\n",
    "plt.rcParams[\"figure.figsize\"] = [5, 3.5]\n",
    "plt.rcParams[\"figure.dpi\"] = 110\n",
    "plt.rcParams[\"axes.axisbelow\"] = True\n",
    "plt.rcParams.update({\"figure.facecolor\": \"white\"})\n",
    "\n",
    "# set numpy print option to a more readable format for floats\n",
    "np.set_printoptions(formatter={'float': lambda x: \"{0:0.3f}\".format(x)})\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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[1;32m/Users/vivaswatshastry/selCoefEst/mom-framework.ipynb Cell 3\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/vivaswatshastry/selCoefEst/mom-framework.ipynb#W2sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m \u001b[39m# start in generation 10 so generation 11 has all zeros (going back in time)\u001b[39;00m\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/vivaswatshastry/selCoefEst/mom-framework.ipynb#W2sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m tot_gen \u001b[39m=\u001b[39m \u001b[39m10000\u001b[39m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/vivaswatshastry/selCoefEst/mom-framework.ipynb#W2sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m time_steps \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mlinspace(\u001b[39m0\u001b[39m, tot_gen\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m, \u001b[39m100\u001b[39m, dtype\u001b[39m=\u001b[39m\u001b[39mint\u001b[39m)\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/vivaswatshastry/selCoefEst/mom-framework.ipynb#W2sZmlsZQ%3D%3D?line=9'>10</a>\u001b[0m mom \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros((tot_gen\u001b[39m+\u001b[39m\u001b[39m1\u001b[39m,n\u001b[39m+\u001b[39m\u001b[39m1\u001b[39m))\n\u001b[1;32m     <a href='vscode-notebook-cell:/Users/vivaswatshastry/selCoefEst/mom-framework.ipynb#W2sZmlsZQ%3D%3D?line=10'>11</a>\u001b[0m momnp1 \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mzeros(n\u001b[39m+\u001b[39m\u001b[39m1\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "N = 10000\n",
    "s = -10/N # 25/N -> gamma2 = 50 - strong selection\n",
    "mu = 1.25e-8 # human mutation rate\n",
    "n = 2000 # 2 * # of inds sampled, diploid\n",
    "\n",
    "# start in generation 10 so generation 11 has all zeros (going back in time)\n",
    "tot_gen = 10000\n",
    "time_steps = np.linspace(0, tot_gen-1, 100, dtype=int)\n",
    "\n",
    "mom = np.zeros((tot_gen+1,n+1))\n",
    "momnp1 = np.zeros(n+1)\n",
    "momkp1 = np.zeros((tot_gen+1,n+1))\n",
    "\n",
    "# double precaution - creating a mask\n",
    "mk = [False] + [True]*(n-1) + [False]\n",
    "\n",
    "iter = np.arange(1,n)\n",
    "iterm1p1 = np.arange(2,n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 550x385 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.append(np.linspace(0.0, 1.0, num=10)**np.exp(1),np.linspace(100,1,40,endpoint=False)[::-1]),np.random.uniform(0.8,1.5,50),'ko'); plt.semilogx()\n",
    "# np.geomspace(100,1,20,endpoint=False)[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## borrowed directly from https://bitbucket.org/simongravel/moments/src/main/moments/Jackknife.pyx\n",
    "def python2round(f):\n",
    "    if round(f + 1) - round(f) != 1:\n",
    "        return f + abs(f) / f * 0.5\n",
    "    return round(f)\n",
    "\n",
    "# The choice i' in n samples that best approximates the frequency of i/(n + 1) is i*n / (n + 1)\n",
    "def index_bis(i, n):\n",
    "    return int(min(max(python2round(i * n / float(n+1)), 2), n-2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# code borrowed from https://bitbucket.org/simongravel/moments/src/main/moments/Jackknife.pyx  \n",
    "def calcJK13(n):\n",
    "    J = np.zeros((n,n-1))\n",
    "    for i in range(n):\n",
    "        ibis = index_bis(i + 1, n) - 1\n",
    "        J[i, ibis] = -(1.+n) * ((2.+i)*(2.+n)*(-6.-n+(i+1.)*(3.+n))-2.*(4.+n)*(-1.+(i+1.)*(2.+n))*(ibis+1.)+(12.+7.*n+n**2)*(ibis+1.)**2) / (2.+n) / (3.+n) / (4.+n)\n",
    "        J[i, ibis - 1] = (1.+n) * (4.+(1.+i)**2*(6.+5.*n+n**2)-(i+1.)*(14.+9.*n+n**2)-(4.+n)*(-5.-n+2.*(i+1.)*(2.+n))*(ibis+1.)+(12.+7.*n+n**2)*(ibis+1.)**2) / (2.+n) / (3.+n) / (4.+n) / 2.\n",
    "        J[i, ibis + 1] = (1.+n) * ((2.+i)*(2.+n)*(-2.+(i+1.)*(3.+n))-(4.+n)*(1.+n+2.*(i+1.)*(2.+n))*(ibis+1.)+(12.+7.*n+n**2)*(ibis+1.)**2) / (2.+n) / (3.+n) / (4.+n) / 2.\n",
    "    return J"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## testbed for a single realization of gen = t\n",
    "mom[tot_gen,1] = n*mu # singleton input\n",
    "\n",
    "J = calcJK13(n)\n",
    "\n",
    "# going from generation 9 to 0\n",
    "for gen in np.arange(tot_gen)[::-1]:\n",
    "    momkp1[gen,iterm1p1] = 0.25/N * (mom[gen+1,iterm1p1-1] * (iterm1p1-1)*(n-iterm1p1+1) + mom[gen+1,iterm1p1+1] * (iterm1p1+1)*(n-iterm1p1-1) - mom[gen+1,iterm1p1] * 2*iterm1p1*(n-iterm1p1))\n",
    "\n",
    "    momkp1[gen,1] = 0.25/N * ((n-2) * 2 * mom[gen+1,2] - 2 * (n-1) * mom[gen+1,1])\n",
    "    momkp1[gen,n-1] = 0.25/N * ((n-2) * 2 * mom[gen+1,n-2] - 2 * (n-1) * mom[gen+1,n-1])\n",
    "\n",
    "    # notice the difference in indexing for LHS\n",
    "    # momnp1[np.arange(1,n+1)] = (jk13[:,0] * mom[gen+1,np.array(ibis)-1] - jk13[:,1] * mom[gen+1,np.array(ibis)] + jk13[:,2] * mom[gen+1,np.array(ibis)+1])\n",
    "    momnp1[np.arange(1,n+1)] = (J @ mom[gen+1,iter])\n",
    "\n",
    "    momkp1[gen,iter] += mom[gen+1,iter] + 0.5 * s/(n+1) * (iter * (n+1-iter) * momnp1[iter] - (n-iter) * (iter+1) * momnp1[iter+1])\n",
    "\n",
    "    mom[gen,] = deepcopy(momkp1[gen,])\n",
    "\n",
    "mom2 = deepcopy(mom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## code to run APR's moments and compare with output from above\n",
    "# initialize the spectrum, with 1 in singleton bin\n",
    "fs = moments.Spectrum(np.zeros(2*n + 1))\n",
    "fs[1] = n*1\n",
    "# simulate a generations\n",
    "T = tot_gen / 2 / N\n",
    "# set relative size to 1, theta to 0 to forbid new mutations\n",
    "fs.integrate([1], T, gamma=s*2*N, h=0.5, theta=0, adapt_dt=True, dt_fac=0.005)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## testbed for a single realization of gen = t & the Crank-Nicolson method\n",
    "mom[100,1] = n*1 # singleton input\n",
    "\n",
    "dt = 1\n",
    "\n",
    "D = 0.25/N * calcD(n+1)\n",
    "J = calcJK13(n+1)\n",
    "S = 0.5 * s * calcS(n+1, J)\n",
    "\n",
    "# if N is same across all gens then only have to do this once\n",
    "slv = linalg.factorized(sp.sparse.identity(S.shape[0], dtype=\"float\", format=\"csc\") - dt / 2.0 * (D + S))\n",
    "Q = sp.sparse.identity(S.shape[0], dtype=\"float\", format=\"csc\") + dt / 2.0 * (D + S)\n",
    "\n",
    "# going from generation 9 to 0\n",
    "for gen in np.arange(100)[::-1]:\n",
    "\n",
    "    # momkp1[gen,iter] = mom[gen+1,iter] + ((D[iter,] + S[iter,]) @ mom[gen+1,])\n",
    "    momkp1[gen,iter] = mom[gen+1,iter] + slv(Q.dot(mom[gen+1,iter]))\n",
    "    momkp1[gen,0] = momkp1[gen,n] = 0.0\n",
    "\n",
    "    mom[gen,] = deepcopy(momkp1[gen,])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcD(d):\n",
    "    data = []\n",
    "    row = []\n",
    "    col = []\n",
    "    # loop over the fs elements:\n",
    "    for i in range(d):\n",
    "        if i > 1:\n",
    "            data.append((i-1) * (d-i))\n",
    "            row.append(i)\n",
    "            col.append(i - 1)\n",
    "        if i < d - 2:\n",
    "            data.append((i+1) * (d-i-2))\n",
    "            col.append(i + 1)\n",
    "            row.append(i)\n",
    "        if i > 0 and i < d - 1:\n",
    "            data.append(-2 * i * (d-i-1))\n",
    "            row.append(i)\n",
    "            col.append(i)\n",
    "\n",
    "    return coo_matrix((data, (row, col)), shape=(d, d), dtype='float').tocsc()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcS(d, ljk):\n",
    "    # Computes the jackknife-transformed selection matrix 1\n",
    "    # for the addition of a single sample\n",
    "    # arrays for the creation of the sparse (coo) matrix\n",
    "    # data will have matrix entry, row + column have coordinates\n",
    "    data = []\n",
    "    row = []\n",
    "    col = []\n",
    "    # loop over the fs elements:\n",
    "    for i in range(d):\n",
    "        i_bis = index_bis(i, d - 1) # This picks the second jackknife index \n",
    "        i_ter = index_bis(i + 1, d - 1) # This picks the third jackknife index\n",
    "        # coefficients of the selection matrix\n",
    "        g1 = i * (d-i) / np.float64(d)\n",
    "        g2 = -(i+1) * (d-1-i) / np.float64(d)\n",
    "\n",
    "        if i < d - 1 and i > 0: # First deal with non-fixed variants\n",
    "            data += [g1 * ljk[i - 1, i_bis - 1], g1 * ljk[i - 1, i_bis - 2],\n",
    "                    g1 * ljk[i - 1, i_bis], g2 * ljk[i, i_ter - 1],\n",
    "                    g2 * ljk[i, i_ter - 2], g2 * ljk[i, i_ter]]\n",
    "            row += 6 * [i]\n",
    "            col += [i_bis, i_bis - 1, i_bis + 1,\n",
    "                    i_ter, i_ter - 1, i_ter + 1]\n",
    "        \n",
    "        elif i == 0: # g1=0\n",
    "            data += [g2 * ljk[i, i_ter - 1],\n",
    "                     g2 * ljk[i, i_ter - 2], g2 * ljk[i, i_ter]]\n",
    "            row += 3 * [i]\n",
    "            col += [i_ter, i_ter - 1, i_ter + 1]\n",
    "        \n",
    "        elif i == d - 1: # g2=0\n",
    "            data += [g1 * ljk[i - 1, i_bis - 1], g1 * ljk[i - 1, i_bis - 2],\n",
    "                     g1 * ljk[i - 1, i_bis]]\n",
    "            row += 3 * [i]\n",
    "            col += [i_bis, i_bis - 1, i_bis + 1]\n",
    "\n",
    "    return coo_matrix((data, (row, col)), shape=(d, d), dtype='float').tocsc()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## packaging into a function for easy manipulation - iteration implementation \n",
    "# input: a (number of gens), n (number of samples), s, N (pop size)\n",
    "# output: mom (number of sites)\n",
    "def run_mom_iterate(a, n, s, N, mu, misc):\n",
    "    mom = np.zeros((a+1,n+1))\n",
    "    # momnp1 = np.zeros(n+1)\n",
    "    momkp1 = np.zeros(n+1)\n",
    "\n",
    "    D = 0.25/N * calcD(n+1)\n",
    "    J = calcJK13(n)\n",
    "    S = 0.5 * s * calcS(n+1, J)\n",
    "\n",
    "    # if N is same across all gens then only have to do this once\n",
    "    slv = linalg.factorized(sp.sparse.identity(S.shape[0], dtype=\"float\", format=\"csc\") - 0.5 * (D + S))\n",
    "    Q = sp.sparse.identity(S.shape[0], dtype=\"float\", format=\"csc\") + 0.5 * (D + S)\n",
    "\n",
    "    mom[a,1] = 1 # singleton input\n",
    "\n",
    "    # going from generation 9 to 0\n",
    "    for gen in np.arange(a)[::-1]:\n",
    "        momkp1 = slv(Q.dot(mom[gen+1,]))\n",
    "        momkp1[0] = momkp1[n] = 0.0\n",
    "\n",
    "        mom[gen,] = deepcopy(momkp1)\n",
    "\n",
    "    return mom[:-1,:]           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-05-17T16:02:54.161245Z",
     "iopub.status.busy": "2024-05-17T16:02:54.160786Z",
     "iopub.status.idle": "2024-05-17T16:02:54.302766Z",
     "shell.execute_reply": "2024-05-17T16:02:54.302286Z",
     "shell.execute_reply.started": "2024-05-17T16:02:54.161212Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = 1\n",
    "ibis1 = index_bis(i, 10); iter1 = index_bis(i+1, 10)\n",
    "ibis1, iter1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-06-06T21:15:11.485447Z",
     "iopub.status.busy": "2024-06-06T21:15:11.485031Z",
     "iopub.status.idle": "2024-06-06T21:15:11.644979Z",
     "shell.execute_reply": "2024-06-06T21:15:11.644589Z",
     "shell.execute_reply.started": "2024-06-06T21:15:11.485399Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(matrix([[0.000, 9.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000,\n",
       "          0.000, 0.000],\n",
       "         [0.000, -18.000, 16.000, 0.000, 0.000, 0.000, 0.000, 0.000,\n",
       "          0.000, 0.000, 0.000],\n",
       "         [0.000, 9.000, -32.000, 21.000, 0.000, 0.000, 0.000, 0.000,\n",
       "          0.000, 0.000, 0.000],\n",
       "         [0.000, 0.000, 16.000, -42.000, 24.000, 0.000, 0.000, 0.000,\n",
       "          0.000, 0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 21.000, -48.000, 25.000, 0.000, 0.000,\n",
       "          0.000, 0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 24.000, -50.000, 24.000, 0.000,\n",
       "          0.000, 0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 0.000, 25.000, -48.000, 21.000,\n",
       "          0.000, 0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 24.000, -42.000,\n",
       "          16.000, 0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 21.000,\n",
       "          -32.000, 9.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 16.000,\n",
       "          -18.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000,\n",
       "          9.000, 0.000]]),\n",
       " matrix([[0.000, -0.989, 0.183, -0.027, 0.000, 0.000, 0.000, 0.000, 0.000,\n",
       "          0.000, 0.000],\n",
       "         [0.000, 0.890, -1.832, 0.275, 0.000, 0.000, 0.000, 0.000, 0.000,\n",
       "          0.000, 0.000],\n",
       "         [0.000, 0.099, 1.429, -2.423, 0.396, 0.000, 0.000, 0.000, 0.000,\n",
       "          0.000, 0.000],\n",
       "         [0.000, 0.000, 0.220, 1.791, -2.857, 0.513, 0.000, 0.000, 0.000,\n",
       "          0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.385, 1.885, -3.013, 0.577, 0.000, 0.000,\n",
       "          0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 1.154, 0.000, -1.154, 0.000, 0.000,\n",
       "          0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, -0.577, 3.013, -1.885, -0.385,\n",
       "          0.000, 0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 0.000, -0.513, 2.857, -1.791,\n",
       "          -0.220, 0.000, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 0.000, 0.000, -0.396, 2.423, -1.429,\n",
       "          -0.099, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, -0.275, 1.832,\n",
       "          -0.890, 0.000],\n",
       "         [0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.027, -0.183,\n",
       "          0.989, 0.000]]))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# D = calcD(10+1)\n",
    "# J = calcJK13(10); S = calcS(11, J)\n",
    "D.todense(), S.todense()\n",
    "# (D+S).todense()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@jit(nopython=True)\n",
    "def run_mom_iterate_changing(n, s, Nc, mu, misc):\n",
    "    mom = np.zeros((len(Nc)+1,n+1))\n",
    "    # momnp1 = np.zeros(n+1)\n",
    "    momkp1 = np.zeros(n+1)\n",
    "\n",
    "    changepoints = len(Nc) - np.concatenate((np.array([0]),np.where(Nc[:-1] != Nc[1:])[0]+1),axis=0)\n",
    "    changepoints = np.append(changepoints, 0)\n",
    "\n",
    "    mom[len(Nc),1] = 1 # singleton input\n",
    "    \n",
    "    # only need to do this once - no dependence on N\n",
    "    J = calcJK13(n)\n",
    "    S = 0.5 * s * calcS(n+1, J)\n",
    "\n",
    "    for i in range(len(changepoints)-1):\n",
    "        D = 0.25/Nc[len(Nc)-changepoints[i]] * calcD(n+1)\n",
    "\n",
    "        slv = linalg.factorized(sp.sparse.identity(S.shape[0], dtype=\"float\", format=\"csc\") - 0.5 * (D + S))\n",
    "        Q = sp.sparse.identity(S.shape[0], dtype=\"float\", format=\"csc\") + 0.5 * (D + S)\n",
    "\n",
    "        for gen in np.arange(changepoints[i+1],changepoints[i])[::-1]:\n",
    "            momkp1 = slv(Q.dot(mom[gen+1,]))\n",
    "            momkp1[0] = momkp1[n] = 0.0\n",
    "\n",
    "            mom[gen,] = deepcopy(momkp1)\n",
    "\n",
    "    return mom[:-1,:]           "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## starting from the past to the present (Nc[-1] is current generation)\n",
    "# Nc = np.concatenate((np.repeat(20000,1000),np.repeat(2000,2000)))\n",
    "# changepoints = len(Nc) - np.concatenate((np.array([0]),np.where(Nc[:-1] != Nc[1:])[0]+1),axis=0)\n",
    "# changepoints = np.append(changepoints, 0)\n",
    "# mom_outc = run_mom_iterate_changing(1000, -0.000125, Nc/2, 1.25e-8, None)\n",
    "# plt.imshow(mom_outc[000:2100,:]/np.sum(mom_outc[000:2100]),aspect='auto',norm=colors.LogNorm()); plt.colorbar(); plt.show()\n",
    "# plt.imshow(up_xa_s[gamma2[-20]],aspect='auto',norm=colors.LogNorm(vmax=1e-3,vmin=1e-10)); plt.colorbar(); plt.show()\n",
    "plt.imshow(up_xa_s[-100.],aspect='auto',norm=colors.LogNorm(vmax=1e-3,vmin=1e-10)); plt.colorbar(); plt.show()\n",
    "# plt.plot(mom_outc[-100,:]); plt.plot(mom_outc[-2000,:]); plt.loglog(); plt.ylim((1e-10,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gamma2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'N' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [52]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# fs = run_mom_integrate(4000, 1000, 0.5*gamma[0]/N, N, mu, misc = {'dt_fac':0.02, 'adapt_dt':False})\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;66;03m# plt.imshow(fs[:,:],aspect='auto',norm=colors.LogNorm(vmax=10e-7,vmin=10e-30)); plt.colorbar(); plt.show()\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m fs2 \u001b[38;5;241m=\u001b[39m run_mom_integrate2(\u001b[38;5;241m4000\u001b[39m, \u001b[38;5;241m200\u001b[39m, \u001b[38;5;241m0.5\u001b[39m\u001b[38;5;241m*\u001b[39mgamma[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m/\u001b[39m\u001b[43mN\u001b[49m, N, mu, misc \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdt_fac\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;241m0.02\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124madapt_dt\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;28;01mFalse\u001b[39;00m})\n\u001b[1;32m      4\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(fs2[:,:],aspect\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mauto\u001b[39m\u001b[38;5;124m'\u001b[39m,norm\u001b[38;5;241m=\u001b[39mcolors\u001b[38;5;241m.\u001b[39mLogNorm(vmax\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10e-7\u001b[39m,vmin\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10e-30\u001b[39m)); plt\u001b[38;5;241m.\u001b[39mcolorbar(); plt\u001b[38;5;241m.\u001b[39mshow()\n",
      "\u001b[0;31mNameError\u001b[0m: name 'N' is not defined"
     ]
    }
   ],
   "source": [
    "# fs = run_mom_integrate(4000, 1000, 0.5*gamma[0]/N, N, mu, misc = {'dt_fac':0.02, 'adapt_dt':False})\n",
    "# plt.imshow(fs[:,:],aspect='auto',norm=colors.LogNorm(vmax=10e-7,vmin=10e-30)); plt.colorbar(); plt.show()\n",
    "# fs2 = run_mom_integrate2(4000, 200, 0.5*gamma[0]/N, N, mu, misc = {'dt_fac':0.02, 'adapt_dt':False})\n",
    "# plt.imshow(fs2[:,:],aspect='auto',norm=colors.LogNorm(vmax=10e-7,vmin=10e-30)); plt.colorbar(); plt.show()\n",
    "# mom = run_mom_iterate(8000, 2000, 0.5*gamma[10]/N, N, mu, np.nan)\n",
    "# plt.imshow(mom[:,:],aspect='auto',norm=colors.LogNorm(vmax=10e-7,vmin=10e-30)); plt.colorbar(); plt.show()\n",
    "# fs.shape, mom.shape\n",
    "# plt.scatter(np.ravel(mom[:,1:-1]), np.ravel(fs[:,1:-1]), color='grey', alpha=0.75, s=5); plt.loglog()\n",
    "# plt.axline((0,0),(1,1),color='coral',ls='--', linewidth=0.6); plt.xlabel('iterative framework'); plt.ylabel('integrative framework'); plt.title('γ = {}'.format(-100.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## function where each generation was integrated to separately\n",
    "def run_mom_integrate(a, n, s, N, mu, misc):\n",
    "    fsmat = np.zeros((a,n+1))\n",
    "    for idt, dt in enumerate(np.linspace(0.5/N,0.5*a/N,a)[::-1]):\n",
    "        fs = moments.Spectrum(np.zeros(n + 1))\n",
    "        fs[1] = 1\n",
    "        fs.integrate([1], dt, gamma=2*s*N, h=0.5, theta=0, dt_fac=misc['dt_fac'], adapt_dt=misc['adapt_dt'])\n",
    "        fsmat[idt,:] = n*mu*fs\n",
    "    return fsmat\n",
    "\n",
    "## function where each generation is only integrated from previous generation\n",
    "def run_mom_integrate2(a, n, s, N, mu, misc):\n",
    "    fsmat = np.zeros((a,n+1))\n",
    "    dt = 0.5/N\n",
    "    fs = moments.Spectrum(fsmat[-1,:])\n",
    "    fs[1] = 1\n",
    "    fs.integrate([1], dt, gamma=2*s*N, h=0.5, theta=0)\n",
    "    fsmat[-1,:] = fs\n",
    "    for idt in np.arange(0,a-1)[::-1]:\n",
    "        # fs = moments.Spectrum(fsmat[idt+1,:])\n",
    "        fs.integrate([1], dt, gamma=2*s*N, h=0.5, theta=0, dt_fac=misc['dt_fac'], adapt_dt=misc['adapt_dt'])\n",
    "        fsmat[idt,:] = fs\n",
    "    return n*mu*fsmat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fs.integrate([1],2,gamma=-10,theta=1)\n",
    "# fs1 = moments.Spectrum(np.zeros(n+1))\n",
    "# fs1[1]=1\n",
    "# fs1.integrate([1],2,gamma=-1,theta=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gamma2 = np.hstack((np.logspace(1,-2,10),0.0,-np.logspace(-2,1,10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## creating a database of P(X, a | s) with dicts for different s values\n",
    "# import io\n",
    "# up_xa_s = h5py.File(io.BytesIO(), 'w')\n",
    "# del up_xa_s\n",
    "gamma2 = -np.logspace(-.5,2.5,25,) \n",
    "# up_xa_s = dict.fromkeys(gamma2)\n",
    "## use different lengths of time for each gamma (high gamma - small limits)\n",
    "## go up to 5 orders of magnitude below start (i.e., E[# seg sites] < 1e-11)\n",
    "# limal = np.concatenate((np.linspace(7500,85000,20,dtype=int),np.repeat(85000,30)))\n",
    "# limal = np.linspace(140000,10000,25,dtype='int')\n",
    "# for ig, g in enumerate(gamma2):\n",
    "    # unscaled probability - almost likelihood\n",
    "    # up_xa_s[g] = run_mom_iterate(limal[ig], 2000, 0.5*g/N, N, 1.25e-8, misc = {'dt_fac':0.02, 'adapt_dt':True})\n",
    "    # can project down to any sample size using moments.Spectrum(p_xa_s[g][-1,:]).project([20])*120/20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# up_xa_s_neut = run_mom_iterate(100000, 2000, 0, N, 1.25e-8, misc = {'dt_fac':0.02, 'adapt_dt':True})\n",
    "cutoff = 2\n",
    "up_xa_s_neut[:,np.arange(cutoff,n-cutoff+1)] = up_xa_s_neut[:,np.arange(cutoff,n-cutoff+1)]/np.sum(up_xa_s_neut[:,np.arange(cutoff,n-cutoff+1)])\n",
    "p_xa_s_neut = np.sum(up_xa_s_neut, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "testup_xa_s = {}\n",
    "testup_xa_s[gamma[6]] = run_mom_integrate(80000, 2000, 0.5*g/N, N, mu, misc = {'dt_fac':0.02, 'adapt_dt':True})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# testup_xa_s[gamma[6]][:,np.arange(cutoff,n-cutoff+1)] = testup_xa_s[gamma[6]][:,np.arange(cutoff,n-cutoff+1)]/np.sum(testup_xa_s[gamma[6]][:,np.arange(cutoff,n-cutoff+1)])\n",
    "fs = moments.Spectrum(np.zeros(2000 + 1))\n",
    "fs[1] = 1\n",
    "fs.integrate([1], 120000/2/N, gamma=gamma[-1], theta=0, adapt_dt=True, dt_fac=0.0001)\n",
    "testp_xa_s = fs\n",
    "testp_xa_s[cutoff:(2000-cutoff+1)] = fs[cutoff:(2000-cutoff+1)]/np.sum(fs[cutoff:(2000-cutoff+1)])\n",
    "plt.plot(np.arange(2,1001),testp_xa_s[2:1001],marker='o'); plt.loglog()\n",
    "# testp_xa_s = np.sum(testup_xa_s[gamma[6]], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# use these plots to figure out when to stop (for gamma<1, ok could stop at 10k for high gamma)\n",
    "plt.scatter(np.arange(100000)[::-1],(np.sum(up_xa_s[-1.],axis=1)),alpha=0.7,color='k')\n",
    "plt.scatter(np.arange(100000)[::-1],(np.sum(up_xa_s[-.1],axis=1)),alpha=0.7,color='grey')\n",
    "plt.loglog(); plt.xlabel('gens'); plt.ylabel('exp # of seg sites')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## scaling the matrix from above to get pdf (all rows sum to 1)\n",
    "cutoff = 2 # 2 x # of inds\n",
    "for g in gamma2:\n",
    "    # normalizing by rows (summing across gens)\n",
    "    # p_xa_s[g] = up_xa_s[g]/up_xa_s[g].sum(axis=0,keepdims=1)\n",
    "    # up_xa_s[g][:,np.arange(cutoff,n-cutoff+1)] = up_xa_s[g][:,np.arange(cutoff,n-cutoff+1)]/up_xa_s[g][:,np.arange(cutoff,n-cutoff+1)].sum(axis=1,keepdims=True)\n",
    "    # normalizing by rows and cols (summing across gens and # of derived alleles)\n",
    "    # p_xa_s[g] = up_xa_s[g]/np.sum(up_xa_s[g])\n",
    "    # normalizing by rows and cols and number of derived alleles (based on if detectable in sample or not)\n",
    "    up_xa_s[g][:,np.arange(cutoff,2000-cutoff+1)] = up_xa_s[g][:,np.arange(cutoff,2000-cutoff+1)]/np.sum(up_xa_s[g][:,np.arange(cutoff,2000-cutoff+1)]) \n",
    "    # normalizing by rows (summing across allele freqs)\n",
    "    # up_xa_s[g][:,np.arange(cutoff,n-cutoff+1)] = up_xa_s[g][:,np.arange(cutoff,n-cutoff+1)]/up_xa_s[g][:,np.arange(cutoff,n-cutoff+1)].sum(axis=1,keepdims=True)\n",
    "\n",
    "# import pickle as pkl\n",
    "# with open('testdata/fsintegrate.pkl', 'wb') as f:\n",
    "#     pkl.dump(up_xa_s, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## summing across rows and then normalizing to get P(X|\\gamma) \n",
    "# del p_xa_s\n",
    "p_xa_s = {}\n",
    "for g in gamma2:\n",
    "    fs = moments.Spectrum(np.zeros(2000+1))\n",
    "    fs[1] = 1\n",
    "    fs.integrate([0.5], 10, gamma=g)\n",
    "    p_xa_s[g] = fs/np.sum(fs[np.arange(cutoff,2000-cutoff+1)])\n",
    "    # p_xa_s[g] = np.sum(up_xa_s[g], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# moments.Plotting.plot_1d_fs(p_xa_s[gamma2[-15]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x17e28e590>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x420 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(dpi=120)\n",
    "fs = moments.Spectrum(np.zeros(100),); fs[1] = 500\n",
    "fs.integrate([0.5],4,gamma=-1,theta=10); #fs = fs.project([11])*100/11\n",
    "plt.bar(x=range(1,99),height=np.array(fs[1:-1]),color='pink',alpha=0.8,label=r'Model $\\mathbb{E}[X \\mid \\gamma,\\theta]$'); \n",
    "plt.plot(range(1,99),[rng.poisson(fs[i]) for i in range(1,99)],'k-o',alpha=0.7,markersize=4,label=r'Data $\\mathbf{X}$'); \n",
    "plt.xlabel('# of allele copies'); plt.ylabel('E[i|γ]'); plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(p_xa_s[gamma2[-10]],np.sum(up_xa_s[gamma2[-10]],axis=0),alpha=0.8); plt.loglog(); plt.axline((0,0),(1,1),ls='--')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.imshow(up_xa_s[gamma[15]],aspect='auto',norm=colors.LogNorm(vmax=1e-7,vmin=1e-20)); plt.colorbar()\n",
    "# np.min(p_xa_s[gamma[4]][10,:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading in simulation data for comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import os\n",
    "# os.chdir(\"/Users/vivaswatshastry/selCoefEst/PReFerSims\")\n",
    "## using the Rcpp code to simulate population allele freqs\n",
    "# df2 = pd.read_csv(\"../traindata/trip-2022-03-29.csv\")\n",
    "# df2['gamma'] = df2['gamma'].round(decimals=2)\n",
    "# df2['empty'] = ''\n",
    "# df2['empty2'] = ''\n",
    "# df2['sXl'] = rng.binomial(n=2000, p=df2['Xl'])\n",
    "# gamma = np.unique(df2['gamma'])\n",
    "## using PReFerSim to simulate sample allele freqs (already simulated, just reading in)\n",
    "gamma = np.array([-100.,-30.,-10.,-3.,-1.])\n",
    "Xldata = np.empty(1,dtype='int'); aldata = np.empty(1,dtype='int'); gldata = np.empty(1)\n",
    "for g in gamma:\n",
    "    df = pd.read_csv(\"outfiles/ConstantSize{}_n400_sim{}.3.full_out.txt\".format(-g,12),sep='\\t',header=None,)\n",
    "    df.columns = ['','Xl','s','al','id']\n",
    "    df['empty'] = ''\n",
    "    # Xldata.append((df['Xl']*400).astype('int').tolist())\n",
    "    Xldata = np.append(Xldata,(df['Xl']*400).astype('int').tolist())\n",
    "    df['al'] = 80000+1 - df['al']\n",
    "    aldata = np.append(aldata,df['al'].astype('int').tolist())\n",
    "    gldata = np.append(gldata,np.repeat(g,len(df)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df2 = pd.DataFrame({'g':gldata[1:],'X':Xldata[1:],'a':aldata[1:]})\n",
    "dat2 = df2.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'gamma' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [8]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# df1['sXl'] = np.around(df1['Xl']*n).astype(int)\u001b[39;00m\n\u001b[1;32m      2\u001b[0m nsites \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m2000\u001b[39m\n\u001b[0;32m----> 3\u001b[0m idx2keep \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mempty(\u001b[38;5;28mlen\u001b[39m(\u001b[43mgamma\u001b[49m)\u001b[38;5;241m*\u001b[39mnsites,dtype\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mint\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m ig, _ \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(gamma):\n\u001b[1;32m      5\u001b[0m     idx2keep[(ig\u001b[38;5;241m*\u001b[39mnsites):(ig\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m*\u001b[39mnsites] \u001b[38;5;241m=\u001b[39m rng\u001b[38;5;241m.\u001b[39mchoice(np\u001b[38;5;241m.\u001b[39mwhere(df2[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msXl\u001b[39m\u001b[38;5;124m'\u001b[39m][(ig\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m5000\u001b[39m):(ig\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m5000\u001b[39m]\u001b[38;5;241m>\u001b[39m\u001b[38;5;241m1\u001b[39m)[\u001b[38;5;241m0\u001b[39m], nsites, \u001b[38;5;28;01mFalse\u001b[39;00m) \u001b[38;5;241m+\u001b[39m ig\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m5000\u001b[39m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'gamma' is not defined"
     ]
    }
   ],
   "source": [
    "# df1['sXl'] = np.around(df1['Xl']*n).astype(int)\n",
    "nsites = 2000\n",
    "idx2keep = np.empty(len(gamma)*nsites,dtype='int')\n",
    "for ig, _ in enumerate(gamma):\n",
    "    idx2keep[(ig*nsites):(ig+1)*nsites] = rng.choice(np.where(df2['sXl'][(ig*5000):(ig+1)*5000]>1)[0], nsites, False) + ig*5000\n",
    "df2 = df2.iloc[idx2keep,:]\n",
    "dat2 = df2.to_numpy()\n",
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from statsmodels.distributions.empirical_distribution import ECDF\n",
    "## PReFerSim selection coefficient is HALF of backward WF sims (need to test this further—simple to rerun cell, but long runtime)\n",
    "def plot_ecdf_al_sxl(idx):\n",
    "    indices = np.arange((19*1000),(19+1)*1000)\n",
    "    indices2 = np.arange((16*1000),(16+1)*1000)\n",
    "    age1_ecdf = ECDF(df1['al'][::-1].iloc[indices])\n",
    "    age2_ecdf = ECDF(df2['al'].iloc[indices2])\n",
    "    x = np.linspace(1,np.max(df2['al'].iloc[indices]))\n",
    "    y1 = age1_ecdf(x)\n",
    "    y2 = age2_ecdf(x)\n",
    "    plt.plot(x, y1, color='green', alpha=0.7, label='PReFerSim vals'); plt.xlabel('age (gens)'); plt.semilogx()\n",
    "    plt.plot(x, y2, color='purple', alpha=0.7, label='backward approx WF vals'); plt.title('γ={}'.format(gamma[0])); plt.legend()\n",
    "\n",
    "plot_ecdf_al_sxl(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# df2['gamma'].iloc[np.arange((16*1000),(16+1)*1000)], df1['s'][::-1].iloc[np.arange((19*1000),(19+1)*1000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# interpolate gamma (in other words, I need a denser grid of gamma values around the MLE for better quadratic estimation)\n",
    "interp_gamma = np.zeros((len(gamma),5))\n",
    "interp_gamma[0,] = -np.exp(np.linspace(np.log(-gamma[1]),np.log(125),5))\n",
    "for ig, g in enumerate(gamma[1:-1]):\n",
    "    interp_gamma[ig+1,] = -np.exp(np.linspace(np.log(-gamma[ig+2]),np.log(-gamma[ig]),5))\n",
    "interp_gamma[-1,] = -np.exp(np.linspace(np.log(0.7),np.log(-gamma[-2]),5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## going through and deleting entries that are very close to each other (tol=1)\n",
    "interp_gamma = interp_gamma.round(2)\n",
    "print(interp_gamma)\n",
    "it_gamma = np.unique(np.hstack((gamma,np.ravel(interp_gamma))))\n",
    "it_gamma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## function to obtain the log P(X,|gamma)\n",
    "def get_lp_xl(g, sXlred, n=2000, cutoff=20):\n",
    "    \"\"\"function to compute L(gamma|Xl), where gamma is a range of values and Xl is a given set of freqs\"\"\"\n",
    "    res = np.empty(np.sum((sXlred>cutoff) & (sXlred<n-cutoff+1))) #np.empty(len(Xlred))\n",
    "\n",
    "    # just performing a search in a look-up table\n",
    "    for idx, i in enumerate(np.where((sXlred>cutoff) & (sXlred<n-cutoff+1))[0]):\n",
    "        res[idx] = p_xa_s[g][sXlred[i]]\n",
    "    \n",
    "    return np.log(res)\n",
    "\n",
    "def get_lp_xl2(g, sXlred, n=2000, cutoff=20):\n",
    "    \"\"\"function to compute L(gamma|Xl), where gamma is a range of values and Xl is a given set of freqs\"\"\"\n",
    "    res = np.empty(np.sum((sXlred>cutoff) & (sXlred<n-cutoff+1))) #np.empty(len(Xlred))\n",
    "\n",
    "    # ub = np.exp(2.*g)*scipy.special.expi(-2.*g*0.25/N) - scipy.special.expi(2.*g*(1-0.25/N)) - np.exp(2.*g)*(np.log(0.25/N) - np.log(1-0.25/N))\n",
    "    # lb = np.exp(2.*g)*scipy.special.expi(2.*g*(0.25/N-1)) - scipy.special.expi(2.*g*0.25/N) - np.exp(2.*g)*(np.log(1-0.25/N) - np.log(0.25/N))\n",
    "    ub = np.exp(2.*g)*sp.special.expi(-2.*g*0.5*cutoff/n) - sp.special.expi(2.*g*(1-0.5*cutoff/n)) - np.exp(2.*g)*(np.log(0.5*cutoff/n) - np.log(1-0.5*cutoff/n))\n",
    "    lb = np.exp(2.*g)*sp.special.expi(2.*g*(0.5*cutoff/n-1)) - sp.special.expi(2.*g*0.5*cutoff/n) - np.exp(2.*g)*(np.log(1-0.25/n) - np.log(0.5*cutoff/n))\n",
    "    scalfact = (ub - lb)/np.expm1(2.*g)\n",
    "\n",
    "    # return a vector...\n",
    "    for isx, sx in enumerate(np.where((sXlred>cutoff) & (sXlred<n-cutoff+1))[0]):\n",
    "        res[isx] = (1-np.exp(-2*g*(1-sXlred[sx]/n)))/(sXlred[sx]/n*(1-sXlred[sx]/n)*(1-np.exp(-2*g)))\n",
    "\n",
    "    return np.log(res/scalfact)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## don't need a function since the dict already exists\n",
    "Xsamp = np.arange(1,n+1)/n\n",
    "plt.hist([np.argmin(np.abs(dat[i,0]-Xsamp))+1 for i in range(len(dat))],bins=200);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.hist(newdat[:,2],bins=100)\n",
    "# plt.hist2d(np.log(newdat[:,0]),newdat[:,2][::-1],(25,25)); plt.colorbar()\n",
    "# print(newdat[-5:,])\n",
    "np.where(np.isinf(get_lp_alxl(gamma[-2], newdat[:,0], newdat[:,2], 100)))\n",
    "# print(newdat[429,])\n",
    "# get_lp_alxl(gamma[-2], newdat[:,0], newdat[:,2], 100)\n",
    "# sXlred = np.around(newdat[:,0]*100).astype(int)\n",
    "# np.sum((sXlred>0) & (sXlred<100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings('error')\n",
    "## just doing a lookup of sorts for the right probability\n",
    "def get_lp_alxl(g, sXlred, alred, n=2000, cutoff=2):\n",
    "    # Xsamp = np.arange(1,n)/n\n",
    "    # sXlred = np.around(Xlred*n).astype(int) # rng.binomial(n, Xlred, len(Xlred))\n",
    "    res = np.empty(np.sum((sXlred>cutoff) & (sXlred<n-cutoff+1)))\n",
    "    for idx, i in enumerate(np.where((sXlred>cutoff) & (sXlred<n-cutoff+1))[0]):\n",
    "        # if too many gens, then pass in a very low number (like -400.)\n",
    "        # res[i] = np.log(p_xa_s[g][-int(alred[i]),np.argmin(np.abs(Xlred[i]-Xsamp))+1]) if (int(alred[i]<p_xa_s[g].shape[0])) else -400. \n",
    "        try:\n",
    "            res[idx] = np.log(up_xa_s[g][-int(alred[i]),sXlred[i]]) if (int(alred[i])<up_xa_s[g].shape[0]) else np.median(np.log(up_xa_s[g][0,cutoff:(n-cutoff+1)]))\n",
    "        except RuntimeWarning:\n",
    "            print(g, sXlred[i], alred[i])\n",
    "        # if np.isinf(res[idx]):\n",
    "        #     print(i, Xlred[i], alred[i])\n",
    "\n",
    "    return res\n",
    "\n",
    "def get_lp_alxl_nocheck(g, sXlred, alred, n=2000, cutoff=2):\n",
    "    ## version of function with no check for cutoff\n",
    "    res = np.log(up_xa_s[g][-int(alred),sXlred]) if (int(alred)<up_xa_s[g].shape[0]) else np.median(np.log(up_xa_s[g][0,cutoff:(n-cutoff+1)]))\n",
    "\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## finding how many alleles have ages beyond computed values in the lookup matrix/table (like 4)\n",
    "for ig, g in enumerate(gamma):\n",
    "    alred = df1['al'].iloc[ig*1000:(ig+1)*1000]\n",
    "    print(g, np.sum(alred>up_xa_s[g].shape[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Code to run continuous optimization of framework instead of dicrete grid\n",
    "\n",
    "Here, I will construct a method to compute the likelihood of a given dataset for any $\\gamma$ value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ll_freq(g, sXlred, n=2000, cutoff=2):\n",
    "    fs = moments.Spectrum(np.zeros(n+1))\n",
    "    fs[1] = 1\n",
    "    fs.integrate([0.5], 10, gamma=g)\n",
    "    pxs = fs/np.sum(fs[np.arange(cutoff,n-cutoff+1)])\n",
    "\n",
    "    res = np.empty(np.sum((sXlred>cutoff) & (sXlred<n-cutoff+1))) #np.empty(len(Xlred))\n",
    "\n",
    "    # just performing a search in a look-up table\n",
    "    for idx, i in enumerate(np.where((sXlred>cutoff) & (sXlred<n-cutoff+1))[0]):\n",
    "        res[idx] = pxs[sXlred[i]]\n",
    "    \n",
    "    return -np.sum(np.log(res))\n",
    "@jit(forceobj=True)\n",
    "def get_ll_freqage(g, sXlred, alred, n=2000, cutoff=2):\n",
    "    pxas = run_mom_iterate(int(100000+900*g), n, 0.5*g/N, N, 1.25e-8, misc = {'dt_fac':0.02, 'adapt_dt':True})\n",
    "    \n",
    "    pxas[:,np.arange(cutoff,n-cutoff+1)] = pxas[:,np.arange(cutoff,n-cutoff+1)]/np.sum(pxas[:,np.arange(cutoff,n-cutoff+1)]) \n",
    "\n",
    "    res = np.empty(np.sum((sXlred>cutoff) & (sXlred<n-cutoff+1)),dtype='float32')\n",
    "    for idx, i in enumerate(np.where((sXlred>cutoff) & (sXlred<n-cutoff+1))[0]):\n",
    "        res[idx] = np.log(pxas[-int(alred[i]),sXlred[i]]) if (int(alred[i])<pxas.shape[0]) else np.median(np.log(pxas[0,cutoff:(n-cutoff+1)]))\n",
    "\n",
    "    return -np.sum(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_sims = 16\n",
    "parestfreq = np.zeros((4,num_sims))\n",
    "parestage = np.zeros((4,num_sims))\n",
    "for ig, g in enumerate([1.,10.,100.]):\n",
    "    for n in range(num_sims):\n",
    "        with open('simfiles/ParameterFilesConstant.txt',\"r\") as file:\n",
    "            data = file.readlines()\n",
    "\n",
    "        data[0] = 'MutationRate: {:f}\\n'.format(2)\n",
    "        data[2] = 'DFEPointSelectionCoefficient: {:.8f}\\n'.format(-0.5*g/10000)\n",
    "        data[7] = 'FilePrefix: outfiles/ConstantSize{}_n{}_sim{}_t2\\n'.format(-g,400,n)\n",
    "\n",
    "        with open('simfiles/ParameterFilesConstant.txt', 'w') as file:\n",
    "            file.writelines(data)\n",
    "        \n",
    "        os.system(\"GSL_RNG_SEED={} GSL_RNG_TYPE=mrg ../../PReFerSim/PReFerSim simfiles/ParameterFilesConstant.txt 3 > /dev/null 2>&1 \".format(rng.integers(100496)))\n",
    "\n",
    "        dft = pd.read_csv('outfiles/ConstantSize{}_n{}_sim{}_t2.3.full_out.txt'.format(-g,400,n),sep='\\t',header=None,names=['','Xl','s','al','id'])\n",
    "        dft['empty'] = ''\n",
    "        dft['sXl'] = (dft['Xl']*400).astype('int')\n",
    "        dft['al'] = 80000+1 - dft['al']\n",
    "        dft['al'] = dft['al'].astype('int')\n",
    "        dft = dft.iloc[:,1:]\n",
    "        datt = dft.to_numpy()\n",
    "\n",
    "        SMS = np.zeros((80000,400+1),dtype='int16')\n",
    "        mask = np.zeros_like(SMS); mask[0,:] = 1; mask[:,0] = 1; mask[:,-1] = 1;\n",
    "        for i in range(len(datt)):\n",
    "            SMS[datt[i,2],datt[i,5]] += 1\n",
    "        SMSmask = np.ma.array(SMS,mask=mask)\n",
    "\n",
    "        sfs = moments.Spectrum(np.histogram(datt[:,5],bins=range(0,402))[0])\n",
    "\n",
    "        # parestfreq[ig,n] = sp.optimize.minimize_scalar(get_ll_freq, args=(datt[:,5]), options={'xtol': .05,}).x\n",
    "        # parestage[ig,n] = sp.optimize.minimize_scalar(get_ll_freqage, args=(datt[:,5], datt[:,2]), options={'xtol': .2}).x\n",
    "        parestfreq[ig,n] = sp.optimize.minimize_scalar(get_ll_freqconstant_notfm,args=({'sfs':sfs,'theta':2,'p_misid':0},400)).x\n",
    "        parestage[ig,n] = sp.optimize.minimize_scalar(get_ll_freqageconstant_notfm,args=({'sms':SMSmask,'theta':2,'N':10000,'p_misid':0,'gens':80000},400)).x\n",
    "\n",
    "        print(parestfreq[ig,n],parestage[ig,n])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sp.optimize.minimize_scalar(get_ll_freqconstant_notfm,args=({'sfs':sfs,'theta':200,'p_misid':0},400)).x, sp.optimize.minimize_scalar(get_ll_freqageconstant_notfm,args=({'sms':SMSmask,'theta':200,'N':10000,'p_misid':0,'gens':80000},400)).x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parestfreq, parestage/2\n",
    "# 10**sp.optimize.minimize_scalar(get_ll_freqageconstant,args=({'sms':SMSmask,'theta':400,'N':10000,'p_misid':0,'gens':80000},400),).x\n",
    "# 10**sp.optimize.minimize_scalar(get_ll_freqageconstant,args=({'sms':SMSmask,'theta':4,'N':10000,'p_misid':0,'gens':80000},400),).x\n",
    "# run_mom_iterate_constant??\n",
    "# -10**sp.optimize.minimize_scalar(get_ll_freqconstant,args=({'sfs':sfs,'theta':400,'p_misid':0},200)).x\n",
    "# parestfreq.std(axis=1)\n",
    "# dft = pd.read_csv('PReFerSims/outfiles/ConstantSize0.0.1.full_out.txt',sep='\\t',header=None,names=['','Xl','s','al','id'])\n",
    "# dft['empty'] = ''\n",
    "# dft['sXl'] = (dft['Xl']*400).astype('int')\n",
    "# dft['al'] = 80000+1 - dft['al']\n",
    "# dft['al'] = dft['al'].astype('int')\n",
    "# dft = dft.iloc[:,1:]\n",
    "# datt = dft.to_numpy()\n",
    "\n",
    "# sfs = moments.Spectrum(np.histogram(datt[:,5],bins=range(0,402))[0])\n",
    "# print(sp.optimize.minimize_scalar(get_ll_freqconstant_notfm,args=({'sfs':sfs,'theta':400,'p_misid':0},400)))\n",
    "\n",
    "# SMS = np.zeros((80000,400+1),dtype='int16')\n",
    "# mask = np.zeros_like(SMS); mask[0,:] = 1; mask[:,0] = 1; mask[:,-1] = 1;\n",
    "# for i in range(len(datt)):\n",
    "#     SMS[datt[i,2],datt[i,5]] += 1\n",
    "# SMSmask = np.ma.array(SMS,mask=mask)\n",
    "# plt.plot(np.linspace(-125,125,20),[get_ll_freqageconstant_notfm(g,{'sms':SMSmask,'theta':4,'N':10000,'p_misid':0,'gens':80000},400) for g in np.linspace(-125,125,20)],'ko')\n",
    "# sp.optimize.minimize_scalar(get_ll_freqageconstant_notfm,args=({'sms':SMSmask,'theta':400,'N':10000,'p_misid':0,'gens':80000},400))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parestfreq = -np.array([[100.756, 104.793, 104.931, 99.876, 98.784, 90.711, 97.843, 101.897, 100.753, 99.271],\n",
    "#         [9.616, 9.769, 10.315, 9.405, 10.001, 9.913, 9.895, 9.425, 9.713, 10.653],\n",
    "#         [1.113, 1.151, 1.204, 0.938, 1.036, 0.911, 1.122, 0.915, 1.026, 1.046],\n",
    "#         [-4.35832402069063e-45, -4.35832402069063e-45, -4.35832402069063e-45, -4.35832402069063e-45, -4.35832402069063e-45, -1.971976596466917e-15, -1.971976596466917e-15, -1.971975942072855e-15, -4.35832402069063e-45, -4.35832402069063e-45, -4.35832402069063e-45]])\n",
    "# parestage = -np.array([[107.958, 103.559, 111.178, 105.733, 98.938, 95.403, 104.087, 104.810, 103.923, 106.285],\n",
    "#         [10.354, 9.969, 10.613, 9.571, 10.331, 10.372, 10.616, 9.793, 10.120, 11.210],\n",
    "#         [1.005, 1.193, 1.148, 0.99, 0.846, 1.126, 0.93, 1.089, 1.044, 1.02]])\n",
    "\n",
    "# parestage = np.array([[-72.638, -72.416, -72.477, -72.360, -72.582, -72.191, -72.398,\n",
    "#          -72.534, -72.418, -72.591, -72.341, -72.598, -72.206, -72.451,\n",
    "#          -72.207, -72.625, -72.508, -72.380, -72.447, -72.224],\n",
    "#         [-25.950, -26.648, -25.815, -27.308, -26.011, -26.545, -25.472,\n",
    "#          -26.114, -25.423, -26.061, -25.936, -25.875, -25.913, -26.334,\n",
    "#          -26.247, -26.006, -27.079, -26.789, -26.381, -26.240],\n",
    "#         [-11.182, -10.847, -10.509, -10.994, -10.700, -10.616, -10.484,\n",
    "#          -10.843, -10.313, -11.236, -10.623, -10.742, -10.775, -10.517,\n",
    "#          -10.198, -10.811, -10.679, -10.517, -11.417, -10.289],\n",
    "#         [-2.967, -3.017, -3.077, -2.870, -2.618, -3.203, -3.312, -2.521,\n",
    "#          -2.955, -2.772, -2.618, -2.797, -2.593, -2.700, -3.156, -3.265, -3.135, -2.559, -2.755, -2.576],\n",
    "#         [-0.995, -0.618, -0.618, -0.618, -0.618, -0.908, -0.618, -0.618,\n",
    "#          -0.618, -0.618, -0.618, -0.618, -1.181, -0.618, -0.742, -0.618, -0.818, -0.742, -0.618, -0.742]],dtype=float)\n",
    "\n",
    "# parestfreq = np.array(([[-76.064, -70.595, -72.271, -70.274, -76.273, -66.556, -69.697, -74.476, -70.613, -73.723, -71.448, -74.220, -67.808, -71.549, -66.524, -77.530, -74.721, -71.273, -71.199, -66.284],[-23.513, -25.072, -24.235, -24.239, -23.385, -26.478, -23.393, -25.434, -22.406, -23.127, -24.769, -24.344, -24.670, -24.671, -23.045, -22.772, -27.346, -26.433, -24.705, -23.759],[-9.703, -7.282, -8.675, -7.885, -8.933, -9.850, -6.890, -7.391, -10.592, -7.572, -16.959, -7.963, -6.882, -17.281, -10.580, -19.203, -7.826, -18.361, -10.170, -9.423],[-1.969, -1.924, -1.915, -2.075, -2.034, -2.074, -2.038, -1.928, -2.039, -2.079, -2.634, -2.056, -1.916, -2.645, -2.654, -2.971, -2.752, -1.876,\n",
    "#        -2.518, -2.279],[-1.346, -0.618, -0.960, -0.618, -0.916, -1.148, -0.618, -0.618,-1.016, -0.824, -0.618, -0.814, -1.439, -0.943, -0.930, -1.000, -1.083, -0.885, -0.950, -0.964]]),dtype=float)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def setViolColors(bp):\n",
    "    bp['bodies'][0].set_facecolor('deepskyblue')\n",
    "    bp['bodies'][0].set_alpha(0.8)\n",
    "    bp['bodies'][0].set_linewidth(1)\n",
    "    bp['cbars'].set_colors('grey')\n",
    "    bp['cbars'].set_alpha(0.6)\n",
    "    bp['cmins'].set_color('grey')\n",
    "    bp['cmaxes'].set_color('grey')\n",
    "    # plt.setp(bp['cbars'][0], color='deepskyblue')\n",
    "    # plt.setp(bp['caps'][1], color='deepskyblue')\n",
    "    # plt.setp(bp['whiskers'][0], color='deepskyblue')\n",
    "    # plt.setp(bp['whiskers'][1], color='deepskyblue')\n",
    "    # plt.setp(bp['fliers'][0], color='deepskyblue')\n",
    "    # plt.setp(bp['medians'][0], color='deepskyblue')\n",
    "\n",
    "    plt.setp(bp['bodies'][1], color='coral', alpha=0.8)\n",
    "    # plt.setp(bp['cbars'][1], color='coral')\n",
    "    # plt.setp(bp['caps'][3], color='coral')\n",
    "    # plt.setp(bp['whiskers'][2], color='coral')\n",
    "    # plt.setp(bp['whiskers'][3], color='coral')\n",
    "    # plt.setp(bp['fliers'][1], color='coral')\n",
    "    # plt.setp(bp['medians'][1], color='coral')\n",
    "\n",
    "fig = plt.figure(dpi=130)\n",
    "ax = plt.axes()\n",
    "s = np.array([-100.,-10.,-1.,0])\n",
    "# hold(True)\n",
    "\n",
    "for i in range(len(s)):\n",
    "    # bp = plt.boxplot([parestfreq[i,~np.isnan(parestfreq[i,:])],parestage[i,~np.isnan(parestage[i,:])]],positions=[3*i+1,3*i+2], widths=0.6,flierprops=dict(marker='x',markersize=5,alpha=0.5),)\n",
    "    # setBoxColors(bp)\n",
    "    vp = plt.violinplot([parestfreq[i,:],parestage[i,:]],positions=[3*i+1,3*i+2], widths=0.6,)\n",
    "    setViolColors(vp)\n",
    "    plt.axhline(s[i],color='grey',ls='--',alpha=0.6)\n",
    "\n",
    "# bp = plt.boxplot([parestfreq0,parestage0],positions=[16,17],widths=0.6,flierprops=dict(marker='x',markersize=5,alpha=0.5))\n",
    "# setBoxColors(bp) \n",
    "# vp = plt.violinplot([-parestfreq[-1,:],-parestage[-1,:]],positions=[9,10],widths=0.6,)\n",
    "# setViolColors(vp)\n",
    "# plt.axhline(0.,color='grey',ls='--',alpha=0.6);\n",
    "\n",
    "# ax.set_xticks([1.5,4.5,7.5,10.5,13.5,16.5]); ax.set_xticklabels(np.ravel(s.tolist()+[0.])); ax.set_yscale('symlog');\n",
    "ax.set_xticks([1.5,4.5,7.5,10.5]); ax.set_xticklabels(np.ravel(s.tolist())); ax.set_yscale('symlog'); ax.set_yticks([-100.,-10.,-1.,0,]); plt.grid()\n",
    "\n",
    "hB, = plt.plot([1,0],'-',color='deepskyblue'); hR, = plt.plot([1,0],'-',color='coral'); hB.set_visible(False); hR.set_visible(False)\n",
    "plt.xlabel('true γ value'); plt.ylabel('MLE γ value (20 replicates)')\n",
    "plt.legend((hB, hR),('freq only, RMSLE: {:.2f}'.format(np.sqrt(np.mean((np.log10(-s+1)-np.log10(np.nanmean(parestfreq,axis=1)))**2))), 'freq & age, RMSLE: {:.2f}'.format(np.sqrt(np.mean((np.log10(-s+1)-np.log10(np.nanmean(parestage,axis=1)))**2)))),loc='upper left')\n",
    "# plt.savefig(\"../figs/MLEfreqage2.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot([-100,-10,-1,0],np.std(parestfreq,axis=1)/np.std(parestage,axis=1),'k-o', alpha=0.7); plt.xscale('symlog'); plt.ylabel('ratio of SD'); plt.xlabel(r'$\\gamma$'); plt.axhline(1,color='grey')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dft = pd.read_csv('outfiles/ConstantSize100.0.3.full_out.txt',sep='\\t',header=None,names=['','Xl','s','al','id'])\n",
    "dft['empty'] = ''\n",
    "dft['sXl'] = (dft['Xl']*400).astype('int')\n",
    "dft['al'] = 80000+1 - dft['al']\n",
    "dft['al'] = dft['al'].astype('int')\n",
    "dft = dft.iloc[:,1:]\n",
    "datt = dft.to_numpy()\n",
    "\n",
    "SMS = np.zeros((80000,400+1),dtype='int16')\n",
    "mask = np.zeros_like(SMS); mask[0,:] = 1; mask[:,0] = 1; mask[:,-1] = 1;\n",
    "for i in range(len(datt)):\n",
    "    if (datt[i,2]<80000) & (datt[i,5]<400):\n",
    "        SMS[datt[i,2],datt[i,5]] += 1\n",
    "SMSmask = np.ma.array(SMS,mask=mask)\n",
    "\n",
    "# thetas = np.logspace(0,2,12)\n",
    "# gammas = np.logspace(-1,2,12,base=10)\n",
    "# ll2d = np.zeros((len(thetas),len(gammas)))\n",
    "# for it, t in enumerate(thetas):\n",
    "#     for ig, g in enumerate(gammas):\n",
    "#         ll2d[it,ig] = get_ll_freqageconstant(np.log10(g),{'sms':SMSmask,'theta':t,'N':10000,'p_misid':0,'gens':50000},400)\n",
    "\n",
    "# plt.imshow(-ll2d+np.min(ll2d),vmin=-1000); plt.colorbar(); plt.ylabel(r'$\\theta$'); plt.xlabel(r'$\\gamma$'); plt.yticks(np.arange(0,12,3),labels=np.round(thetas[::3],1)); plt.xticks(np.arange(0,12,3),labels=np.round(gammas[::3],1)); plt.plot(8,4,'kx'); plt.axvline(8.3,color='red')\n",
    "# plt.plot(np.linspace(1,10,5),[get_ll_freqageconstant(np.log10(10),{'sms':SMSmask,'theta':t,'N':10000,'p_misid':0,'gens':20000},200) for t in np.linspace(1,10,5)])\n",
    "# get_ll_freqageconstant(np.log10(1),{'sms':SMSmask,'theta':400,'N':10000,'p_misid':0,'gens':100000},400), get_ll_freqageconstant(np.log10(1),{'sms':SMSmask,'theta':4,'N':10000,'p_misid':0,'gens':100000},400), get_ll_freqageconstant(np.log10(1e-7),{'sms':SMSmask,'theta':4,'N':10000,'p_misid':0,'gens':100000},400)\n",
    "# sp.optimize.minimize_scalar(get_ll_freqageconstant,args=({'sms':SMSmask,'theta':7.2,'N':10000,'p_misid':0,'gens':50000},400))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SMSmask.sum(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Relevent error distribution for allele ages\n",
    "Initially, using a simplification of estimates from Figure 2 in Albers & McVean, 2018 (piecewise-linear fit) with Poisson distributed error. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_age_err(simal, rng, errvar):\n",
    "    erral = np.zeros_like(simal,dtype='int')\n",
    "    mask1 = (simal>0) & (simal<21)\n",
    "    mask2 = (simal>20) & (simal<1001)\n",
    "    mask3 = (simal>1000) & (simal<20001)\n",
    "    mask4 = simal>20000\n",
    "    \n",
    "    erral[mask1] = rng.normal(rng.poisson(10+simal[mask1].astype('int')*1.5, ),errvar[0])\n",
    "    erral[mask2] = rng.normal(rng.poisson(15+simal[mask2].astype('int')*95/98, ),errvar[1])\n",
    "    erral[mask3] = rng.normal(rng.poisson(700+simal[mask3].astype('int')*6/19, ),errvar[2])\n",
    "    erral[mask4] = rng.normal(rng.poisson(2000+simal[mask4].astype('int')*80/98, ),errvar[3])\n",
    "\n",
    "    # erral[mask1] = rng.lognormal(simal[mask1].astype('int')*1.5, 0.02)\n",
    "    # erral[mask2] = rng.lognormal(15+simal[mask2].astype('int')*95/98, 0.02)\n",
    "    # erral[mask3] = rng.lognormal(400+simal[mask3].astype('int')*11/19, 0.02)\n",
    "    # erral[mask4] = rng.lognormal(2000+simal[mask4].astype('int')*80/98, 0.02)\n",
    "\n",
    "    return erral"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rng = np.random.RandomState(234)\n",
    "# errvar = [20,100,200,1500]\n",
    "errvar = np.repeat(0,4)\n",
    "erral = get_age_err(np.repeat(np.arange(10000)+1,20),rng,errvar)\n",
    "# plt.hist(erral[mask1],50)\n",
    "# plt.hist(simal[mask1],50)\n",
    "plt.figure(dpi=120); plt.scatter(np.repeat(np.arange(10000)+1,20),erral); plt.loglog(); plt.axline((1,1),(100,100),color='grey',ls='--'); plt.grid(); plt.xlabel('true ages', fontsize=9); plt.ylabel('ages with Normal distributed error rates', fontsize=9); plt.xticks(fontsize=10); plt.yticks(fontsize=10)\n",
    "#plt.plot([1,20],[10,35],color='silver',linewidth=1.5); plt.plot([20,1000],[35,1035],color='silver',linewidth=1.5)\n",
    "# mask1 = (simal>0) & (simal<21)\n",
    "# mask2 = (simal>20) & (simal<1001)\n",
    "# mask3 = (simal>1000) & (simal<20001)\n",
    "# mask4 = simal>20000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.repeat(np.arange(5000)+1,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# trueg1 = -0.01\n",
    "trueg2 = gamma[-10]\n",
    "# newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==trueg1)),0:3].append(df1.iloc[np.ravel(np.where(dat[:,1]==trueg2)),0:3])\n",
    "newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==trueg2)),:]\n",
    "newdat = newdf1.to_numpy()\n",
    "\n",
    "print(gamma2[np.argmax([np.sum(get_lp_xl(g1, newdat[:,5], cutoff=2)) for g1 in gamma2])])\n",
    "print(gamma2[np.argmax([np.sum(get_lp_alxl_nocheck(g1, newdat[:,5], newdat[:,2], cutoff=2)) for g1 in gamma2])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[np.sum(get_lp_xl(g1, newdat[:,5], cutoff=2)) for g1 in gamma2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "llfreq, llage = np.zeros(len(gamma2)), np.zeros(len(gamma2))\n",
    "for ig, g in enumerate(gamma2):\n",
    "    llfreq[ig] = get_lp_xl(g, newdat[:,5], cutoff=2)\n",
    "    llfreq[ig] = get_lp_alxl(g, newdat[:,5], newdat[:,2], cutoff=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## getting parametric bootstrap, basically compute MLE s for each data point and then find the 95% CI/2 std to get info measure\n",
    "mlegfreq = np.zeros((len(gamma),len(newdat)))\n",
    "mlegage = np.zeros((len(gamma),len(newdat)))\n",
    "for it, trueg2 in enumerate(gamma): \n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==trueg2)),:]\n",
    "    newdat = newdf1.to_numpy()\n",
    "    for i in range(len(newdat)):\n",
    "        mlegfreq[it,i] = gamma2[np.argmax([np.log(p_xa_s[g1][newdat[i,5]]) for g1 in gamma2])]\n",
    "        # mlegfreq[it,i] = gamma2[np.argmax([sp.stats.poisson.logpmf(newdat[i,5],mu=p_xa_s[g1][newdat[i,5]]) for g1 in gamma2])]\n",
    "        mlegage[it,i] = gamma2[np.argmax([get_lp_alxl_nocheck(g1, newdat[i,5], newdat[i,2], cutoff=2) for g1 in gamma2])]\n",
    "        # mlegage[it,i] = gamma2[np.argmax([sp.stats.poisson.logpmf(newdat[i,5],mu=np.exp(get_lp_alxl_nocheck(g1, newdat[i,5], newdat[i,2], cutoff=2))) for g1 in gamma2])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sum(mlegfreq,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.scatter(newdat[:,5],mleg,alpha=0.4); plt.xlabel('# of derived alleles'); plt.ylabel('MLE γ'); plt.axhline(trueg2, ls='--', color='red')\n",
    "plt.boxplot(np.array([mlegfreq[5,],mlegage[5,]]).T,labels=['freq only', 'freq & age']); plt.axhline(gamma[5],color='red',ls='--'); "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(gamma,mlegfreq.std(axis=1/mlegage.std(axis=1),color='k',alpha=0.7); plt.axhline(1,color='grey',ls='--'); plt.grid(); \n",
    "plt.xlabel('γ'); plt.ylabel('SD of freq/SD of freq & age')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(get_lp_xl(g, newdat[:,5], cutoff=10), get_lp_xl2(g, newdat[:,5], cutoff=10), alpha=0.7, color='k', s=2.5); \n",
    "plt.axline((-5.75,1.75),slope=1.,color='grey',ls='--',linewidth=0.5);\n",
    "plt.xlabel('p(X|γ) using moments framework'); plt.ylabel('using PRF approx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sin_onlyfreq = np.empty(len(gamma2))\n",
    "sin_onlyage = np.empty(len(gamma2))\n",
    "# num_sims = 3\n",
    "# num_samps = [35,350,3500]\n",
    "# info_onlyfreq, info_onlyage = np.zeros((len(num_samps),num_sims)), np.zeros((len(num_samps),num_sims))\n",
    "# nboot = 10\n",
    "# for i in range(nboot):\n",
    "#     newdat = newdat[np.random.choice(len(newdat),1000,replace=True)]\n",
    "    # for ig, g in enumerate(gamma):\n",
    "        # sum log prob for each locus\n",
    "        # sin_onlyfreq[ig] = np.sum(get_lp_xl(g, newdat[:,5], cutoff=2))\n",
    "        # sin_onlyage[ig] = np.sum(get_lp_alxl(g, newdat[:,5], newdat[:,2], cutoff=2))\n",
    "        # mle = get_boot_ci(newdat,nboot=2)\n",
    "    # print(gamma[np.argmax(sin_onlyfreq)], gamma[np.argmax(sin_onlyage)])\n",
    "\n",
    "for ig, g in enumerate(gamma2):\n",
    "    sin_onlyfreq[ig] = np.sum(get_lp_xl(g, newdat[:,5], cutoff=2))\n",
    "    sin_onlyage[ig] = np.sum(get_lp_alxl(g, newdat[:,5], newdat[:,2], cutoff=2))\n",
    "\n",
    "# mle = get_boot_ci(newdat,nboot=20)\n",
    "# mle.mean(axis=0), mle.std(axis=0)\n",
    "\n",
    "# for ins, ns in enumerate(num_samps):\n",
    "#     info_onlyfreq[ins,:], info_onlyage[ins,:] = get_info_content(newdat, num_samps=ns, num_sims=num_sims, cutoff=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get_mean_sd_werr(newdat, nreps=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## compute gain in information for the same number of sites but over a range of gamma\n",
    "gain_info = np.empty((3,num_sims))\n",
    "info_onlyfreq, info_onlyage = np.zeros_like(gain_info), np.zeros_like(gain_info)\n",
    "# for ig, g in enumerate(gamma):\n",
    "#     newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g)),:]\n",
    "#     newdat = newdf1.to_numpy()\n",
    "\n",
    "#     info_onlyfreq[2,:], info_onlyage[2,:] = get_info_content(newdat, num_samps=5000, num_sims=num_sims, cutoff=2)\n",
    "#     gain_info[ig,:] = np.divide(info_onlyage[2,:],info_onlyfreq[2,:])\n",
    "\n",
    "## but need to resimulate a bunch of new sites for each gamma (do it only for 1, 10, 100 first)\n",
    "for ig, g in enumerate([-1., -10., -100.]):\n",
    "    for n in range(num_sims):\n",
    "        with open('simfiles/ParameterFilesConstant.txt',\"r\") as file:\n",
    "            data = file.readlines()\n",
    "\n",
    "        data[0] = 'MutationRate: {:f}\\n'.format(250)\n",
    "        data[2] = 'DFEPointSelectionCoefficient: {:.8f}\\n'.format(-0.25*g/10000)\n",
    "        data[7] = 'FilePrefix: outfiles/ConstantSize{}\\n'.format(-g)\n",
    "\n",
    "        with open('simfiles/ParameterFilesConstant.txt', 'w') as file:\n",
    "            file.writelines(data)\n",
    "        \n",
    "        os.system(\"GSL_RNG_SEED={} GSL_RNG_TYPE=mrg ../../PReFerSim/PReFerSim simfiles/ParameterFilesConstant.txt 3 > /dev/null 2>&1 \".format(rng.integers(100496)))\n",
    "\n",
    "        dft = pd.read_csv('outfiles/ConstantSize{}.3.full_out.txt'.format(-g),sep='\\t',header=None,names=['','Xl','s','al','id'])\n",
    "        dft['empty'] = ''\n",
    "        dft['sXl'] = (dft['Xl']*2000).astype('int')\n",
    "        dft['al'] = 80000+1 - dft['al']\n",
    "        dft['al'] = dft['al'].astype('int')\n",
    "        dft = dft.iloc[:,1:]\n",
    "        if(len(dft)>1000):\n",
    "            datt = dft.sample(n=1000).to_numpy()\n",
    "        else: \n",
    "            datt = dft.to_numpy()\n",
    "\n",
    "        info_onlyfreq[ig,n], info_onlyage[ig,n] = get_info_content(datt, num_samps=len(datt), num_sims=1, cutoff=2)\n",
    "    \n",
    "    gain_info[ig,:] = np.divide(info_onlyage[ig,:],info_onlyfreq[ig,:])\n",
    "    # print(gain_info[ig,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gain_info[1,:] = [1.412, 1.498, 1.583, 1.728, 1.718, 1.688, 1.489, 1.541, 1.494, 1.526, 1.440, 1.337, 1.306, 1.564, 1.461, 1.488]\n",
    "# gain_info[2,:] = [1.546, 1.551, 1.545, 1.556, 1.542, 1.547, 1.537, 1.538, 1.532, 1.544, 1.546, 1.543, 1.539, 1.551, 1.553, 1.554]\n",
    "# gain_info[0,:] = [np.nan, 1.100, 1.132, 1.092, 1.088, 1.098, 1.104, 1.090, 1.130, 1.099, 1.122, 1.093, 1.094, 1.105, 1.105, 1.118]\n",
    "# (array([1.962, 2.510, 2.103, 1.538, 1.352, 1.590]),\n",
    "#  array([0.267, 0.974, 0.428, 0.224, 0.032, 0.011]))\n",
    "# array([[1.814, 1.361, 1.377, 1.944, 1.836, 1.736, 0.520, 1.882, 1.884,\n",
    "#         1.469, 1.042, 0.974, 1.816, 1.457, 2.198, 2.188],\n",
    "#        [0.074, 0.082, 0.077, 0.176, 0.080, 0.068, 0.077, 0.087, 0.076,\n",
    "#         0.075, 0.070, 0.072, 0.078, 0.073, 0.070, 0.164],\n",
    "#        [1.502, 1.510, 1.494, 1.521, 1.512, 1.539, 1.526, 1.513, 1.521,\n",
    "#         1.517, 1.512, 1.532, 1.483, 1.505, 1.522, 1.516]])\n",
    "# gain_info.mean(axis=1), gain_info.std(axis=1)\n",
    "# mean and sd of -0.1, -1., -10., -100 under 2 different regimes (no error, low GEVA error)\n",
    "gain_info_mean = np.array([[1.048, 0.988, 1.005, 1.019, 1.011, 1.32, 1.484, 1.435, 1.494]])\n",
    "gain_info_sd = np.array([[0.121, 0.06, 0.027, 0.038, 0.017, 0.42, 0.059, 0.135, 0.149]])\n",
    "# gain_info_mean = np.array([[1.048, 1.005, 1.484, 1.494],[0.821,0.838,1.037,1.307]])\n",
    "# gain_info_sd = np.array([[0.121, 0.027, 0.059, 0.149],[0.01,0.037,0.222,0.234]])\n",
    "# no point in computing the gain in information under high error since MLE is not even the same...\n",
    "# gamma[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(info_onlyage, info_onlyfreq)\n",
    "print(gain_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.divide(infoage, infofreq)\n",
    "np.abs([get_bfq(ll_adam, gamma2)[0], get_bfq(sin_onlyfreq, gamma2)[0], get_bfq(sin_onlyage, gamma2)[0]])\n",
    "# -get_bfq(ll_adam-np.max(ll_adam), gamma2)[1]*0.5/get_bfq(ll_adam-np.max(ll_adam), gamma2)[0], -get_bfq(sin_onlyfreq-np.max(sin_onlyfreq), gamma2)[1]*0.5/get_bfq(sin_onlyfreq-np.max(sin_onlyfreq), gamma2)[0], -get_bfq(sin_onlyage-np.max(sin_onlyage), gamma2)[1]*0.5/get_bfq(sin_onlyage-np.max(sin_onlyage), gamma2)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# seaborn.stripplot(data=pd.DataFrame(gain_info.T,columns=gamma),color='salmon',alpha=0.8,size=7); \n",
    "# plt.xlabel('|γ|'); plt.ylabel('gain in information'); plt.title('20 reps of 5000 sites'); plt.grid();\n",
    "plt.figure(dpi=130)\n",
    "plt.scatter(np.array([0.099,0.299,0.99,1.77,3.29,7.29,9.9,29,98]),gain_info_mean[0,:],color='slategrey',alpha=0.9,); \n",
    "# plt.scatter(np.array([0.11,1.01,10.1,102]),gain_info_mean[1,:],color='lightsteeldeepskydeepskydeepskyblue',alpha=0.9,label='GEVA error'); plt.grid()\n",
    "plt.errorbar(np.array([0.099,0.299,0.99,1.77,3.29,7.29,9.9,29,98]),gain_info_mean[0,:],yerr=gain_info_sd[0,:],color='slategrey',alpha=0.9,linewidth=2,ls='none'); plt.xticks(fontsize=10); plt.yticks(fontsize=10)\n",
    "# plt.errorbar(np.array([0.11,1.01,10.1,102]),gain_info_mean[1,:],yerr=gain_info_sd[1,:],color='lightsteelblue',alpha=0.9,linewidth=2,ls='none'); \n",
    "# plt.scatter(-gamma[2:],gain_info[0],alpha=0.8,color='k'); plt.semilogx(); plt.xlabel('|γ|'); plt.title('20 reps of 1000 sites')\n",
    "# plt.errorbar(-gamma[2:],gain_info[0],yerr=2*gain_info[1],color='k',alpha=0.8); plt.grid(); plt.ylabel('gain in info'); \n",
    "plt.axhline(1.,color='grey',ls='--',linewidth=2,alpha=0.7); plt.ylabel('ratio of curvature +/- 1 SD', fontsize=10); plt.xlabel('|γ|', fontsize=16); plt.semilogx(); plt.grid(); #plt.legend(loc=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Working with Adam's log-likelihoods\n",
    "(and data, since we only need a subset of alleles...)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ll_adam = np.array([-12779.905577243711,-12779.67560657378,-12779.345559393892,-12778.872363586619,-12778.19492458077,-12777.22714620313,-12775.848879337178,-12773.89494812682,-12771.143604153498,-12767.30870429352,-12762.046666304424,-12755.004172803323,-12745.96462111521,-12735.2182496041,-12724.415368038992,-12718.41220639416,-12729.002025638603,-12781.678920760727,-12925.363284151737,-13238.84902857637]) # using ~ 500 trajectories\n",
    "ll_adam=np.array([-29565.76313316775,-29565.621718394377,-29565.418924835354,-29565.128508755162,-29564.713434007765,-29564.121904008814,-29563.282471330967,-29562.098695611345,-29560.44496421317,-29558.16773914124,-29555.102378376516,-29551.12840744588,-29546.313073918434,-29541.248815564642,-29537.801653373364,-29540.693962031066,-29560.662504959695,-29620.153166439388,-29761.530313756353,-30052.589833320435]) # using ~3000 trajectories \n",
    "# plt.plot(-gamma2,ll_adam-np.max(ll_adam),'-o',alpha=0.5,label='full traj',color='k'); plt.grid(); plt.plot(-gamma2, sin_onlyfreq-np.max(sin_onlyfreq),'-o',alpha=0.5,label=\"only freq\",color='deepskyblue'); plt.plot(-gamma2,sin_onlyage-np.max(sin_onlyage),'-o',alpha=0.5,label=\"freq & age\",color='coral'); plt.ylim((-200,10)); plt.semilogx()\n",
    "plt.plot(-gamma2,ll_adam-np.max(ll_adam),'-o',alpha=0.5,label='full traj',color='k'); plt.grid(); plt.plot(-gamma2, np.sum(mlegfreq,axis=1)-np.max(np.sum(mlegfreq,axis=1)),'-o',alpha=0.5,label=\"only freq\",color='deepskyblue'); plt.plot(-gamma2,np.sum(mlegage,axis=1)-np.max(np.sum(mlegage,axis=1)),'-o',alpha=0.5,label=\"freq & age\",color='coral'); plt.ylim((-200,10)); plt.semilogx()\n",
    "#plt.axvline(-gamma2[np.argmax(sin_onlyage)],color='grey',ls='--'); \n",
    "plt.axvline(100.,color='red',); plt.xlabel('|γ|'); plt.ylabel('log-lik'); plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(dft.loc[dft['id'].isin(alls['IDs'])]['sXl']/20,dft.loc[dft['id'].isin(alls['IDs'])]['al'],color='grey',alpha=0.7); plt.xlabel('allele freq (%)'); plt.ylabel('allele age'); plt.semilogy()\n",
    "# datt = dft.loc[dft['id'].isin(alls['IDs'])].to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(-np.repeat(gamma,num_sims),gain_info,s=10,color='salmon',alpha=0.6); plt.semilogx()\n",
    "plt.xlabel('|γ|'); plt.ylabel('gain in information'); plt.title('20 reps of 5000 sites'); plt.grid();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_boot_ci(newdat, nsamps=1000, nboot=20, cutoff=2):\n",
    "    mle = np.zeros((nboot,2))\n",
    "    sin_onlyfreq, sin_onlyage = np.empty(len(gamma2)), np.empty(len(gamma2))\n",
    "    for i in range(nboot):\n",
    "        newnewdat = newdat[np.random.choice(len(newdat),nsamps,replace=True)]\n",
    "        for ig, g in enumerate(gamma2):\n",
    "            sin_onlyfreq[ig] = np.sum(get_lp_xl(g, newnewdat[:,5], cutoff=cutoff))\n",
    "            sin_onlyage[ig] = np.sum(get_lp_alxl(g, newnewdat[:,5], newnewdat[:,2], cutoff=cutoff))\n",
    "        \n",
    "        mle[i,0] = gamma2[np.argmax(sin_onlyfreq)]\n",
    "        mle[i,1] = gamma2[np.argmax(sin_onlyage)]\n",
    "\n",
    "    return mle            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_mean_sd_werr(newdat, errvar, nreps=20, cutoff=2):\n",
    "    ests = np.zeros(nreps)\n",
    "    sin_onlyage = np.empty(len(gamma2))\n",
    "    for i in range(nreps):\n",
    "        newage = get_age_err(newdat[:,2],rng,errvar)\n",
    "        sin_onlyage = [np.sum(get_lp_alxl(g, newdat[:,5], newage, cutoff=cutoff)) for g in gamma2]\n",
    "        \n",
    "        ests[i] = gamma2[np.argmax(sin_onlyage)]\n",
    "    \n",
    "    return ests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seaborn.stripplot(data=pd.DataFrame(np.divide(info_onlyage, info_onlyfreq).T,columns=num_samps),color='salmon',alpha=0.8); \n",
    "plt.xlabel('# of sites'); plt.ylabel('gain in information'); plt.title('γ = {:.1f}'.format(trueg2)); plt.grid(); "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seaborn.stripplot(data=pd.DataFrame(info_onlyfreq.T,columns=num_samps), color='deepskyblue', alpha=0.7, label='only freq')\n",
    "seaborn.stripplot(data=pd.DataFrame(info_onlyage.T,columns=num_samps), color='coral', alpha=0.7, label='freq & age')\n",
    "plt.xlabel('# of sites'); plt.ylabel('information measure'); plt.grid(); plt.title('γ = {:.1f}'.format(trueg2)); \n",
    "plt.legend(handles=[mpatches.Patch(color='deepskyblue', label='only freq, total info: {:.2f}'.format(np.sum(info_onlyfreq))), mpatches.Patch(color='coral', label='freq & age, total info: {:.2f}'.format(np.sum(info_onlyage)))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_info_content(newdat, num_samps=800, num_sims=16, cutoff=2):\n",
    "    ci_freq, ci_age = np.zeros(num_sims), np.zeros(num_sims)\n",
    "    for n in range(num_sims):\n",
    "        newnewdat = newdat[rng.choice(newdat.shape[0], num_samps, replace=False),:]\n",
    "        sin_onlyfreq = [np.sum(get_lp_xl(g1, newnewdat[:,5], cutoff=cutoff)) for g1 in gamma2]\n",
    "        sin_onlyage = [np.sum(get_lp_alxl(g1, newnewdat[:,5], newnewdat[:,2], cutoff=cutoff)) for g1 in gamma2]\n",
    "\n",
    "        ci_freq[n] = np.abs(get_bfq(sin_onlyfreq-np.max(sin_onlyfreq), gamma2)[0])\n",
    "        ci_age[n] = np.abs(get_bfq(sin_onlyage-np.max(sin_onlyage), gamma2)[0])\n",
    "\n",
    "    return [ci_freq, ci_age]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_info_content_werr(newdat, errvar, num_samps=800, reps=16, cutoff=2):\n",
    "    ci_freq, ci_age = np.zeros(reps), np.zeros(reps)\n",
    "    for n in range(reps):\n",
    "        newnewdat = newdat[rng.choice(newdat.shape[0], num_samps, replace=False),:]\n",
    "        sin_onlyfreq = [np.sum(get_lp_xl(g1, newnewdat[:,5], cutoff=cutoff)) for g1 in gamma2]\n",
    "        ci_freq[n] = np.abs(get_bfq(sin_onlyfreq-np.max(sin_onlyfreq), gamma2)[0])\n",
    "        for r in range(reps):\n",
    "            newage = get_age_err(newnewdat[:,2],rng,errvar)\n",
    "            sin_onlyage = [np.sum(get_lp_alxl(g1, newnewdat[:,5], newage, cutoff=cutoff)) for g1 in gamma2]\n",
    "            # print(gamma2[np.argmax(sin_onlyage)])\n",
    "            ci_age[n] += np.abs(get_bfq(sin_onlyage-np.max(sin_onlyage), gamma2)[0])\n",
    "\n",
    "    return [ci_freq, ci_age/reps]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_conf_int(loglik, thresh=2):\n",
    "    mle = gamma[np.argmax(loglik)]\n",
    "\n",
    "    if mle==np.min(gamma):\n",
    "        lower_thresh = gamma[1]  \n",
    "        return [(np.max(loglik)-thresh-loglik[np.argmax(loglik)+1])/(np.max(loglik) - loglik[np.argmax(loglik)+1])/(mle - lower_thresh)+lower_thresh, mle]\n",
    "    elif mle==np.max(gamma):\n",
    "        upper_thresh = gamma[-2] \n",
    "        return [mle, -thresh/(loglik[np.argmax(loglik)-1] - np.max(loglik))/(upper_thresh - mle)+mle]\n",
    "    else:\n",
    "        lower_thresh = gamma[np.argmax(loglik)+1] \n",
    "        upper_thresh = gamma[np.argmax(loglik)-1] \n",
    "        return [(np.max(loglik)-thresh-loglik[np.argmax(loglik)+1])*(mle - lower_thresh)/(np.max(loglik) - loglik[np.argmax(loglik)+1])+lower_thresh, -thresh*(upper_thresh - mle)/(loglik[np.argmax(loglik)-1] - np.max(loglik))+mle,]\n",
    "        # return [(np.max(loglik)-thresh-loglik[np.argmax(loglik)+1])/(np.max(loglik) - loglik[np.argmax(loglik)+1])/(mle - lower_thresh)+lower_thresh, -thresh/(loglik[np.argmax(loglik)-1] - np.max(loglik))/(upper_thresh - mle)+mle]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## run the same search on a denser grid\n",
    "win_sin_onlyfreq = np.empty(interp_gamma.shape[1])\n",
    "for ig, g in enumerate(interp_gamma[np.argmax(sin_onlyfreq),]):\n",
    "    win_sin_onlyfreq[ig] = np.sum(get_lp_xl(g, newdat[:,5], cutoff=10))\n",
    "\n",
    "win_sin_onlyage = np.empty(interp_gamma.shape[1])\n",
    "for ig, g in enumerate(interp_gamma[np.argmax(sin_onlyage),]):\n",
    "    win_sin_onlyage[ig] = np.sum(get_lp_alxl(g, newdat[:,5], newdat[:,2], cutoff=10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "densegrid = -np.logspace(0,2,base=10,num=100)\n",
    "lxlbfq = get_bfq(sin_onlyfreq-np.max(sin_onlyfreq), gamma) @ np.vstack((densegrid**2, densegrid,np.repeat(1.0,100)))\n",
    "# lxlbfq = get_bfq_win(sin_onlyfreq-np.max(sin_onlyfreq), gamma) @ np.vstack((np.repeat(1.0,len(gamma)), gamma, gamma**2,))\n",
    "# lxlalbfq = np.polynomial.polynomial.Polynomial.fit(gamma[7:10],(sin_onlyage-np.max(sin_onlyage))[7:10],deg=2).coef @ np.vstack((np.repeat(1.0,4), gamma[(np.argmax(sin_onlyage)-1):(np.argmax(sin_onlyage)+3)], gamma[(np.argmax(sin_onlyage)-1):(np.argmax(sin_onlyage)+3)]**2,))\n",
    "lxlalbfq = get_bfq(sin_onlyage-np.max(sin_onlyage), gamma) @ np.vstack((densegrid**2, densegrid,np.repeat(1.0,100)))\n",
    "# lxlalbfq = get_bfq_win(sin_onlyage-np.max(sin_onlyage), gamma) @ np.vstack((np.repeat(1.0,len(gamma)), gamma, gamma**2,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(-gamma2, sin_onlyfreq-np.max(sin_onlyfreq),'grey', label='freq'); plt.ylim((-10,1)); plt.xlabel('est gamma')\n",
    "plt.axvline(-gamma2[np.argmax(sin_onlyfreq)], color='grey', linestyle='--'); \n",
    "# plt.plot(-densegrid, lxlbfq-np.max(lxlbfq), color='deepskyblue', alpha=0.6,label='best-fit quadratic Xl');#interp_gamma\n",
    "plt.axvline(1., color='red', ls='--'); plt.semilogx()\n",
    "plt.plot(-gamma2, sin_onlyage-np.max(sin_onlyage),'k', label='freq & age'); plt.ylim((-10,1)); \n",
    "# plt.plot(-densegrid, lxlalbfq-np.max(lxlalbfq), color='coral', alpha=0.6,label='best-fit quadratic Xl, al');#interp_gamma[np.argmax(sin_onlyage)]\n",
    "plt.axvline(-gamma2[np.argmax(sin_onlyage)], color='k', linestyle='--'); plt.ylabel('log-lik units'); plt.legend(); plt.grid()\n",
    "plt.axhline(-2.,color='red',alpha=0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_bfq(loglik, gamma):\n",
    "    ## does not work for some reason—wasted multiple hours on it...\n",
    "    # return np.polynomial.polynomial.Polynomial.fit(-gamma[(ig-3):(ig+3)], loglik[(ig-3):(ig+3)], deg=2)\n",
    "    igamma = gamma[(np.argmax(loglik)-1):(np.argmax(loglik)+2)] if np.argmax(loglik)>0 else gamma[0:3]\n",
    "    loglik = loglik[(np.argmax(loglik)-1):(np.argmax(loglik)+2)] if np.argmax(loglik)>0 else loglik[0:3]\n",
    "\n",
    "    rhs = np.array([np.dot(igamma**2,loglik), np.dot(igamma,loglik), np.sum(loglik)])\n",
    "    lhs = np.array([[np.sum(igamma**4), np.sum(igamma**3), np.sum(igamma**2)],\n",
    "    [np.sum(igamma**3), np.sum(igamma**2), np.sum(igamma)],\n",
    "    [np.sum(igamma**2), np.sum(igamma), len(igamma)]])\n",
    "\n",
    "    return np.linalg.solve(lhs, rhs) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds_sin_onlyfreq = np.zeros(len(s))\n",
    "ci_sin_onlyfreq = np.zeros((len(s),2))\n",
    "\n",
    "for ig, g in enumerate(s):\n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g)),:]\n",
    "    newdat = newdf1.to_numpy()\n",
    "    # sin_onlyfreq = [np.sum(get_lp_xl(g1, newdat[:,5], cutoff=5)) for g1 in gamma]\n",
    "    # preds_sin_onlyfreq[ig] = gamma[np.argmax(sin_onlyfreq)]\n",
    "    # ci_sin_onlyfreq[ig] = 1/np.abs(get_bfq(sin_onlyfreq - np.argmax(sin_onlyfreq), gamma)[0]) # get_conf_int(sin_onlyfreq)\n",
    "    info_onlyfreq[ig,:], info_onlyage[ig,:] = get_info_content(newdat, num_samps=1000, num_sims=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# preds_sin_agefreq = np.zeros(len(gamma))\n",
    "# for ig, g in enumerate(gamma):\n",
    "#     newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g)),:]\n",
    "#     newdat = newdf1.to_numpy()\n",
    "#     sin_agefreq = [np.sum(get_lp_alxl(g1, newdat[:,5], newdat[:,2]) + get_lp_xl(g1, newdat[:,5])) for g1 in gamma]\n",
    "#     # sin_agefreq = [np.sum(get_lp_alxl(g1, newdat[:,0], newdat[:,2], n=100)) for g1 in gamma]\n",
    "#     preds_sin_agefreq[ig] = gamma[np.nanargmax(sin_agefreq)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds_sin_onlyage = np.zeros(len(gamma))\n",
    "ci_sin_onlyage = np.zeros((len(gamma),2))\n",
    "for ig, g in enumerate(gamma):\n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g)),:]\n",
    "    newdat = newdf1.to_numpy()\n",
    "    # newdat = newdf1.loc[np.logical_and(newdf1['al']>1, newdf1['al']<60),:].to_numpy()\n",
    "    sin_onlyage = [np.sum(get_lp_alxl(g1, newdat[:,5], newdat[:,2], cutoff=5)) for g1 in gamma]\n",
    "    preds_sin_onlyage[ig] = gamma[np.argmax(sin_onlyage)]\n",
    "    ci_sin_onlyage[ig] = 1/np.abs(get_bfq(sin_onlyage-np.argmax(sin_onlyage), gamma)[0]) # get_conf_int(sin_onlyage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## get bootstrap std estimates but mle only calculated once\n",
    "preds_sin_onlyfreq, preds_sin_onlyage = np.zeros(len(gamma)), np.zeros(len(gamma))\n",
    "ci_sin_onlyfreq, ci_sin_onlyage = np.zeros((len(gamma),)), np.zeros((len(gamma),))\n",
    "\n",
    "for ig, g in enumerate(gamma):\n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g)),:]\n",
    "    newdat = newdf1.to_numpy()\n",
    "    sin_onlyfreq = [np.sum(get_lp_xl(g1, newdat[:,5], cutoff=2)) for g1 in gamma2]\n",
    "    sin_onlyage = [np.sum(get_lp_alxl(g1, newdat[:,5], newdat[:,2], cutoff=2)) for g1 in gamma2]\n",
    "    preds_sin_onlyfreq[ig] = gamma2[np.argmax(sin_onlyfreq)]\n",
    "    preds_sin_onlyage[ig] = gamma2[np.argmax(sin_onlyage)]\n",
    "    mle = get_boot_ci(newdat, nsamps=len(newdat), nboot=5)\n",
    "    ci_sin_onlyfreq[ig,], ci_sin_onlyage[ig,] = mle.std(axis=0) #np.percentile(mle[:,0],[97.5,2.5]), np.percentile(mle[:,1],[97.5,2.5]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## get age estimates but with error introduced into the mix \n",
    "preds_sin_onlyfreq, preds_sin_onlyage = np.zeros(len(gamma)), np.zeros(len(gamma))\n",
    "ci_sin_onlyfreq, ci_sin_onlyage = np.zeros((len(gamma),)), np.zeros((len(gamma),))\n",
    "\n",
    "for ig, g in enumerate(gamma):\n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g)),:]\n",
    "    newdat = newdf1.to_numpy()\n",
    "    sin_onlyfreq = [np.sum(get_lp_xl(g1, newdat[:,5], cutoff=2)) for g1 in gamma2]\n",
    "    # sin_onlyage = [np.sum(get_lp_alxl(g1, newdat[:,5], newdat[:,2], cutoff=2)) for g1 in gamma2]\n",
    "    preds_sin_onlyfreq[ig] = gamma2[np.argmax(sin_onlyfreq)]\n",
    "    ests_age = get_mean_sd_werr(newdat, errvar = np.repeat(0,4), nreps=5)\n",
    "    # print(ests_age)\n",
    "    preds_sin_onlyage[ig] = np.mean(ests_age)\n",
    "    ci_sin_onlyage[ig] = np.std(ests_age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==gamma[-10])),:]\n",
    "# newdat = newdf1.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## predictions with data from neutral case only \n",
    "dfneut = pd.read_csv(\"outfiles/ConstantSize0.0.1.full_out.txt\",sep='\\t',header=None,)\n",
    "dfneut.columns = ['','Xl','s','al','id']\n",
    "dfneut['empty'] = ''\n",
    "dfneut['sXl'] = (dfneut['Xl']*2000).astype('int')\n",
    "dfneut['al'] = 80000+1 - dfneut['al']\n",
    "dfneut['al'] = dfneut['al'].astype('int')\n",
    "dfneut = dfneut.iloc[:,1:]\n",
    "datneut = dfneut.to_numpy()\n",
    "dfneut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "shufidx = np.arange(len(datneut))\n",
    "rng.shuffle(shufidx)\n",
    "parestfreq0 = np.zeros(11)\n",
    "parestage0 = np.zeros(11)\n",
    "for i in range(11):    \n",
    "    parestfreq0[i] = sp.optimize.minimize_scalar(get_ll_freq, args=(datneut[shufidx[(i*962):((i+1)*962)],5]), options={'xtol': .1,}).x\n",
    "    parestage0[i] = sp.optimize.minimize_scalar(get_ll_freqage, args=(datneut[shufidx[(i*962):((i+1)*962)],5], datneut[shufidx[(i*962):((i+1)*962)],2]), options={'xtol': .1}).x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parestfreq0 = np.array([-0.239, 0.230, -0.841, 0.284, 0.088, 0.249, 0.083, -0.115, -0.004, 0.031, -0.003])\n",
    "parestage0 = np.array([0.027, 0.538, -0.618, 0.680, 0.420, 0.547, 0.420, 0.187, 0.317, 0.382, 0.277])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dfhund = pd.read_csv(\"outfiles/ConstantSize100.0.1.full_out.txt\",sep='\\t',header=None,).sample(n=2000)\n",
    "# dfhund.columns = ['','Xl','s','al','id']\n",
    "# dfhund['empty'] = ''\n",
    "# dfhund['sXl'] = (dfhund['Xl']*2000).astype('int')\n",
    "# dfhund['al'] = 100000+1 - dfhund['al']\n",
    "# dfhund['al'] = dfhund['al'].astype('int')\n",
    "# dfhund = dfhund.iloc[:,1:]\n",
    "# dathund = dfhund.to_numpy()\n",
    "# dfhund"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.hist(dfhund['al'],alpha=0.8); plt.hist(dfneut['al'],alpha=0.4); plt.semilogx()\n",
    "plt.plot(p_xa_s[gamma2[-5]],'o'); plt.plot(p_xa_s[0.],'o',alpha=0.8); plt.loglog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sin_onlyfreq = [np.sum(get_lp_xl(g1, datneut[:,5], cutoff=2)) for g1 in gamma2]\n",
    "# sin_onlyage = [np.sum(get_lp_alxl(g1, datneut[:,5], datneut[:,2], cutoff=2)) for g1 in gamma2]\n",
    "# print(gamma2[np.argmax(sin_onlyfreq)], gamma2[np.argmax(sin_onlyage)])\n",
    "mle = get_boot_ci(datneut, nsamps=len(datneut), nboot=100)\n",
    "# mle.std(axis=0)\n",
    "\n",
    "# plt.scatter(np.repeat(0.001,len(mle)),mle[:,0],alpha=0.5,color='deepskyblue',label='only freq'); plt.ylabel('estimated γ')\n",
    "# plt.scatter(np.repeat(-.001,len(mle)),mle[:,1],alpha=0.5,color='coral',label='freq & age'); plt.xlabel('true γ'); #plt.semilogy()\n",
    "# plt.legend(); plt.grid()\n",
    "# np.corrcoef(mle[:,0],mle[:,1])\n",
    "# mle.mean(axis=0), mle.std(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## get bootstrap std estimates but mle only calculated once\n",
    "preds_sin_onlyfreq, preds_sin_onlyage = np.zeros(len(s)), np.zeros(len(s))\n",
    "ci_sin_onlyfreq, ci_sin_onlyage = np.zeros((len(s),)), np.zeros((len(s),))\n",
    "\n",
    "for ig, g in enumerate(s):\n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g)),:]\n",
    "    newdat = newdf1.to_numpy()\n",
    "    sin_onlyfreq = [np.sum(get_lp_xl(g1, newdat[:,5], cutoff=2)) for g1 in gamma2]\n",
    "    sin_onlyage = [np.sum(get_lp_alxl(g1, newdat[:,5], newdat[:,2], cutoff=2)) for g1 in gamma2]\n",
    "    preds_sin_onlyfreq[ig] = gamma2[np.argmax(sin_onlyfreq)]\n",
    "    preds_sin_onlyage[ig] = gamma2[np.argmax(sin_onlyage)]\n",
    "    mle = get_boot_ci(newdat, nsamps=len(newdat), nboot=50)\n",
    "    ci_sin_onlyfreq[ig,], ci_sin_onlyage[ig,] = mle.std(axis=0) #np.percentile(mle[:,0],[97.5,2.5]), np.percentile(mle[:,1],[97.5,2.5]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==s[4])),:]\n",
    "# newdat = newdf1.to_numpy()\n",
    "# sin_onlyfreq = [np.sum(get_lp_xl(g1, newdat[:,5], cutoff=2)) for g1 in gamma2]\n",
    "# sin_onlyage = [np.sum(get_lp_alxl(g1, newdat[:,5], newdat[:,2], cutoff=2)) for g1 in gamma2]\n",
    "# gamma2[np.argmax(sin_onlyfreq)], gamma2[np.argmax(sin_onlyage)]\n",
    "# get_boot_ci(newdat, nsamps=len(newdat), nboot=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## basically, do fitdadi inference for each selection coefficient\n",
    "## cannot do point selection coefficient inference\n",
    "import dadi\n",
    "df = pd.read_csv(\"PReFerSims/outfiles/ConstantSize2.0.1.full_out.txt\", sep=\"\\t\", header=None).sample(n=1000)\n",
    "fs = dadi.Spectrum(np.histogram(fdf.iloc[:, 1] * 2000, bins=2001)[0])\n",
    "def one_epoch_sel(params, ns, pts):\n",
    "    nu, T, gamma = params\n",
    "    xx = dadi.Numerics.default_grid(pts)\n",
    "    phi = dadi.PhiManip.phi_1D(xx, gamma=gamma)\n",
    "    phi = dadi.Integration.one_pop(phi, xx, T, nu, gamma=gamma)\n",
    "    fs = dadi.Spectrum.from_phi(phi, ns, (xx,))\n",
    "    return fs\n",
    "pts_l = [600, 800, 1000]\n",
    "spectra = Selection.spectra(\n",
    "    [1, 2],\n",
    "    np.array([2000]),\n",
    "    one_epoch_sel,\n",
    "    pts_l=pts_l,\n",
    "    int_bounds=[0.1, 100],\n",
    "    Npts=20,\n",
    "    echo=True,\n",
    ")\n",
    "sel_params = [0.1, 200.0]\n",
    "lower_bound = [1e-3, 1e-2]\n",
    "upper_bound = [1, 100.0]\n",
    "p0 = dadi.Misc.perturb_params(sel_params, lower_bound=lower_bound, upper_bound=upper_bound)\n",
    "popt = Selection.optimize_log(\n",
    "    p0,\n",
    "    fs,\n",
    "    spectra.integrate,\n",
    "    Selection.normal_dist,\n",
    "    300,\n",
    "    lower_bound=lower_bound,\n",
    "    upper_bound=upper_bound,\n",
    "    verbose=len(sel_params),\n",
    "    maxiter=30,\n",
    ")\n",
    "spectra.Integrate(popt[1], Selection.normal_dist, 300)\n",
    "spectra.integrate([1.,4.], Selection.normal_dist, 300)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(-s, -preds_sin_onlyfreq, color='deepskyblue', alpha=0.5, label='only freq, rel. error: {:.1f}'.format(np.sum(np.abs(s-preds_sin_onlyfreq)*100/-s)),)#s=truenumloci*50/1000)\n",
    "plt.errorbar(-s, -preds_sin_onlyfreq, yerr=1.96*ci_sin_onlyfreq[:], color='deepskyblue', alpha=0.5, ls='none')\n",
    "plt.scatter(-s, -preds_sin_onlyage, color='coral', alpha=0.5, label='freq & age, rel. error: {:.1f}'.format(np.sum(np.abs(s-preds_sin_onlyage)*100/-s)),)#s=truenumloci*50/1000)\n",
    "plt.errorbar(-s, -preds_sin_onlyage, yerr=1.96*ci_sin_onlyage[:], color='coral', alpha=0.5, ls='none')\n",
    "plt.xlabel('true -γ value'); plt.ylabel('MLE -γ value'); plt.legend(); plt.loglog()\n",
    "plt.axline((1,1),(100,100),color='grey',ls='--', linewidth=1.); plt.ylim((0.1,1000)); plt.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(-gamma, -preds_sin_onlyfreq, color='deepskyblue', alpha=0.5, label='only freq, RMSLE: {:.2f}'.format(np.sqrt(np.mean((np.log10(-gamma)-np.log10(-preds_sin_onlyfreq))**2))))#s=truenumloci*50/1000)\n",
    "# plt.scatter(-gamma, -preds_sin_onlyfreq, color='deepskyblue', alpha=0.5, label='only freq, r2: {:.2f}'.format(sp.stats.pearsonr(np.log(-gamma),np.log(-preds_sin_onlyfreq))[0]**2))\n",
    "plt.xticks(fontsize=10); plt.yticks(fontsize=10); \n",
    "# plt.vlines(-gamma, -ci_sin_onlyfreq[:,0], -ci_sin_onlyfreq[:,1], color='deepskyblue', alpha=0.5)\n",
    "plt.errorbar(-gamma, -preds_sin_onlyfreq, yerr=1.96*ci_sin_onlyfreq[:], color='deepskyblue', alpha=0.5, ls='none')\n",
    "plt.errorbar(-gamma, -preds_sin_onlyfreq, yerr=-ci_sin_onlyfreq.T, color='deepskyblue', alpha=0.5, ls='none')\n",
    "plt.scatter(-gamma, -preds_sin_onlyage, color='coral', alpha=0.5, label='freq & age, RMSLE: {:.2f}'.format(np.sqrt(np.mean((np.log10(-gamma)-np.log10(-preds_sin_onlyage))**2))))#s=truenumloci*50/1000)\n",
    "# plt.scatter(-gamma, -preds_sin_onlyage, color='coral', alpha=0.5, label='freq & age, r2: {:.2f}'.format(sp.stats.pearsonr(np.log(-gamma),np.log(-preds_sin_onlyage))[0]**2))\n",
    "# plt.vlines(-gamma, -ci_sin_onlyage[:,0], -ci_sin_onlyage[:,1], color='coral', alpha=0.5)\n",
    "plt.errorbar(-gamma, -preds_sin_onlyage, yerr=1.96*ci_sin_onlyage[:], color='coral', alpha=0.5, ls='none')\n",
    "plt.errorbar(-gamma, -preds_sin_onlyage, yerr=-ci_sin_onlyage.T, color='coral', alpha=0.5, ls='none'); plt.yscale('log')\n",
    "# plt.scatter(-gamma, -preds_sin_agefreq, color='darkgreen', alpha=0.5, label='age & freq, abs. error: {:.1f}'.format(np.sum(np.abs(gamma-preds_sin_agefreq))))\n",
    "plt.xlabel('true |γ| value', fontsize=10); plt.ylabel('MLE |γ| value', fontsize=10); plt.legend(loc='lower right', fontsize=10); plt.loglog()\n",
    "plt.axline((1,1),(100,100),color='grey',ls='--', linewidth=1.); plt.ylim((0.2,200)); plt.grid()\n",
    "# plt.xticks(fontsize=8)\n",
    "# plt.yticks(fontsize=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sp.stats.pearsonr(np.log(-gamma),np.log(-preds_sin_onlyfreq))[0]**2\n",
    "preds_sin_onlyage, preds_sin_onlyfreq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dft = pd.read_csv(\"../traindata/trip-2022-04-05.csv\")\n",
    "# dft['gamma'] = dft['gamma'].round(decimals=2)\n",
    "preds_sin_onlyfreq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## comparing empirical distribution from data of frequency values with likelihood from moments framework\n",
    "# basically take samples from binomial for each rep and then store the values in a vector that keeps getting updated...\n",
    "ir = np.empty((100,1500),dtype=int)\n",
    "for n in range(100): #nreps\n",
    "    ir[n,:] = rng.binomial(n=2000, p=df1[df1['s']==-10.]['Xl'])\n",
    "counts, bins, _ = plt.hist(np.ravel(ir),bins=2000,range=(0,2000),density=True); plt.semilogx(); plt.xlabel('# of allele copies')\n",
    "counts[cutoff:(2000-cutoff+1)] = counts[cutoff:(2000-cutoff+1)]/np.sum(counts[cutoff:(2000-cutoff+1)])\n",
    "counts[0:cutoff] = counts[-cutoff:] = np.repeat(0,cutoff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## numerical integration of likelihood to get analytical expression (from eq 2 in Bustamante et al 2001)\n",
    "def Fanal(gg, i, n):\n",
    "    with np.errstate(divide='ignore'):\n",
    "        return [(1-np.exp(-2*gg*(1-x)))*2/((1-np.exp(-2*gg))*x*(1-x)) * sp.stats.binom.pmf(i,n,x) for x in np.logspace(-8,-0.01,99)]\n",
    "\n",
    "analexp = [sp.integrate.trapezoid(Fanal(-11.625/2,i,2000),np.logspace(-8,-0.01,99)) for i in range(2000)]\n",
    "analexp[cutoff:(2000-cutoff+1)] = analexp[cutoff:(2000-cutoff+1)]/np.sum(analexp[cutoff:(2000-cutoff+1)])\n",
    "analexp[0:cutoff] = analexp[-cutoff:] = np.repeat(0,cutoff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.corrcoef([sp.integrate.trapezoid(Fanal(gamma[19],i,2000),np.linspace(1e-6,1-1e-6,200)) for i in range(20)], [sp.integrate.trapezoid(Fanal(gamma[0],i,2000),np.linspace(1e-6,1-1e-6,200)) for i in range(20)])\n",
    "# Fanal(gamma[19],10,2000), Fanal(gamma[0],10,2000) \n",
    "# np.linspace(1e-6,1-1e-6,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.scatter(p_xa_s[gamma[15]],p_xa_s[gamma[17]]); plt.loglog(); plt.axline((0.1,0.1),(0,0))\n",
    "# np.allclose(p_xa_s[gamma[19]],p_xa_s[gamma[16]])\n",
    "gamma2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(np.arange(2,100+1),p_xa_s[gamma2[15]][2:101],color='purple',label='moments, error={:.2f}'.format(np.sum(np.abs(p_xa_s[gamma2[15]][2:101]-analexp[2:101]))),alpha=0.5);\n",
    "# plt.scatter(np.arange(2,100+1),testp_xa_s[2:101],color='grey',label='moments2, error={:.2f}'.format(np.sum(np.abs(testp_xa_s[2:101]-analexp[2:101]))),alpha=0.5);\n",
    "# plt.scatter(np.arange(2,100+1),counts[2:101],color='green',label='PReFerSims, error={:.2f}'.format(np.sum(np.abs(counts[2:101]-analexp[2:101]))),alpha=0.5); \n",
    "plt.scatter(np.arange(2,100+1),analexp[2:101],color='lightpink',marker='+',label='analytical expression');  plt.grid(); plt.loglog()\n",
    "plt.ylabel('probability'); plt.title('γ = {}'.format(-10.)); plt.legend(); plt.xlabel('# of allele copies')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## plotting different SFS from moments on the same plot\n",
    "plt.scatter(np.arange(2,100+1),p_xa_s[gamma[0]][2:101],color=cm.get_cmap('Purples',6)(5),alpha=0.6,label='γ={}'.format(gamma[0])); \n",
    "plt.scatter(np.arange(2,100+1),p_xa_s[gamma[10]][2:101],color=cm.get_cmap('Purples',6)(3),label='γ={}'.format(gamma[10])); \n",
    "plt.scatter(np.arange(2,100+1),p_xa_s[gamma[-1]][2:101],color=cm.get_cmap('Purples',6)(1),label='γ={}'.format(gamma[-1])); \n",
    "plt.xlabel('# of allele copies'); plt.ylabel('moments likelihood'); plt.legend(); plt.loglog(); plt.grid()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds_sin_onlyfreq, ci_sin_onlyfreq, preds_sin_onlyage, ci_sin_onlyage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.figure(dpi=150)\n",
    "import matplotlib.patches as mpatches\n",
    "seaborn.stripplot(data=pd.DataFrame(info_onlyfreq.T,columns=-gamma[::-1]), color='deepskyblue', alpha=0.7, label='only freq',s=4)\n",
    "seaborn.stripplot(data=pd.DataFrame(info_onlyage.T,columns=-gamma[::-1]), color='coral', alpha=0.7, label='freq & age',s=4)\n",
    "plt.semilogy(); plt.xlabel('gamma'); plt.ylabel('information measure'); plt.grid(); \n",
    "plt.legend(handles=[mpatches.Patch(color='deepskyblue', label='only freq, total info: {:.2f}'.format(np.sum(info_onlyfreq))), mpatches.Patch(color='coral', label='freq & age, total info: {:.2f}'.format(np.sum(info_onlyage)))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## plotting error rates across selection coefficients\n",
    "plt.plot(-gamma, np.abs(gamma-preds_sin_onlyfreq), color='deepskyblue', alpha=0.8, label='only freq'.format(np.sum(np.abs(gamma-preds_sin_onlyfreq))), ls='--')\n",
    "plt.plot(-gamma, np.abs(gamma-preds_sin_onlyage), color='coral', label='freq & age', alpha=0.8, ls='--')\n",
    "plt.legend(); plt.semilogx(); plt.xlabel('-γ'); plt.ylabel('absolute error'); plt.show()\n",
    "\n",
    "plt.plot(-gamma, -np.abs(gamma-preds_sin_onlyfreq)*100/gamma, color='deepskyblue', alpha=0.8, label='only freq, total: {:.2f}'.format(np.sum(-np.abs(gamma-preds_sin_onlyfreq)*100/gamma)), ls='--')\n",
    "plt.plot(-gamma, -np.abs(gamma-preds_sin_onlyage)*100/gamma, color='coral', label='freq & age, total: {:.2f}'.format(np.sum(-np.abs(gamma-preds_sin_onlyage)*100/gamma)), alpha=0.8, ls='--')\n",
    "plt.legend(); plt.semilogx(); plt.xlabel('-γ'); plt.ylabel('relative error'); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## picking a choice of g1 and g2 & creating a new data frame\n",
    "trueg1 = gamma[-4]\n",
    "trueg2 = gamma[-10]\n",
    "# 2000 x 3 (first 1000 is g1, second 1000 is g2)\n",
    "newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==trueg1)),:].append(df1.iloc[np.ravel(np.where(dat[:,1]==trueg2)),:])\n",
    "# newdf1 = newdf1.sample(frac=1)\n",
    "\n",
    "# only keeping alleles with ages > 1 (cos NN & PRF approx finds really high prob for these alleles to have small gamma...)\n",
    "newdat = newdf1.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## need code to do scipy.optimize for two parameters...\n",
    "def get_ll_freq2(g, sXlred, n=2000, cutoff=2):\n",
    "    g1, g2 = g\n",
    "\n",
    "    fs1 = moments.Spectrum(np.zeros(n+1))\n",
    "    fs1[1] = 1\n",
    "    fs1.integrate([0.5], 10, gamma=g1)\n",
    "    pxs1 = fs1/np.sum(fs1[np.arange(cutoff,n-cutoff+1)])\n",
    "\n",
    "    fs2 = moments.Spectrum(np.zeros(n+1))\n",
    "    fs2[1] = 1\n",
    "    fs2.integrate([0.5], 10, gamma=g2)\n",
    "    pxs2 = fs2/np.sum(fs2[np.arange(cutoff,n-cutoff+1)])\n",
    "\n",
    "    res = np.empty(np.sum((sXlred>cutoff) & (sXlred<n-cutoff+1))) #np.empty(len(Xlred))\n",
    "\n",
    "    # just performing a search in a look-up table\n",
    "    for idx, i in enumerate(np.where((sXlred>cutoff) & (sXlred<n-cutoff+1))[0]):\n",
    "        res[idx] = np.log(0.5*pxs1[sXlred[i]]+0.5*pxs2[sXlred[i]])\n",
    "    \n",
    "    return -np.sum(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ll_freqage2(g, sXlred, alred, n=2000, cutoff=2):\n",
    "    g1, g2 = g\n",
    "\n",
    "    pxas1 = run_mom_iterate(int(100000+900*g1), n, 0.5*g1/N, N, 1.25e-8, misc = {'dt_fac':0.02, 'adapt_dt':True})\n",
    "    pxas1[:,np.arange(cutoff,n-cutoff+1)] /= np.sum(pxas1[:,np.arange(cutoff,n-cutoff+1)]) \n",
    "\n",
    "    pxas2 = run_mom_iterate(int(100000+900*g2), n, 0.5*g2/N, N, 1.25e-8, misc = {'dt_fac':0.02, 'adapt_dt':True})\n",
    "    pxas2[:,np.arange(cutoff,n-cutoff+1)] /= np.sum(pxas2[:,np.arange(cutoff,n-cutoff+1)]) \n",
    "\n",
    "    res = np.empty(np.sum((sXlred>cutoff) & (sXlred<n-cutoff+1)))\n",
    "    \n",
    "    for idx, i in enumerate(np.where((sXlred>cutoff) & (sXlred<n-cutoff+1))[0]):\n",
    "        res[idx] = np.log(0.5*pxas1[-int(alred[i]),sXlred[i]] + 0.5*pxas2[-int(alred[i]),sXlred[i]])\n",
    "\n",
    "    return -np.sum(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.sum((newdat[:,5]>cutoff) & (newdat[:,5]<2000-cutoff+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0.5*pxs1[newdat[10,5]] + 0.5*pxs2[newdat[10,5]]\n",
    "# trueg1, trueg2, N, 41843.793\n",
    "# sp.optimize.minimize(get_ll_freqage2, x0=[trueg1, trueg2], method='L-BFGS-B', args=(newdat[:,5], newdat[:,2]), options={'maxiter':5, 'ftol':1.}, bounds=[(-200,-0.2),(-200,-0.2)])\n",
    "np.sum((trueg1+24.772)**2+(trueg2+11.16)**2)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sp.optimize.basinhopping(get_ll_freq2, x0=[-10,-10], minimizer_kwargs={'method': 'L-BFGS-B', 'args': (newdat[:,5]), 'tol': (1., 1.)})\n",
    "sp.optimize.minimize(get_ll_freq2, x0=[-1,-10], method='L-BFGS-B', args=(newdat[:,5]), options={'maxiter':50, 'ftol':1e-2,}, bounds=[(-200,-0.2),(-200,-0.2)])\n",
    "# Nelder-Mead: 'xatol':0.25, 'fatol': 1., takes ~1min/iter and progresses slowly (need to initialize close to true for faster convergence)\n",
    "# sp.optimize.minimize(get_ll_freqage2, x0=[trueg1+1, trueg2+1], method='TNC', args=(newdat[:,5], newdat[:,2]), options={'eps':1e-2,'ftol':1,'xtol':1e-2,'gtol':1e-2,},)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## assuming two selection coefficients and only freq info (split 50/50)\n",
    "dub_onlyfreq = np.zeros((len(gamma2),len(gamma2))) # need a 2d search\n",
    "# for ig1, g1 in enumerate(gamma2):\n",
    "#     for ig2, g2 in enumerate(gamma2[0:(ig1+1)]):\n",
    "#         dub_onlyfreq[ig1, ig2] = np.sum(np.log(0.5*np.exp(get_lp_xl(g1, newdat[:,5])) + 0.5*np.exp(get_lp_xl(g2, newdat[:,5]))))\n",
    "\n",
    "mask = np.full(dub_onlyfreq.shape,False)\n",
    "mask[np.triu_indices_from(dub_onlyfreq,k=1)] = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seaborn.heatmap(dub_onlyfreq,alpha=0.95,cmap='viridis_r',mask=mask,vmax=np.max(dub_onlyfreq[~mask])-5,vmin=np.max(dub_onlyfreq[~mask]))\n",
    "plt.xticks(np.linspace(0,24,6,dtype='int'),gamma2[np.linspace(0,24,6,dtype='int')].round(2))\n",
    "plt.yticks(np.linspace(0,24,6,dtype='int'),gamma2[np.linspace(0,24,6,dtype='int')].round(2))\n",
    "np.take(gamma, np.unravel_index(np.nanargmax(np.ma.masked_array(dub_onlyfreq, mask)),dub_onlyfreq.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## assuming two selection coefficients and only age info (split 50/50)\n",
    "dub_onlyage = np.zeros((len(gamma2),len(gamma2))) # need a 2d search\n",
    "for ig1, g1 in enumerate(gamma2):\n",
    "    for ig2, g2 in enumerate(gamma2[0:(ig1+1)]):\n",
    "        dub_onlyage[ig1, ig2] = np.sum(np.log(0.5*np.exp(get_lp_alxl(g1, newdat[:,5], newdat[:,2])) + \n",
    "        0.5*np.exp(get_lp_alxl(g2, newdat[:,5], newdat[:,2]))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seaborn.heatmap(dub_onlyage,alpha=0.75,xticklabels=gamma,yticklabels=gamma,cmap='Blues',mask=mask,vmin=np.max(dub_onlyage[~mask])-10,vmax=np.max(dub_onlyage[~mask]))\n",
    "plt.xticks(np.linspace(0,24,6,dtype='int'),gamma2[np.linspace(0,24,6,dtype='int')].round(2))\n",
    "plt.yticks(np.linspace(0,24,6,dtype='int'),gamma2[np.linspace(0,24,6,dtype='int')].round(2))\n",
    "np.take(gamma, np.unravel_index(np.argmax(np.ma.masked_array(dub_onlyage, mask)),dub_onlyfreq.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.unravel_index(np.argmax(np.ma.masked_array(dub_onlyage, mask)),dub_onlyage.shape)\n",
    "np.unravel_index(np.nanargmax(np.ma.masked_array(dub_onlyfreq, mask)),dub_onlyfreq.shape)\n",
    "# print(np.max(dub_onlyfreq[~mask]))\n",
    "# print(np.max(dub_onlyage[~mask]))\n",
    "# dub_onlyfreq[24,]\n",
    "# dub_onlyage[21,]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What if there was only one $\\gamma$ in the data? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "samepredsonlyfreq = np.zeros((len(gamma),4))\n",
    "samepredsagefreq = np.zeros((len(gamma),4))\n",
    "for itg, trueg in enumerate(gamma):\n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==trueg)),:]\n",
    "\n",
    "    newdat = newdf1.to_numpy()\n",
    "    \n",
    "    sin_onlyfreq = np.zeros(len(gamma))\n",
    "    sin_agefreq = np.zeros(len(gamma))\n",
    "    \n",
    "    dub_onlyfreq = np.zeros((len(gamma),len(gamma))) # need a 2d search\n",
    "    dub_agefreq = np.zeros((len(gamma),len(gamma))) # need a 2d search\n",
    "\n",
    "    for ig1, g1 in enumerate(gamma):\n",
    "        sin_onlyfreq[ig1] = np.sum(get_lp_xl(g1, newdat[:,5]))\n",
    "        # sin_agefreq[ig1] = np.sum(get_lp_alxl(g1, newdat[:,0], newdat[:,2], n=100) + get_lp_xl(g1, newdat[:,0]))\n",
    "        sin_agefreq[ig1] = np.sum(get_lp_alxl(g1, newdat[:,5], newdat[:,2]))\n",
    "\n",
    "        for ig2, g2 in enumerate(gamma[0:(ig1+1)]):        \n",
    "            dub_onlyfreq[ig1, ig2] = np.sum(np.log(0.5*np.exp(get_lp_xl(g1, newdat[:,5])) + 0.5*np.exp(get_lp_xl(g2, newdat[:,5]))))\n",
    "    \n",
    "            # dub_agefreq[ig1, ig2] = np.sum(np.log(0.5*np.exp(get_lp_alxl(g1, newdat[:,0], newdat[:,2], n=100) + get_lp_xl(g1, newdat[:,0])) + 0.5*np.exp(get_lp_alxl(g2, newdat[:,0], newdat[:,2], n=100) + get_lp_xl(g2, newdat[:,0]))))\n",
    "            \n",
    "            dub_agefreq[ig1, ig2] = np.sum(np.log(0.5*np.exp(get_lp_alxl(g1, newdat[:,5], newdat[:,2])) + 0.5*np.exp(get_lp_alxl(g2, newdat[:,5], newdat[:,2]))))\n",
    "\n",
    "    estgonlyfreq = gamma[np.argmax(sin_onlyfreq)]\n",
    "\n",
    "    estg1onlyfreq = gamma[np.unravel_index(dub_onlyfreq.argmax(), dub_onlyfreq.shape)[0]]\n",
    "    estg2onlyfreq = gamma[np.unravel_index(dub_onlyfreq.argmax(), dub_onlyfreq.shape)[1]]\n",
    "\n",
    "    lambfreq = 2.*(np.max(dub_onlyfreq[~mask]) - np.max(sin_onlyfreq))\n",
    "\n",
    "    samepredsonlyfreq[itg,2] = estgonlyfreq\n",
    "\n",
    "    samepredsonlyfreq[itg,:2] = np.take(gamma, np.unravel_index(np.nanargmax(np.ma.masked_array(dub_onlyfreq, mask)),dub_onlyfreq.shape))\n",
    "\n",
    "    if(chi2.sf(lambfreq, 1)<0.05):\n",
    "        samepredsonlyfreq[itg,3] = True\n",
    "    else:\n",
    "        samepredsonlyfreq[itg,3] = False\n",
    "\n",
    "    estgagefreq = gamma[np.nanargmax(sin_agefreq)]        \n",
    "\n",
    "    estg1agefreq = np.take(gamma, np.unravel_index(np.nanargmax(np.ma.masked_array(dub_agefreq, mask)),dub_agefreq.shape))[0]\n",
    "    estg2agefreq = np.take(gamma, np.unravel_index(np.nanargmax(np.ma.masked_array(dub_agefreq, mask)),dub_agefreq.shape))[1]\n",
    "\n",
    "    lambagefreq = 2.*(np.nanmax(dub_agefreq[~mask]) - np.nanmax(sin_agefreq))\n",
    "\n",
    "    samepredsagefreq[itg,2] = estgagefreq\n",
    "\n",
    "    samepredsagefreq[itg,:2] = np.take(gamma, np.unravel_index(np.nanargmax(np.ma.masked_array(dub_agefreq, mask)),dub_agefreq.shape))\n",
    "\n",
    "    if(chi2.sf(lambagefreq, 1)<0.05):\n",
    "        samepredsagefreq[itg,3] = True\n",
    "    else:\n",
    "        samepredsagefreq[itg,3] = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.max(dub_onlyfreq) - np.max(sin_onlyfreq)\n",
    "samepredsagefreq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## plotting the above results\n",
    "plt.scatter(-gamma, -samepredsonlyfreq[:,0], color='deepskyblue', marker='+', alpha=0.5)\n",
    "plt.scatter(-gamma, -samepredsonlyfreq[:,1], color='deepskyblue', marker='+', label='estimates using only freq', alpha=0.5)\n",
    "plt.scatter(-gamma, -samepredsagefreq[:,0], color='coral', marker='*', label='estimates using freq & age', alpha=0.5)\n",
    "plt.scatter(-gamma, -samepredsagefreq[:,1], color='coral', marker='*', alpha=0.5)\n",
    "plt.xlabel('true -γ value'); plt.ylabel('predicted -γ value(s)'); plt.loglog()\n",
    "plt.axline((0.01,0.01),(100,100),color='grey',ls='--'); plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Template code to compute difference in $\\gamma$ given set of data\n",
    "\n",
    "Here, I will run the mechanism to compute the probability of a significant difference in selection coefficients is detected given a set of large data i.e., 2000 data points and I will resample 25 times to obtain smaller datasets of 500. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# num_sims is number of reps to run to calculate prob\n",
    "# num_samps is number of rows to resample the big data from\n",
    "# gamma is np.array of values to calculate over\n",
    "# thresh is threshold to assign significance\n",
    "def resample_calculateprob_freq(newdat, gamma, num_sims=16, num_samps=500, thresh=0.05, cutoff=cutoff):\n",
    "    prob = 0.\n",
    "    sin_onlyfreq = np.empty(len(gamma))\n",
    "    dub_onlyfreq = np.zeros((len(gamma),len(gamma)))\n",
    "    for n in np.arange(num_sims):\n",
    "        newnewdat = newdat[np.random.choice(newdat.shape[0], num_samps, replace=False),:]\n",
    "        for ig, g in enumerate(gamma):\n",
    "            # sum log prob for each locus\n",
    "            sin_onlyfreq[ig] = np.sum(get_lp_xl(g, newnewdat[:,5], cutoff=cutoff))\n",
    "            for ig2, g2 in enumerate(gamma[0:(ig+1)]):\n",
    "                dub_onlyfreq[ig, ig2] = np.sum(np.log(0.5*np.exp(get_lp_xl(g, newnewdat[:,5], cutoff=cutoff)) + 0.5*np.exp(get_lp_xl(g2, newnewdat[:,5], cutoff=cutoff))))\n",
    "\n",
    "\n",
    "        estgonlyfreq = gamma[np.argmax(sin_onlyfreq)]\n",
    "\n",
    "        # estg1onlyfreq = gamma[np.unravel_index(dub_onlyfreq.argmax(), dub_onlyfreq.shape)[0]]\n",
    "        # estg2onlyfreq = gamma[np.unravel_index(dub_onlyfreq.argmax(), dub_onlyfreq.shape)[1]]\n",
    "        estg1onlyfreq, estg2onlyfreq = np.take(gamma, np.unravel_index(np.argmax(np.ma.masked_array(dub_onlyfreq, mask)),dub_onlyfreq.shape))\n",
    "\n",
    "        lambfreq = 2.*(dub_onlyfreq[gamma==estg1onlyfreq,gamma==estg2onlyfreq] - sin_onlyfreq[gamma==estgonlyfreq])\n",
    "\n",
    "        if(chi2.sf(lambfreq, 1)<thresh):\n",
    "            prob += 1.\n",
    "\n",
    "    return [prob/num_sims, estgonlyfreq, np.array([estg1onlyfreq, estg2onlyfreq])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 387,
   "metadata": {},
   "outputs": [],
   "source": [
    "## function call to find MLE using scipy.optimize (and corresponding changes in the next steps for LRT)\n",
    "## pass in the entire data set & positive gamma and do wrangling inside function\n",
    "def resample_calculateprob_freqcont(dft, gamma, t=200, n=200, thresh=0.05):\n",
    "    dft['empty'] = ''\n",
    "    dft['sXl'] = (dft['Xl']*n).astype('int')\n",
    "    dft['al'] = 80000+1 - dft['al']\n",
    "    dft['al'] = dft['al'].astype('int')\n",
    "    dft = dft.iloc[:,1:]\n",
    "    datt = dft.to_numpy()\n",
    "    sfs = moments.Spectrum(np.histogram(datt[:,5],bins=range(0,n+2))[0])\n",
    "    SMS = np.zeros((80000,n+1),dtype='int16')\n",
    "    mask = np.zeros_like(SMS); mask[0,:] = 1; mask[:,0] = 1; mask[:,-1] = 1;\n",
    "    for i in range(len(datt)):\n",
    "        SMS[datt[i,2],datt[i,5]] += 1\n",
    "    SMSmask = np.ma.array(SMS,mask=mask)\n",
    "\n",
    "    ressinf = sp.optimize.minimize_scalar(get_ll_freqconstant,args=({'sfs':sfs,'theta':t,'p_misid':0},n))\n",
    "    lldubf = get_ll_freqconstant_twogam(np.log10([-gamma[0],-gamma[1]]),{'sfs':sfs,'theta':t,'p_misid':0},n)\n",
    "    # print(ressinf.fun, lldubf)\n",
    "\n",
    "    if(chi2.sf(2.*(ressinf.fun - lldubf),1)<thresh):\n",
    "        probf = 1\n",
    "    else:\n",
    "        probf = 0\n",
    "\n",
    "    # ressina = sp.optimize.minimize_scalar(get_ll_freqageconstant,args=({'sms':SMSmask,'theta':t,'N':10000,'p_misid':0,'gens':80000},n))\n",
    "    # llduba = get_ll_freqageconstant_twogam(np.log10([-gamma[0],-gamma[1]]),{'sms':SMSmask,'theta':t,'N':10000,'gens':80000},n)\n",
    "    \n",
    "    # print(ressina.fun, llduba)\n",
    "    # if(chi2.sf(2.*(ressina.fun - llduba),1)<thresh):\n",
    "    #     proba = 1\n",
    "    # else:\n",
    "    #     proba = 0\n",
    "    proba = 1; \n",
    "\n",
    "    return [probf, proba, ressinf.x, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# num_samps is number of rows to resample the big data from\n",
    "# gamma is np.array of values to calculate over\n",
    "# thresh is threshold to assign significance\n",
    "def resample_calculateprob_agefreq(newdat, gamma, num_sims=16, num_samps=500, thresh=0.05):\n",
    "    prob = 0.\n",
    "\n",
    "    sin_agefreq = np.empty(len(gamma))\n",
    "    \n",
    "    dub_agefreq = np.zeros((len(gamma),len(gamma)))\n",
    "    for n in np.arange(num_sims):\n",
    "        newnewdat = newdat[np.random.choice(newdat.shape[0], num_samps, replace=False),:]\n",
    "        for ig, g in enumerate(gamma):\n",
    "            # sum log prob for each locus\n",
    "            sin_agefreq[ig] = np.sum(get_lp_alxl(g, newnewdat[:,0], newnewdat[:,2], n=100) + get_lp_xl(g, newnewdat[:,0]))\n",
    "            for ig2, g2 in enumerate(gamma[0:(ig+1)]):\n",
    "                dub_agefreq[ig, ig2] = np.sum(np.log(0.5*np.exp(get_lp_alxl(g, newnewdat[:,5], newnewdat[:,2]) + get_lp_xl(g, newnewdat[:,5])) + 0.5*np.exp(get_lp_alxl(g2, newnewdat[:,5], newnewdat[:,2]) + get_lp_xl(g2, newnewdat[:,5]))))\n",
    "\n",
    "        estgagefreq = gamma[np.nanargmax(sin_agefreq)]        \n",
    "\n",
    "        estg1agefreq = gamma[np.unravel_index(np.nanargmax(dub_agefreq[~mask]), dub_agefreq.shape)[0]]\n",
    "        estg2agefreq = gamma[np.unravel_index(np.nanargmax(dub_agefreq[~mask]), dub_agefreq.shape)[1]]\n",
    "\n",
    "        lambagefreq = 2.*(dub_agefreq[gamma==estg1agefreq,gamma==estg2agefreq] - sin_agefreq[gamma==estgagefreq])\n",
    "\n",
    "        if(chi2.sf(lambagefreq, 1)<thresh):\n",
    "            prob += 1.\n",
    "\n",
    "    return prob/num_sims"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# num_samps is number of rows to resample the big data from\n",
    "# gamma is np.array of values to calculate over\n",
    "# thresh is threshold to assign significance\n",
    "def resample_calculateprob_age(newdat, gamma, num_sims=16, num_samps=500, thresh=0.05, cutoff=cutoff):\n",
    "    prob = 0.\n",
    "\n",
    "    sin_onlyage = np.empty(len(gamma))\n",
    "    \n",
    "    dub_onlyage = np.zeros((len(gamma),len(gamma)))\n",
    "    for n in np.arange(num_sims):\n",
    "        newnewdat = newdat[np.random.choice(newdat.shape[0], num_samps, replace=False),:]\n",
    "        for ig, g in enumerate(gamma):\n",
    "            # sum log prob for each locus\n",
    "            sin_onlyage[ig] = np.sum(get_lp_alxl(g, newnewdat[:,5], newnewdat[:,2], cutoff=cutoff))\n",
    "            for ig2, g2 in enumerate(gamma[0:(ig+1)]):\n",
    "                dub_onlyage[ig, ig2] = np.sum(np.log(0.5*np.exp(get_lp_alxl(g, newnewdat[:,5], newnewdat[:,2], cutoff=cutoff)) + 0.5*np.exp(get_lp_alxl(g2, newnewdat[:,5], newnewdat[:,2], cutoff=cutoff))))\n",
    "\n",
    "        estgonlyage = gamma[np.argmax(sin_onlyage)]        \n",
    "\n",
    "        # estg1onlyage = gamma[np.unravel_index(dub_onlyage.argmax(), dub_onlyage.shape)[0]]\n",
    "        # estg2onlyage = gamma[np.unravel_index(dub_onlyage.argmax(), dub_onlyage.shape)[1]]\n",
    "        estg1onlyage, estg2onlyage = np.take(gamma, np.unravel_index(np.argmax(np.ma.masked_array(dub_onlyage, mask)),dub_onlyage.shape))\n",
    "\n",
    "        lambonlyage = 2.*(dub_onlyage[gamma==estg1onlyage,gamma==estg2onlyage] - sin_onlyage[gamma==estgonlyage])\n",
    "\n",
    "        if(chi2.sf(lambonlyage, 1)<thresh):\n",
    "            prob += 1.\n",
    "\n",
    "    return [prob/num_sims, estgonlyage, np.array([estg1onlyage, estg2onlyage])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nsims = 15\n",
    "gamma = [-1.,-2.,-5.,-10.,-20.,-50.,-100.]\n",
    "diffgamma = np.reshape(list(it.combinations(gamma, 2)), (-1,2)) # np.reshape([(-1., x) for x in gamma[:-1][::2]], (-1,2)) #\n",
    "# diffgamma = [[-1.,-5.],[-2.,-10.],[-2.,-20.],[-5.,-50.],[-10.,-50.],[-20.,-100.]]\n",
    "# diffprobsf = np.zeros((len(diffgamma),nsims))\n",
    "# diffprobsa = np.zeros((len(diffgamma),nsims))\n",
    "# sinpredsf = np.zeros((len(diffgamma),nsims))\n",
    "# sinpredsa = np.zeros((len(diffgamma),nsims))\n",
    "# for ig, g in enumerate(diffgamma[::-1]):\n",
    "#     print(g)\n",
    "#     for sim in range(nsims):\n",
    "#         with open('simfiles/SelPoint.txt', 'r') as file:\n",
    "#             data = file.readlines()\n",
    "\n",
    "#         data[0] = '{:d} 0.5\\n'.format(int(-g[1]))\n",
    "#         data[1] = '{:d} 1.0\\n'.format(int(-g[0]))\n",
    "\n",
    "#         with open('simfiles/SelPoint.txt', 'w') as file:\n",
    "#             file.writelines(data)\n",
    "\n",
    "#         with open('simfiles/ParameterFilesPoint.txt', 'r') as file:\n",
    "#             data = file.readlines()\n",
    "        \n",
    "#         data[0] = 'MutationRate: {}\\n'.format(1000)\n",
    "#         data[8] = 'FilePrefix: outfiles/Point_g{}_g{}_t{}_sim{}'.format(-g[0],-g[1],1000,sim)\n",
    "\n",
    "#         with open('simfiles/ParameterFilesPoint.txt', 'w') as file:\n",
    "#             file.writelines(data)\n",
    "        \n",
    "#         os.system(\"GSL_RNG_SEED={} GSL_RNG_TYPE=mrg ../../PReFerSim/PReFerSim simfiles/ParameterFilesPoint.txt 3 > /dev/null 2>&1 \".format(rng.integers(100496)))\n",
    "\n",
    "#         dft = pd.read_csv('outfiles/Point_g{}_g{}_t{}_sim{}.3.full_out.txt'.format(-g[0],-g[1],1000,sim),sep='\\t',header=None,names=['','Xl','s','al','id'])\n",
    "#         res = resample_calculateprob_freqcont(dft, g, t=1000)\n",
    "#         diffprobsf[ig,sim] = res[0]; diffprobsa[ig,sim] = res[1]; sinpredsf[ig,sim] = 10**res[2]; sinpredsa[ig,sim] = 10**res[3]\n",
    "#         print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# diffprobsf, diffprobsa, sinpredsf, sinpredsa\n",
    "# np.savetxt(X=np.vstack((diffprobsf,diffprobsa)),fname=\"resfiles/diffprob_t40.txt\")\n",
    "# gamma = [-1.,-2.,-5.,-10.,-20.,-50.,-100.]\n",
    "# diffgamma = np.reshape(list(it.combinations(gamma, 2)), (-1,2))\n",
    "# os.chdir(\"/Users/vivaswatshastry/selCoefEst/PReFerSims/\")\n",
    "diffprobsf = np.loadtxt('resfiles/diffprob_t40.txt')[:21,:]; diffprobsa = np.loadtxt('resfiles/diffprob_t40.txt')[21:,:]\n",
    "# df = pd.read_csv('~/selCoefEst/PReFerSims/outfiles/Point_g{}_g{}_sim{}.3.full_out.txt'.format(5.,100.,7),sep='\\t',header=None,names=['','Xl','s','al','id'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.000, 4.000, 9.000, 14.000, 15.000, 14.000, 0.000, 7.000, 11.000,\n",
       "        13.000, 15.000, 0.000, 4.000, 9.000, 13.000, 0.000, 5.000, 11.000,\n",
       "        0.000, 2.000, 0.000]),\n",
       " array([0.000, 5.000, 11.000, 14.000, 15.000, 14.000, 2.000, 10.000,\n",
       "        13.000, 14.000, 15.000, 0.000, 7.000, 13.000, 14.000, 0.000,\n",
       "        10.000, 13.000, 1.000, 5.000, 0.000]))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diffprobsf.sum(axis=1), diffprobsa.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [74]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m newdat \u001b[38;5;241m=\u001b[39m newdf1\u001b[38;5;241m.\u001b[39mto_numpy()\n\u001b[1;32m      9\u001b[0m \u001b[38;5;66;03m## continuous pred doesn't do great, worse than using grid! \u001b[39;00m\n\u001b[0;32m---> 10\u001b[0m diffprobs[ig,\u001b[38;5;241m0\u001b[39m], sinpreds[ig,\u001b[38;5;241m0\u001b[39m], dubpreds[ig,:\u001b[38;5;241m2\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[43mresample_calculateprob_freqcont\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnewdat\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mgamma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_sims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m5\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mnum_samps\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcutoff\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "Input \u001b[0;32mIn [66]\u001b[0m, in \u001b[0;36mresample_calculateprob_freqcont\u001b[0;34m(newdat, gamma, num_sims, num_samps, thresh, cutoff)\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m n \u001b[38;5;129;01min\u001b[39;00m np\u001b[38;5;241m.\u001b[39marange(num_sims):\n\u001b[1;32m      7\u001b[0m     newnewdat \u001b[38;5;241m=\u001b[39m newdat[np\u001b[38;5;241m.\u001b[39mrandom\u001b[38;5;241m.\u001b[39mchoice(newdat\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m0\u001b[39m], num_samps, replace\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m),:]\n\u001b[0;32m----> 8\u001b[0m     ressin \u001b[38;5;241m=\u001b[39m \u001b[43msp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mminimize_scalar\u001b[49m\u001b[43m(\u001b[49m\u001b[43mget_ll_freq\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mnewnewdat\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mxtol\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m.05\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      9\u001b[0m     resdub \u001b[38;5;241m=\u001b[39m sp\u001b[38;5;241m.\u001b[39moptimize\u001b[38;5;241m.\u001b[39mminimize(get_ll_freq2, x0\u001b[38;5;241m=\u001b[39m[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m10\u001b[39m], method\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mL-BFGS-B\u001b[39m\u001b[38;5;124m'\u001b[39m, args\u001b[38;5;241m=\u001b[39m(newnewdat[:,\u001b[38;5;241m1\u001b[39m]), options\u001b[38;5;241m=\u001b[39m{\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mmaxiter\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;241m50\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mftol\u001b[39m\u001b[38;5;124m'\u001b[39m:\u001b[38;5;241m1e-2\u001b[39m,}, bounds\u001b[38;5;241m=\u001b[39m[(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m200\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m0.2\u001b[39m),(\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m200\u001b[39m,\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m0.2\u001b[39m)])\n\u001b[1;32m     11\u001b[0m     estgonlyfreq \u001b[38;5;241m=\u001b[39m ressin\u001b[38;5;241m.\u001b[39mx\n",
      "File \u001b[0;32m~/mambaforge/envs/cvae/lib/python3.10/site-packages/scipy/optimize/_minimize.py:886\u001b[0m, in \u001b[0;36mminimize_scalar\u001b[0;34m(fun, bracket, bounds, args, method, tol, options)\u001b[0m\n\u001b[1;32m    884\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m method(fun, args\u001b[38;5;241m=\u001b[39margs, bracket\u001b[38;5;241m=\u001b[39mbracket, bounds\u001b[38;5;241m=\u001b[39mbounds, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39moptions)\n\u001b[1;32m    885\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m meth \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbrent\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m--> 886\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_minimize_scalar_brent\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfun\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbracket\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    887\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m meth \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbounded\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[1;32m    888\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m bounds \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
      "File \u001b[0;32m~/mambaforge/envs/cvae/lib/python3.10/site-packages/scipy/optimize/_optimize.py:2498\u001b[0m, in \u001b[0;36m_minimize_scalar_brent\u001b[0;34m(func, brack, args, xtol, maxiter, disp, **unknown_options)\u001b[0m\n\u001b[1;32m   2495\u001b[0m brent \u001b[38;5;241m=\u001b[39m Brent(func\u001b[38;5;241m=\u001b[39mfunc, args\u001b[38;5;241m=\u001b[39margs, tol\u001b[38;5;241m=\u001b[39mtol,\n\u001b[1;32m   2496\u001b[0m               full_output\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, maxiter\u001b[38;5;241m=\u001b[39mmaxiter, disp\u001b[38;5;241m=\u001b[39mdisp)\n\u001b[1;32m   2497\u001b[0m brent\u001b[38;5;241m.\u001b[39mset_bracket(brack)\n\u001b[0;32m-> 2498\u001b[0m \u001b[43mbrent\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2499\u001b[0m x, fval, nit, nfev \u001b[38;5;241m=\u001b[39m brent\u001b[38;5;241m.\u001b[39mget_result(full_output\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m   2501\u001b[0m success \u001b[38;5;241m=\u001b[39m nit \u001b[38;5;241m<\u001b[39m maxiter \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (np\u001b[38;5;241m.\u001b[39misnan(x) \u001b[38;5;129;01mor\u001b[39;00m np\u001b[38;5;241m.\u001b[39misnan(fval))\n",
      "File \u001b[0;32m~/mambaforge/envs/cvae/lib/python3.10/site-packages/scipy/optimize/_optimize.py:2268\u001b[0m, in \u001b[0;36mBrent.optimize\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   2265\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21moptimize\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m   2266\u001b[0m     \u001b[38;5;66;03m# set up for optimization\u001b[39;00m\n\u001b[1;32m   2267\u001b[0m     func \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfunc\n\u001b[0;32m-> 2268\u001b[0m     xa, xb, xc, fa, fb, fc, funcalls \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_bracket_info\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2269\u001b[0m     _mintol \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mintol\n\u001b[1;32m   2270\u001b[0m     _cg \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cg\n",
      "File \u001b[0;32m~/mambaforge/envs/cvae/lib/python3.10/site-packages/scipy/optimize/_optimize.py:2242\u001b[0m, in \u001b[0;36mBrent.get_bracket_info\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m   2239\u001b[0m \u001b[38;5;66;03m### BEGIN core bracket_info code ###\u001b[39;00m\n\u001b[1;32m   2240\u001b[0m \u001b[38;5;66;03m### carefully DOCUMENT any CHANGES in core ##\u001b[39;00m\n\u001b[1;32m   2241\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m brack \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m-> 2242\u001b[0m     xa, xb, xc, fa, fb, fc, funcalls \u001b[38;5;241m=\u001b[39m \u001b[43mbracket\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2243\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(brack) \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m2\u001b[39m:\n\u001b[1;32m   2244\u001b[0m     xa, xb, xc, fa, fb, fc, funcalls \u001b[38;5;241m=\u001b[39m bracket(func, xa\u001b[38;5;241m=\u001b[39mbrack[\u001b[38;5;241m0\u001b[39m],\n\u001b[1;32m   2245\u001b[0m                                                xb\u001b[38;5;241m=\u001b[39mbrack[\u001b[38;5;241m1\u001b[39m], args\u001b[38;5;241m=\u001b[39margs)\n",
      "File \u001b[0;32m~/mambaforge/envs/cvae/lib/python3.10/site-packages/scipy/optimize/_optimize.py:2752\u001b[0m, in \u001b[0;36mbracket\u001b[0;34m(func, xa, xb, args, grow_limit, maxiter)\u001b[0m\n\u001b[1;32m   2750\u001b[0m _gold \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1.618034\u001b[39m  \u001b[38;5;66;03m# golden ratio: (1.0+sqrt(5.0))/2.0\u001b[39;00m\n\u001b[1;32m   2751\u001b[0m _verysmall_num \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1e-21\u001b[39m\n\u001b[0;32m-> 2752\u001b[0m fa \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mxa\u001b[49m\u001b[43m,\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2753\u001b[0m fb \u001b[38;5;241m=\u001b[39m func(\u001b[38;5;241m*\u001b[39m(xb,) \u001b[38;5;241m+\u001b[39m args)\n\u001b[1;32m   2754\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (fa \u001b[38;5;241m<\u001b[39m fb):                      \u001b[38;5;66;03m# Switch so fa > fb\u001b[39;00m\n",
      "Input \u001b[0;32mIn [64]\u001b[0m, in \u001b[0;36mget_ll_freq\u001b[0;34m(g, sXlred, n, cutoff)\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[38;5;66;03m# just performing a search in a look-up table\u001b[39;00m\n\u001b[1;32m     10\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m idx, i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28menumerate\u001b[39m(np\u001b[38;5;241m.\u001b[39mwhere((sXlred\u001b[38;5;241m>\u001b[39mcutoff) \u001b[38;5;241m&\u001b[39m (sXlred\u001b[38;5;241m<\u001b[39mn\u001b[38;5;241m-\u001b[39mcutoff\u001b[38;5;241m+\u001b[39m\u001b[38;5;241m1\u001b[39m))[\u001b[38;5;241m0\u001b[39m]):\n\u001b[0;32m---> 11\u001b[0m     res[idx] \u001b[38;5;241m=\u001b[39m \u001b[43mpxs\u001b[49m\u001b[43m[\u001b[49m\u001b[43msXlred\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m     13\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;241m-\u001b[39mnp\u001b[38;5;241m.\u001b[39msum(np\u001b[38;5;241m.\u001b[39mlog(res))\n",
      "File \u001b[0;32m~/mambaforge/envs/cvae/lib/python3.10/site-packages/numpy/ma/core.py:3222\u001b[0m, in \u001b[0;36mMaskedArray.__getitem__\u001b[0;34m(self, indx)\u001b[0m\n\u001b[1;32m   3212\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m   3213\u001b[0m \u001b[38;5;124;03mx.__getitem__(y) <==> x[y]\u001b[39;00m\n\u001b[1;32m   3214\u001b[0m \n\u001b[1;32m   3215\u001b[0m \u001b[38;5;124;03mReturn the item described by i, as a masked array.\u001b[39;00m\n\u001b[1;32m   3216\u001b[0m \n\u001b[1;32m   3217\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m   3218\u001b[0m \u001b[38;5;66;03m# We could directly use ndarray.__getitem__ on self.\u001b[39;00m\n\u001b[1;32m   3219\u001b[0m \u001b[38;5;66;03m# But then we would have to modify __array_finalize__ to prevent the\u001b[39;00m\n\u001b[1;32m   3220\u001b[0m \u001b[38;5;66;03m# mask of being reshaped if it hasn't been set up properly yet\u001b[39;00m\n\u001b[1;32m   3221\u001b[0m \u001b[38;5;66;03m# So it's easier to stick to the current version\u001b[39;00m\n\u001b[0;32m-> 3222\u001b[0m dout \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[43mindx\u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m   3223\u001b[0m _mask \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mask\n\u001b[1;32m   3225\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_is_scalar\u001b[39m(m):\n",
      "\u001b[0;31mIndexError\u001b[0m: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices"
     ]
    }
   ],
   "source": [
    "diffgamma = np.reshape(list(it.combinations(gamma, 2)), (-1,2)) # np.reshape([(-1., x) for x in gamma[:-1][::2]], (-1,2)) #\n",
    "diffprobs = np.zeros((len(diffgamma),2))\n",
    "sinpreds = np.zeros((len(diffgamma),2))\n",
    "dubpreds = np.zeros((len(diffgamma),4))\n",
    "for ig, g in enumerate(diffgamma):\n",
    "    newdf1 = df2.iloc[np.ravel(np.where(dat2[:,0]==g[0])),:].append(df2.iloc[np.ravel(np.where(dat2[:,0]==g[1])),:])\n",
    "    # newdf1 = newdf1.sample(frac=1)\n",
    "    newdat = newdf1.to_numpy()\n",
    "    ## continuous pred doesn't do great, worse than using grid! \n",
    "    diffprobs[ig,0], sinpreds[ig,0], dubpreds[ig,:2] = resample_calculateprob_freqcont(newdat, gamma, num_sims=5, num_samps=100, cutoff=0)\n",
    "    # diffprobs[ig,1], sinpreds[ig,1], dubpreds[ig,-2:] = resample_calculateprob_age(newdat, gamma2, num_sims=20, num_samps=1000, cutoff=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dft = pd.read_csv('outfiles/Point.3.full_out.txt',sep='\\t',header=None,names=['','Xl','s','al','id'])\n",
    "# dft['empty'] = ''\n",
    "# dft['sXl'] = (dft['Xl']*200).astype('int')\n",
    "# dft['al'] = 80000+1 - dft['al']\n",
    "# dft['al'] = dft['al'].astype('int')\n",
    "# dft = dft.iloc[:,1:]\n",
    "# datt = dft.to_numpy()\n",
    "# sfs = moments.Spectrum(np.histogram(datt[:,5],bins=range(0,202))[0])\n",
    "# SMS = np.zeros((80000,200+1),dtype='int16')\n",
    "# mask = np.zeros_like(SMS); mask[0,:] = 1; mask[:,0] = 1; mask[:,-1] = 1;\n",
    "# for i in range(len(datt)):\n",
    "#     SMS[datt[i,2],datt[i,5]] += 1\n",
    "# SMSmask = np.ma.array(SMS,mask=mask)\n",
    "\n",
    "## with -100 & -1 (~15:85 split), -2.3 & -2.07 estimated with ll = -419 & -4536 respectively\n",
    "# sp.optimize.minimize_scalar(get_ll_freqconstant,args=({'sfs':sfs,'theta':2,'p_misid':0},200)), sp.optimize.minimize_scalar(get_ll_freqageconstant,args=({'sms':SMSmask,'theta':2,'N':10000,'p_misid':0,'gens':80000},200))\n",
    "# what if we said there were two gammas in the set? \n",
    "# from mom_functions import *\n",
    "## (-1, -65) & (-1,-90) estimated with ll = -349 & -4449 respectively (age takes ~4 mins)\n",
    "# sp.optimize.minimize(get_ll_freqconstant_twogam, x0=np.log10([5,50]), method='Nelder-Mead', args=({'sfs':sfs,'theta':200},400), bounds=[(-1,2.5),(-1,2.5)])\n",
    "# sp.optimize.minimize(get_ll_freqageconstant_twogam, x0=np.log10([1,50]), method='Powell', args=({'sms':SMSmask,'theta':200,'N':10000,'gens':80000},400), bounds=[(-1,2.5),(-1,2.5)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10.275835831072095, 40.862785)"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_ll_freqconstant_twogam(np.log10([5,50]),{'sfs':sfs,'theta':2,'p_misid':0},200), get_ll_freqageconstant_twogam(np.log10([5,50]),{'sms':SMSmask,'theta':2,'N':10000,'gens':80000},200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Need a way to plot what the predictions are too..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dubpredsfsame, dubpredsasame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(range(1,len(diffgamma)+1),diffgamma[:,0],marker='+',color='k',alpha=0.5); plt.scatter(range(1,len(diffgamma)+1),diffgamma[:,1],marker='+',color='k',label='True values'); #plt.yscale('symlog')\n",
    "plt.scatter(range(1,len(diffgamma)+1),sinpreds[:,0],color='deepskyblue',alpha=0.6,label='Predicted value (freq only)'); \n",
    "plt.scatter(range(1,len(diffgamma)+1),sinpreds[:,1],color='coral',alpha=0.6,label='Predicted value (freq & age)'); \n",
    "plt.plot([range(1,len(diffgamma)+1),range(1,len(diffgamma)+1)],[diffgamma[:,0],diffgamma[:,1]],color='k',alpha=0.4,linewidth=3); \n",
    "plt.legend(); plt.xlabel('replicate data set'); plt.ylabel(r'$\\gamma_{1,2}$'); plt.grid(); plt.xticks(ticks=range(1,22))\n",
    "# plt.savefig(\"../figs/twoparam1pred.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.hist(newdf1['al'].iloc[:1500],np.logspace(0,3)); plt.hist(newdf1['al'].iloc[1500:],np.logspace(0,3),alpha=0.5)\n",
    "# np.reshape(list(it.combinations(gamma[1::3], 2)), (-1,2))\n",
    "plt.scatter(diffgamma[:,0], diffgamma[:,1], marker='+', color='k', alpha=0.8, label='True values'); plt.yscale('symlog'); plt.xscale('symlog'); plt.grid()\n",
    "plt.scatter(np.unique(diffgamma), np.unique(diffgamma), marker='+', color='k', alpha=0.8); \n",
    "frmse = np.sqrt(np.mean(np.sum((dubpreds[:,0]-diffgamma[:,0])**2+(dubpreds[:,1]-diffgamma[:,1])**2)))#+np.mean(np.sum((dubpredsfsame[:,0]-np.unique(diffgamma))**2+(dubpredsfsame[:,1]-np.unique(diffgamma))**2)))\n",
    "plt.scatter(dubpreds[:,0], dubpreds[:,1], color='deepskyblue', alpha=0.4, label='Predicted values (freq only), RMSE: {:.0f}'.format(frmse)); \n",
    "# plt.scatter(dubpredsfsame[:,0], dubpredsfsame[:,1], color='deepskyblue', alpha=0.4); plt.scatter(dubpredsasame[:,0], dubpredsasame[:,1], color='coral', alpha=0.4);\n",
    "armse = np.sqrt(np.mean(np.sum((dubpreds[:,2]-diffgamma[:,0])**2+(dubpreds[:,3]-diffgamma[:,1])**2))+np.mean(np.sum((dubpredsasame[:,0]-np.unique(diffgamma))**2+(dubpredsasame[:,1]-np.unique(diffgamma))**2)))\n",
    "plt.scatter(dubpreds[:,2], dubpreds[:,3], color='coral', alpha=0.4, label='Predicted values (freq & age), RMSE: {:.0f}'.format(armse))\n",
    "plt.plot([diffgamma[:,0],dubpreds[:,0]],[diffgamma[:,1],dubpreds[:,1]],color='deepskyblue',alpha=0.4); plt.xlabel(r'$\\gamma_1$'); plt.ylabel(r'$\\gamma_2$')\n",
    "# plt.plot([diffgamma[:,0],dubpreds[:,2]],[diffgamma[:,1],dubpreds[:,3]],color='coral',alpha=0.4); plt.legend()\n",
    "# plt.plot([np.unique(diffgamma),dubpredsfsame[:,0]],[np.unique(diffgamma),dubpredsfsame[:,1]],color='deepskyblue',alpha=0.4)\n",
    "# plt.plot([np.unique(diffgamma),dubpredsasame[:,0]],[np.unique(diffgamma),dubpredsasame[:,1]],color='coral',alpha=0.4)\n",
    "plt.savefig(\"../figs/twoparampreds.pdf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==s[5])),:].append(df1.iloc[np.ravel(np.where(dat[:,1]==s[4])),:])\n",
    "# newdat = newdf1.to_numpy()\n",
    "# print(resample_calculateprob_freq(newdat, gamma2, num_sims=16, num_samps=1200, cutoff=2))\n",
    "# print(resample_calculateprob_age(newdat, gamma2, num_sims=16, num_samps=1200, cutoff=2))\n",
    "newnewdat = newdat[np.random.choice(newdat.shape[0], 1200, replace=False),:]\n",
    "for ig, g in enumerate(gamma2):\n",
    "    # sum log prob for each locus\n",
    "    sin_onlyage[ig] = np.sum(get_lp_alxl(g, newnewdat[:,5], newnewdat[:,2], cutoff=cutoff))\n",
    "    for ig2, g2 in enumerate(gamma2[0:(ig+1)]):\n",
    "        dub_onlyage[ig, ig2] = np.sum(np.log(0.5*np.exp(get_lp_alxl(g, newnewdat[:,5], newnewdat[:,2], cutoff=cutoff)) + 0.5*np.exp(get_lp_alxl(g2, newnewdat[:,5], newnewdat[:,2], cutoff=cutoff))))\n",
    "\n",
    "print(gamma[np.argmax(sin_onlyage)])\n",
    "print(np.take(gamma, np.unravel_index(np.argmax(np.ma.masked_array(dub_onlyage, mask)),dub_onlyage.shape)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diffgamma = np.reshape(list(it.combinations(s, 2)), (-1,2)) # np.reshape([(-1., x) for x in gamma[:-1][::2]], (-1,2)) #\n",
    "diffprobs = np.zeros((len(diffgamma),2))\n",
    "sinpreds = np.zeros((len(diffgamma),2))\n",
    "dubpreds = np.zeros((len(diffgamma),4))\n",
    "for ig, g in enumerate(diffgamma):\n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g[0])),:].append(df1.iloc[np.ravel(np.where(dat[:,1]==g[1])),:])\n",
    "    # newdf1 = newdf1.sample(frac=1)\n",
    "    newdat = newdf1.to_numpy()\n",
    "    diffprobs[ig,0], sinpreds[ig,0], dubpreds[ig,:2] = resample_calculateprob_freq(newdat, gamma2, num_sims=20, num_samps=5000, cutoff=2)\n",
    "    diffprobs[ig,1], sinpreds[ig,1], dubpreds[ig,-2:] = resample_calculateprob_age(newdat, gamma2, num_sims=20, num_samps=5000, cutoff=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter([np.abs(g[1]-g[0]) for g in diffgamma], diffprobs[:,0], color='deepskyblue', alpha=0.7, label='only freq') #s=truenumlocifreq[:-1]/(truenumlocifreq[:-1]+truenumlocifreq[-1])*70.)\n",
    "plt.scatter([np.abs(g[1]-g[0]) for g in diffgamma], diffprobs[:,1], color='coral', alpha=0.7, label='freq & age')\n",
    "ginterp = np.logspace(0,4.5,base=np.exp(1),num=25)\n",
    "fit = sp.interpolate.interp1d([np.abs(g[1]-g[0]) for g in diffgamma], diffprobs[:,0], kind='linear')\n",
    "plt.plot(ginterp, fit(ginterp), '--', color='deepskyblue', alpha=0.7)\n",
    "fit = sp.interpolate.interp1d([np.abs(g[1]-g[0]) for g in diffgamma], diffprobs[:,1], kind='linear')\n",
    "plt.plot(ginterp, fit(ginterp), '--', color='coral', alpha=0.7)\n",
    "plt.ylim((-0.1,1.1)); plt.xscale('log'); plt.xlabel('log(|γ1-γ2|)'); plt.ylabel('prob of choosing complex model'); plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "## alternative plotting mechanism to highlight the power in discriminating between gamma values\n",
    "powermat_freq = np.zeros((len(np.unique(diffgamma)),len(np.unique(diffgamma))))\n",
    "powermat_age = np.zeros((len(np.unique(diffgamma)),len(np.unique(diffgamma))))\n",
    "# powermat_freq = np.ones((7,7)); powermat_age = np.ones((7,7))\n",
    "# np.fill_diagonal(powermat_freq,0); np.fill_diagonal(powermat_age,0)\n",
    "mask_pow = np.full(powermat_freq.shape,False)\n",
    "mask_pow[np.tril_indices_from(powermat_freq,k=-1)] = True\n",
    "\n",
    "for ig, g in enumerate(diffgamma): ## need to use a np.sum(diffprobsf[::-1][ig, :])/15 if reading powermat!!??\n",
    "    powermat_freq[np.argmax(g[0]==np.unique(diffgamma)), np.argmax(g[1]==np.unique(diffgamma))] = np.sum(diffprobsf[ig, :])/15\n",
    "    powermat_age[np.argmax(g[0]==np.unique(diffgamma)), np.argmax(g[1]==np.unique(diffgamma))] = np.sum(diffprobsa[ig, :])/15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# powermat = np.loadtxt('resfiles/powermat_t1000.txt')\n",
    "powermat_freq = powermat[:7,:]; powermat_age = powermat[7:,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1320x660 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 770x440 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# np.hstack((diffgamma, dubpreds))\n",
    "# np.argmax(diffgamma[0][1]==np.unique(diffgamma))\n",
    "plt.figure(figsize=(12,6))\n",
    "plt.style.use('seaborn-paper')\n",
    "plt.rcParams['axes.grid'] = False\n",
    "fig, (ax1, ax2, ax3) = plt.subplots(1,3,figsize=(7,4),gridspec_kw={'width_ratios':[1,1.,1.0]})\n",
    "seaborn.heatmap(powermat_freq.T, mask=mask_pow, xticklabels=[-100,-50,-20,-10,-5,-2,-1], yticklabels=[-100,-50,-20,-10,-5,-2,-1], cmap='GnBu', ax=ax1, cbar=False, linewidths=0.05, square=True,alpha=0.8,vmin=0,); #ax1.set_ylabel(r'$\\gamma_1$'); \n",
    "ax1.set_title('freq only',fontsize=12); ax2.set_title('freq & age',fontsize=12); ax3.set_title('increase in power',fontsize=12)\n",
    "im = seaborn.heatmap(powermat_age.T, mask=mask_pow, xticklabels=[-100,-50,-20,-10,-5,-2,-1], yticklabels=[], cmap='GnBu', square=True, ax=ax2, linewidths=0.05, vmin=0, cbar=False,alpha=0.8)\n",
    "seaborn.heatmap(powermat_age.T-powermat_freq.T, mask=mask_pow, xticklabels=[-100,-50,-20,-10,-5,-2,-1], yticklabels=[], cmap='GnBu', vmax=0.8, square=True, ax=ax3, linewidths=0.05, vmin=-0, cbar=False,alpha=0.8)\n",
    "plt.colorbar(im.get_children()[0], ax = [ax1,ax2,ax3],orientation = 'horizontal',shrink=0.6,label='prob. of choosing two parameter model',)\n",
    "plt.savefig('../figs/twoparamdifft1000.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "truenumloci = np.zeros(len(gamma))\n",
    "for ig, g in enumerate(gamma):\n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g)),:]\n",
    "    sXlred = newdf1['sXl']\n",
    "    truenumloci[ig] = np.sum((sXlred>10) & (sXlred<n-10+1))\n",
    "\n",
    "truenumlocifreq = np.zeros(len(gamma))\n",
    "for ig, g in enumerate(gamma):\n",
    "    newdf1 = df1.iloc[np.ravel(np.where(dat[:,1]==g)),0:3]\n",
    "    truenumlocifreq[ig] = newdf1.to_numpy().shape[0]\n",
    "\n",
    "truenumloci"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automating workflow for simulating point DFE from PReFerSim (instead of using the R approach from before)\n",
    "\n",
    "Here, I will write a python function to run the program with appropriate parameters and read the input into a dataframe after."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'os' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m/Users/vivaswatshastry/selCoefEst/mom-framework.ipynb Cell 155\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/vivaswatshastry/selCoefEst/mom-framework.ipynb#Y310sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m os\u001b[39m.\u001b[39mchdir(\u001b[39m\"\u001b[39m\u001b[39m/Users/vivaswatshastry/selCoefEst/PReFerSims\u001b[39m\u001b[39m\"\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'os' is not defined"
     ]
    }
   ],
   "source": [
    "os.chdir(\"/Users/vivaswatshastry/selCoefEst/PReFerSims\")\n",
    "## creating a small set of gamma for simulating data (testing framework) \n",
    "## gamma = 4Ns (if it has to coincide with the moments framework)\n",
    "# gamma = -np.round(np.logspace(0,2,20),2) \n",
    "# s = -np.array([1.,5.,10.,50.,100.,500.])\n",
    "# for ig, g in enumerate(gamma[1:]):\n",
    "#     with open('simfiles/ParameterFilesConstant.txt',\"r\") as file:\n",
    "#         data = file.readlines()\n",
    "\n",
    "#     data[2] = 'DFEPointSelectionCoefficient: {:f}\\n'.format(-0.25*g/10000)\n",
    "#     data[7] = 'FilePrefix: outfiles/ConstantSize{}\\n'.format(-g)\n",
    "\n",
    "#     with open('simfiles/ParameterFilesConstant.txt', 'w') as file:\n",
    "#         file.writelines(data)\n",
    "        \n",
    "#     os.system(\"GSL_RNG_SEED={} GSL_RNG_TYPE=mrg ../../PReFerSim/PReFerSim simfiles/ParameterFilesConstant.txt 2\".format(rng.integers(100496)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## reading in the data and storing in a data frame\n",
    "nsites = 2000\n",
    "# gamma = np.array([0, -0.01, -.1, -1, -10, -100])\n",
    "df1 = pd.DataFrame(index=range(nsites*len(gamma)),columns=['','Xl','s','al','id'])\n",
    "for ig, g in enumerate(gamma):\n",
    "    # if(g==-100.):\n",
    "    #     df1.iloc[(ig*nsites):(ig+1)*nsites] = pd.read_csv('outfiles/ConstantSize50.0.1.full_out.txt'.format(-g),sep='\\t',header=None).sample(n=nsites)\n",
    "    # elif(g==-1.):\n",
    "    #     df1.iloc[(ig*nsites):(ig+1)*nsites] = pd.read_csv('outfiles/ConstantSize2.0.1.full_out.txt'.format(-g),sep='\\t',header=None).sample(n=nsites)\n",
    "    # else:\n",
    "    if g!=0:\n",
    "        df1.iloc[(ig*nsites):(ig+1)*nsites] = pd.read_csv('outfiles/ConstantSize{}.2.full_out.txt'.format(-g),sep='\\t',header=None).sample(n=nsites)\n",
    "    else:\n",
    "        df1.iloc[(ig*nsites):(ig+1)*nsites] = pd.read_csv('outfiles/ConstantSize{}.2.full_out.txt'.format(g),sep='\\t',header=None).sample(n=nsites)\n",
    "    df1['s'].iloc[(ig*nsites):(ig+1)*nsites] = np.repeat(g,nsites)\n",
    "df1['empty'] = ''\n",
    "df1['sXl'] = (df1['Xl']*2000).astype('int')\n",
    "df1['al'] = 80000+1 - df1['al']\n",
    "df1['al'] = df1['al'].astype('int')\n",
    "df1 = df1.iloc[:,1:]\n",
    "dat = df1.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(df1)):\n",
    "    if(df1['al'][i]<0):\n",
    "        df1.iloc[i,2] = df1.iloc[i,2] + 20000\n",
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# [0.5,1,2,5,10,20,50,100,200,500]\n",
    "# np.concatenate((-np.arange(1,5),-np.round(np.logspace(-1,10,25,base=2,),1)))\n",
    "# gamma = -np.logspace(-0.2,3,25,base=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MutationRate: 1000\n",
    "# DFEType: point\n",
    "# DFEPointSelectionCoefficient: 0.005\n",
    "# DemographicHistory: simfiles/ConstantSize.txt \n",
    "# n: 2000\n",
    "# PrintSegSiteInfo: 1\n",
    "# LastGenerationAFSamplingValue: 1\n",
    "# FilePrefix: outfiles/ConstantSize"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "37dbdfb015eb2911072604397bc3ab5127f1ef4d866242904832becb363c8f9b"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}