DataProc.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"/Volumes/SLOT256/COVID-19/\""
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using CSV\n",
    "using DataFrames\n",
    "using DSP\n",
    "using FileIO\n",
    "using GZip\n",
    "using JLD2\n",
    "using KernelDensity\n",
    "using LinearAlgebra\n",
    "using NPZ\n",
    "using ProgressMeter\n",
    "using PyPlot\n",
    "using Random\n",
    "using Statistics\n",
    "using SparseArrays\n",
    "\n",
    "base_path = \"/Volumes/SLOT256/COVID-19/\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "compress_households (generic function with 1 method)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function load_population(path::AbstractString)\n",
    "    ages = Vector{UInt8}()\n",
    "    genders = BitVector()\n",
    "    household_ids = Vector{UInt32}()\n",
    "    GZip.open(path, \"r\") do io\n",
    "        for row in CSV.Rows(io)\n",
    "            push!(ages, parse(Float64, row.age))\n",
    "            push!(genders, parse(Bool, row.gender))\n",
    "            push!(household_ids, parse(UInt32, row.household_id))\n",
    "        end\n",
    "    end\n",
    "    ages, genders, household_ids\n",
    "end\n",
    "\n",
    "function compress_households(households::SparseMatrixCSC{T, Ti}) where {T<:Real, Ti<:Integer}\n",
    "    num_ages, num_households = size(households)\n",
    "    @assert num_ages < num_households\n",
    "    \n",
    "    household2count = Dict{SparseVector{UInt8, Ti}, UInt32}()\n",
    "    sizehint!(household2count, num_households)\n",
    "    \n",
    "    @showprogress for i in 1:num_households\n",
    "        vec = households[:,i]\n",
    "        count = get(household2count, vec, 0)\n",
    "        household2count[vec] = count +1\n",
    "    end\n",
    "    \n",
    "    empty_household = spzeros(T, num_ages)\n",
    "    if(haskey(household2count, empty_household))\n",
    "        delete!(household2count, empty_household)\n",
    "    end\n",
    "    \n",
    "    I = Vector{Ti}()\n",
    "    J = Vector{Ti}()\n",
    "    V = Vector{T}()\n",
    "    C = Vector{UInt32}()\n",
    "    @showprogress for (i,(k,v)) in enumerate(household2count)    \n",
    "        is, vs = findnz(k)\n",
    "        append!(I, is)\n",
    "        append!(J, ones(UInt32, length(is))*i)\n",
    "        append!(V, vs)\n",
    "        push!(C, v)\n",
    "    end\n",
    "    \n",
    "    C, sparse(I,J,V) |> SparseMatrixCSC{T, UInt32}\n",
    "end\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:00\u001b[39m\n",
      "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:00\u001b[39m\n"
     ]
    }
   ],
   "source": [
    "population_path = \"data/wroclaw-population.csv.gz\"\n",
    "\n",
    "individual_age_wro, individual_gender_wro, individual_hh_id_wro = load_population(population_path)\n",
    "population_wro = DataFrame(\n",
    "    age=individual_age_wro,\n",
    "    gender=individual_gender_wro, \n",
    "    household_ids=individual_hh_id_wro)\n",
    "\n",
    "households_wro_all = sparse(population_wro.age.+1, population_wro.household_ids.+1, 1)\n",
    "\n",
    "\n",
    "household_wro_count, households_wro = households_wro_all |> SparseMatrixCSC{UInt8,UInt32} |> compress_households\n",
    "\n",
    "save(\"data/wroclaw-population.jld2\", \n",
    "    \"household_count\", household_wro_count, \n",
    "    \"households\", households_wro, \n",
    "    \"households_all\", households_wro_all,\n",
    "    compress=true)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:49\u001b[39m\n",
      "\u001b[32mProgress: 100%|█████████████████████████████████████████| Time: 0:00:08\u001b[39m\n"
     ]
    }
   ],
   "source": [
    "population_path = \"data/poland-population.csv.gz\"\n",
    "\n",
    "individual_age_pol, individual_gender_pol, individual_hh_id_pol = load_population(population_path)\n",
    "population_pol = DataFrame(\n",
    "    age=individual_age_pol,\n",
    "    gender=individual_gender_pol, \n",
    "    household_ids=individual_hh_id_pol)\n",
    "\n",
    "households_pol_all = sparse(population_pol.age.+1, population_pol.household_ids.+1, 1)\n",
    "\n",
    "\n",
    "household_pol_count, households_pol = households_pol_all |> SparseMatrixCSC{UInt8,UInt32} |> compress_households\n",
    "\n",
    "save(\"data/poland-population.jld2\", \n",
    "    \"household_count\", household_pol_count, \n",
    "    \"households\", households_pol, \n",
    "    \"households_all\", households_pol_all,\n",
    "    compress=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: individual_age not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: individual_age not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[5]:2"
     ]
    }
   ],
   "source": [
    "figure(figsize=(10,5))\n",
    "hist(individual_age, bins=0:100)\n",
    "xlabel(\"age\")\n",
    "ylabel(\"count\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 1000x500 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "([94629.0, 80612.0, 54403.0, 32402.0, 8472.0, 4766.0, 2383.0, 0.0, 0.0, 0.0], [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5], PyCall.PyObject[PyObject <matplotlib.patches.Rectangle object at 0x151569320>, PyObject <matplotlib.patches.Rectangle object at 0x151569128>, PyObject <matplotlib.patches.Rectangle object at 0x151569978>, PyObject <matplotlib.patches.Rectangle object at 0x151569cc0>, PyObject <matplotlib.patches.Rectangle object at 0x151569fd0>, PyObject <matplotlib.patches.Rectangle object at 0x15157c390>, PyObject <matplotlib.patches.Rectangle object at 0x15157c6d8>, PyObject <matplotlib.patches.Rectangle object at 0x15157ca20>, PyObject <matplotlib.patches.Rectangle object at 0x15157cd68>, PyObject <matplotlib.patches.Rectangle object at 0x15157ce80>])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "figure(figsize=(10,5))\n",
    "hist( sum(households_wro_all, dims=1)', bins=0.5:10.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 1000x500 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "([3.91038e6, 3.910099e6, 2.874404e6, 2.105065e6, 954456.0, 412812.0, 143911.0, 44004.0, 15604.0, 7205.0], [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5], PyCall.PyObject[PyObject <matplotlib.patches.Rectangle object at 0x158372080>, PyObject <matplotlib.patches.Rectangle object at 0x158369e48>, PyObject <matplotlib.patches.Rectangle object at 0x158372668>, PyObject <matplotlib.patches.Rectangle object at 0x1583729b0>, PyObject <matplotlib.patches.Rectangle object at 0x158372cf8>, PyObject <matplotlib.patches.Rectangle object at 0x158372e10>, PyObject <matplotlib.patches.Rectangle object at 0x15837c3c8>, PyObject <matplotlib.patches.Rectangle object at 0x15837c710>, PyObject <matplotlib.patches.Rectangle object at 0x15837ca58>, PyObject <matplotlib.patches.Rectangle object at 0x15837cda0>])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "figure(figsize=(10,5))\n",
    "hist( sum(households_pol_all, dims=1)', bins=0.5:10.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"/Volumes/SLOT256/COVID-19/severity.csv\""
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function make_severity_df()::DataFrame\n",
    "    arr = [\n",
    "    0.004081632653061225, 0.006270210077735186, 0.8454333254812944, 0.1442148317879093,\n",
    "    0.004081632653061225, 0.006270210077735186, 0.8454333254812944, 0.1442148317879093,\n",
    "    0.00816326530612245, 0.006244512495449387, 0.8419684348030924, 0.1436237873953359,\n",
    "    0.026530612244897958, 0.006128873375163287, 0.8263764267511833, 0.14096408762875562,\n",
    "    0.07346938775510203, 0.005833351178876588, 0.78653018395186, 0.13416707711416154,\n",
    "    0.163265306122449, 0.005268004368588989, 0.7103025890314154, 0.12116410047754676,\n",
    "    0.3020408163265306, 0.00439428657087179, 0.5924963059725464, 0.10106859113005119,]\n",
    "\n",
    "    arr = collect(reshape(arr, 4,7)')\n",
    "\n",
    "    arr = vcat(\n",
    "        repeat(arr[1,:]', 21),\n",
    "        repeat(arr[2,:]', 20),\n",
    "        repeat(arr[3,:]', 10),\n",
    "        repeat(arr[4,:]', 10),\n",
    "        repeat(arr[5,:]', 10),\n",
    "        repeat(arr[6,:]', 10),\n",
    "        repeat(arr[7,:]', 20)\n",
    "        )\n",
    "\n",
    "    DataFrame(\n",
    "        age=0:100, \n",
    "        critical=arr[:,1], \n",
    "        asymptomatic=arr[:,2], \n",
    "        mild=arr[:,3],\n",
    "        severe=arr[:,4]\n",
    "    )\n",
    "end\n",
    "severity = make_severity_df()\n",
    "CSV.write(base_path * \"severity.csv\", severity)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: countuniquesorted not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: countuniquesorted not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[9]:2"
     ]
    }
   ],
   "source": [
    "t0_dist = npzread(base_path * \"incubation_period_distribution.npy\")\n",
    "t0, t0_counts = countuniquesorted(t0_dist)\n",
    "t0_prob = t0_counts // sum(t0_counts)\n",
    "plot(t0, t0_prob)\n",
    "xlabel(\"time\")\n",
    "ylabel(\"probability\")\n",
    "xlim(left=0)\n",
    "ylim(bottom=0)\n",
    "\n",
    "CSV.write(base_path*\"t0_dist.csv\", DataFrame(t=t0, counts=t0_counts, prob=Float32.(t0_prob)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: countuniquesorted not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: countuniquesorted not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[10]:2"
     ]
    }
   ],
   "source": [
    "t1_dist = npzread(base_path*\"t1_distribution.npy\")\n",
    "t1, t1_counts = countuniquesorted(t1_dist)\n",
    "t1_prob = t1_counts // sum(t1_counts)\n",
    "plot(t1, t1_prob)\n",
    "xlabel(\"time\")\n",
    "ylabel(\"probability\")\n",
    "xlim(left=0)\n",
    "ylim(bottom=0)\n",
    "\n",
    "CSV.write(base_path*\"t1_dist.csv\", DataFrame(t=t1, counts=t1_counts, prob=Float32.(t1_prob)))\n",
    "dot(t1, t1_counts./sum(t1_counts)) |> display\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: countuniquesorted not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: countuniquesorted not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[11]:2"
     ]
    }
   ],
   "source": [
    "t2_dist = npzread(base_path * \"t1_t2_distribution.npy\")\n",
    "t2, t2_counts = countuniquesorted(t2_dist)\n",
    "t2_prob = t2_counts // sum(t2_counts)\n",
    "plot(t2, t2_prob)\n",
    "xlabel(\"time\")\n",
    "ylabel(\"probability\")\n",
    "xlim(left=0)\n",
    "ylim(bottom=0)\n",
    "CSV.write(base_path*\"t2_dist.csv\", DataFrame(t=t2, counts=t2_counts, prob=Float32.(t2_prob)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: t0_prob not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: t0_prob not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[12]:1"
     ]
    }
   ],
   "source": [
    "t01_prob = DSP.conv(t0_prob, t1_prob)\n",
    "t01 = (minimum(t0)+minimum(t1)):(maximum(t0)+maximum(t1))\n",
    "plot(t01, t01_prob)\n",
    "sum(t01_prob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: t0_prob not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: t0_prob not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[13]:1"
     ]
    }
   ],
   "source": [
    "length(t0_prob), length(t2_prob)\n",
    "t02_prob = DSP.conv(t0_prob, t2_prob)\n",
    "t2\n",
    "#length(t0),length(t2)\n",
    "#t02 = (minimum(t0)+minimum(t2)):(maximum(t0)+maximum(t2))\n",
    "#plot(t02, t02_prob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "make_dist (generic function with 1 method)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function make_dist(\n",
    "        samples::AbstractArray{T} where T<:Real, \n",
    "        times::AbstractVector{T} where T<:Real; bandwidth::Real=0.5)\n",
    "    dist = kde(vec(samples), bandwidth=bandwidth)\n",
    "    p = pdf(dist, times)\n",
    "    p./sum(p)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "make_sum_dist (generic function with 1 method)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function make_sum_dist(samples1, samples2, times; bandwidth=0.5)\n",
    "    samples = (vec(samples1) .+ vec(samples2)')[:]\n",
    "    dist = kde(samples, bandwidth=0.5)\n",
    "    p = pdf(dist, times)\n",
    "    p./sum(p)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\"/Volumes/SLOT256/COVID-19/t01_dist\""
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t01 = 0:0.1:30\n",
    "t01_prob = make_dist(t0_dist.+t1_dist', t01, bandwidth=0.5)\n",
    "plot(t01,t01_prob)\n",
    "xlim(left=0)\n",
    "ylim(bottom=0)\n",
    "xlabel(\"time\")\n",
    "ylabel(\"pmf\")\n",
    "CSV.write(base_path*\"t01_dist\", DataFrame(t=t01, prob=t01_prob))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\"/Volumes/SLOT256/COVID-19/t02_dist\""
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t02 = 0:0.1:30\n",
    "t02_prob = make_dist(t0_dist.+t2_dist', t02, bandwidth=0.5)\n",
    "plot(t02,t02_prob)\n",
    "xlim(left=0)\n",
    "ylim(bottom=0)\n",
    "xlabel(\"time\")\n",
    "ylabel(\"pmf\")\n",
    "CSV.write(base_path*\"t02_dist\", DataFrame(t=t02, prob=t02_prob))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"mean is 5.704969121639186\""
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tc = 0:0.1:30\n",
    "\n",
    "tc_prob = make_dist(t0_dist'.+min.(t1_dist, t2_dist')[:], tc, bandwidth=0.5)\n",
    "plot(tc, tc_prob)\n",
    "xlim(left=0)\n",
    "ylim(bottom=0)\n",
    "xlabel(\"time\")\n",
    "ylabel(\"pmf\")\n",
    "CSV.write(base_path*\"tc_dist.csv\", DataFrame(t=tc, prob=tc_prob))\n",
    "display(\"mean is $(dot(tc, tc_prob))\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "\"/Volumes/SLOT256/COVID-19/t0q_dist\""
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t0q = 0:0.01:30\n",
    "t0q_prob = make_sum_dist(t0_dist, [14], t0q, bandwidth=0.1)\n",
    "plot(t0q,t0q_prob)\n",
    "xlim(left=0)\n",
    "ylim(bottom=0)\n",
    "xlabel(\"time\")\n",
    "ylabel(\"pmf\")\n",
    "CSV.write(base_path*\"t0q_dist\", DataFrame(t=t0q, prob=t0q_prob))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(UInt8[0x07, 0x2f, 0x16, 0x03, 0x03, 0x52, 0x3a, 0x26, 0x41, 0x3e  …  0x55, 0x29, 0x27, 0x2b, 0x23, 0x42, 0x39, 0x36, 0x2b, 0x45], Bool[0, 1, 0, 0, 0, 0, 1, 1, 1, 0  …  0, 0, 1, 1, 1, 0, 0, 0, 0, 1], Int32[1, 1, 1, 2, 2, 2, 2, 2, 2, 3  …  14377934, 14377935, 14377935, 14377936, 14377936, 14377937, 14377938, 14377939, 14377939, 14377940])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population_path = base_path *\"aggregated_population.csv\"\n",
    "function load_population(path::AbstractString)\n",
    "    ages = Vector{UInt8}()\n",
    "    genders = BitVector()\n",
    "    household_ids = Vector{Int32}()\n",
    "    for row in CSV.Rows(path)\n",
    "        push!(ages, parse(Float64, row.age))\n",
    "        push!(genders, parse(Bool, row.gender))\n",
    "        push!(household_ids, parse(Int32, row.household_index))\n",
    "    end\n",
    "    ages, genders, household_ids\n",
    "end\n",
    "individual_age, individual_gender, individual_hh_id = load_population(population_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0x00:0x55"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ages = minimum(individual_age):maximum(individual_age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: households not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: households not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[22]:1"
     ]
    }
   ],
   "source": [
    "num_ages, num_households = size(households)\n",
    "num_hh_sizes = 10 # \n",
    "hh_size = sum(households, dims=1)\n",
    "is_singular = hh_size .<= 1\n",
    "is_nonsingular"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: is_singular not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: is_singular not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[23]:1"
     ]
    }
   ],
   "source": [
    "!is_singular"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "UndefVarError",
     "evalue": "UndefVarError: num_ages not defined",
     "output_type": "error",
     "traceback": [
      "UndefVarError: num_ages not defined",
      "",
      "Stacktrace:",
      " [1] top-level scope at In[24]:1"
     ]
    }
   ],
   "source": [
    "phi = ones(num_ages, num_hh_sizes)\n",
    "n = (0:100)' # horizontal vector\n",
    "t_inf = (0:10) .+ 0.25 # vertical vector\n",
    "\n",
    "for hh_size in 1:num_hh_sizes\n",
    "    for (i,age) in enumerate(ages)\n",
    "        exp.(-t_inf, )\n",
    "        #phi[i, hh_size] = \n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.3.1",
   "language": "julia",
   "name": "julia-1.3"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.3.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}