text:
"""
    Script to generate boxplot graphs associated with:
    - Experiment 1 (randV_randE.jl)
    - Experiment 2 (randV_propE05.jl)
"""
using Pkg
Pkg.activate(".")
using LTMSim
using SimpleHypergraphs
using PyPlot
using Serialization
using LaTeXStrings

project_path = dirname(pathof(LTMSim))

fname = "randV_propE05.data" #"randV_randE.data"
pname = "randV_propE05.png" #"randV_randE.png"
data_path = joinpath(project_path, "..", "res", "journal", fname)

hg_files = readdir(joinpath(project_path, "..", "data", "hgs"))
hg_names = [split(file, ".")[1] for file in hg_files]

hg_names[8] = "music-rev"
hg_names[10] = "rest.-rev"
hg_names[11] = "bars-rev"

#
# DATA
#
data = deserialize(data_path)
hgs = [prune_hypergraph!(hg_load(joinpath(project_path, "..", "data", "hgs", hg_file))) for hg_file in hg_files]

#
# PLOTTING INFO
#
algorithms = [
    "BinarySearch(H)", "Greedy([H]₂)", "Greedy(H)", "SubTSS(H)"
]

labels = Dict{String, String}(
    "BinarySearch(H)" => "StaticGreedy",
    "Greedy(H)" => "DynamicGreedy",
    "Greedy([H]₂)" => L"DynamicGreedy_{[H]_2}",
	"SubTSS(H)" => "SubTSS"
)

#
# BOXPLOTS
#
ticks = [1]

function set_box_color(bp, color)
    plt.setp(bp["boxes"], color=color)
    plt.setp(bp["whiskers"], color=color)
    plt.setp(bp["caps"], color=color)
    plt.setp(bp["medians"], color=color)
end

clf()
plt.figure(figsize=(20,8))

val = -0.7
c = 1
pos = 1.5

colorz=["#2C7BB6", "#D7191C", "#FF8900", "#33CC33", "#cc0099", "#4d4dff", "#008080", "#2C7BB6"]

for algo in algorithms
    global val, c

    println(algo)

    ndata = [elem / nhv(hgs[index]) for (index, elem) in enumerate(data[algo])]

    b = plt.boxplot(
        ndata,
        #positions=collect(range(0, stop=length(data[algo])-1)).*2.0.+val,
        positions=collect(range(0, stop=length(data[algo])-1)).*2.5.+val,
        #positions = [pos+val],
        sym="",
        widths=0.2
    )

    set_box_color(b, colorz[c])
    plt.plot([], c=colorz[c], label=labels[algo])

    c+=1
    val+=0.3
end

plt.legend(fontsize="20")

plt.xticks(range(0, (length(hg_names))*2.4, step=2.5), hg_names, fontsize="20", rotation=0)
plt.yticks(fontsize="xx-large")

title("randV - propE05", fontstyle = "italic", fontsize="xx-large")

plt.ylim(0, 0.7)
ylabel("Seed set size / n", fontstyle = "italic", fontsize="20", labelpad=10)

plt.tight_layout()
gcf()

PyPlot.savefig(joinpath(project_path, "..", "res", "journal", "plot", pname))

#
# some distribution data
#
amazon = hgs[2]
amazon_he_dist = [length(getvertices(amazon, he)) for he in 1:nhe(amazon)]
amazon_v_dist = [length(gethyperedges(amazon, v)) for v in 1:nhv(amazon)]

sum(amazon_v_dist[amazon_v_dist .== 1]) * 100 / length(amazon_v_dist)

clf()
hist(amazon_v_dist)
gcf()

dblp = hgs[3]
dblp_he_dist = [length(getvertices(dblp, he)) for he in 1:nhe(dblp)]
dblp_v_dist = [length(gethyperedges(dblp, v)) for v in 1:nhv(dblp)]

sum(dblp_v_dist[dblp_v_dist .== 1]) * 100 / length(dblp_v_dist)

clf()
hist(dblp_v_dist)
gcf()


text:
abstract type DASSLDAEAlgorithm <: DiffEqBase.AbstractDAEAlgorithm end
struct dassl <: DASSLDAEAlgorithm
  maxorder
  factorize_jacobian
end

dassl(;maxorder = 6,factorize_jacobian = true) = dassl(maxorder,factorize_jacobian)

function solve(
    prob::DiffEqBase.AbstractDAEProblem{uType,duType,tupType,isinplace},
    alg::DASSLDAEAlgorithm,args...;timeseries_errors=true,
    abstol=1e-5,reltol=1e-3,dt = 1e-4, dtmin = 0.0, dtmax = Inf,
    callback=nothing,kwargs...) where {uType,duType,tupType,isinplace}

    tType = eltype(tupType)

    if callback != nothing || :callback in keys(prob.kwargs)
        error("DASSL is not compatible with callbacks.")
    end

    tspan = [prob.tspan[1],prob.tspan[2]]

    #sizeu = size(prob.u0)
    #sizedu = size(prob.du0)
    p = prob.p

    ### Fix inplace functions to the non-inplace version
    if isinplace
      f = (t,u,du) -> (out = similar(u); prob.f(out,du,u,p,t); out)
    else
      f = (t,u) -> prob.f(u,p,t)
    end

    ### Finishing Routine

    ts,timeseries,dus = dasslSolve(f,prob.u0,tspan,
                                abstol=abstol,
                                reltol=reltol,
                                maxstep=dtmax,
                                minstep=dtmin,
                                initstep=dt,
                                dy0 = prob.du0,
                                maxorder=alg.maxorder,
                                factorize_jacobian=alg.factorize_jacobian)
    #=
    timeseries = Vector{uType}(0)
    if typeof(prob.u0)<:Number
        for i=1:length(ures)
            push!(timeseries,ures[i][1])
        end
    else
        for i=1:length(ures)
            push!(timeseries,reshape(ures[i],sizeu))
        end
    end
    =#
    DiffEqBase.build_solution(prob,alg,ts,timeseries,du=dus,
                      timeseries_errors = timeseries_errors)
end

ext: jl


text:
squared(x::Real) = x*x
squared(x::Vector) = x.*x
maxzero(x::Real) = max(x,zero(x))


text:
using Bijectors, Optim, Plots, Random, StatsFuns, Stheno, WarpedRegressors

using WarpedRegressors: InvBoxCox, affine

# Specify a Warped-GP.
f = GP(kernel(EQ(); l=0.5, s=3.0), GPC())
σ² = 0.01
ϕ = InvBoxCox(0.5)
g = warp(f, ϕ)

# Generate some training data.
rng = MersenneTwister(123456)
Ntr = 25
Nte = 200
x = 3 * randn(rng, Ntr + Nte)
xtr = x[1:Ntr]
xte = x[Ntr+1:end]
g_x = g(x, σ²)
y = rand(rng, g_x)
ytr = y[1:Ntr]
yte = y[Ntr+1:end]

# Specify parameter handler.
unpack(θ) = (
    σ² = log1pexp(θ[1]) + 1e-6,
    l  = log1pexp(θ[2]) + 1e-6,
    s  = log1pexp(θ[3]) + 1e-6,
    λ  = log1pexp(θ[4]) + 1e-6,
)

# Infer σ², l, and s.
function nlml(θ::AbstractVector{<:Real})
    θ = unpack(θ)
    f = GP(kernel(EQ(); l=θ.l, s=θ.s), GPC())
    ϕ = InvBoxCox(θ.λ)
    g = warp(f, ϕ)
    return -logpdf(g(xtr, θ.σ²), ytr)
end
θ0 = randn(4)
results = Optim.optimize(nlml, θ0, NelderMead())
θ = unpack(results.minimizer)

# Construct posterior Warped GP
f_learned = GP(kernel(EQ(); l=θ.l, s=θ.s), GPC())
g_learned = warp(f_learned, ϕ)
g_posterior = posterior(g_learned(xtr, θ.σ²), ytr)

# Visualise the posterior.
let
    xpr = range(-10.0, 10.0; length=400)
    Ypr = hcat([rand(rng, g_posterior(xpr, θ.σ²)) for _ in 1:5000]...)
    median_pr = map(ys->quantile(ys, 0.5), eachrow(Ypr));
    q95_pr = map(ys->quantile(ys, 0.95), eachrow(Ypr));
    q05_pr = map(ys->quantile(ys, 0.05), eachrow(Ypr));

    plotly()
    plt = plot()
    plot!(plt, xpr, Ypr[:, 1:10]; linecolor=:blue, linewidth=0.5, linealpha=0.2, label="")
    plot!(plt, xpr, median_pr; linecolor=:blue, linewidth=1.0, linealpha=1.0, label="")
    plot!(plt, xpr, [median_pr, median_pr];
        linewidth=0.0,
        fillrange=[q05_pr, q95_pr],
        fillalpha=0.3,
        fillcolor=:blue,
        label="",
    )
    scatter!(plt, xtr, ytr; label="", markersize=2, markercolor=:blue)
    scatter!(plt, xte, yte; label="", markersize=2, markercolor=:black)
    display(plt)
end


text:
############################################################
# Gaussian KL loss
#
# Given inputs mu and sigma, describing a diagonal covariance
# Gaussian distribution, the loss incurred is the
# Kullback-Leibler divergence from the input distribution
# to the standard Gaussian N(0,I).
############################################################

@defstruct GaussianKLLossLayer Layer (
    name :: AbstractString = "gauss-kl-loss",
    (weight :: AbstractFloat = 1.0, weight >= 0),
    (bottoms :: Vector{Symbol} = Symbol[:mu, :sigma], length(bottoms) == 2),
)

@characterize_layer(GaussianKLLossLayer,
    has_loss    => true,
    can_do_bp => true,
    is_sink     => true,
    has_stats => true,
)

type GaussianKLLossLayerState{T, B<:Blob} <: LayerState
    layer            :: GaussianKLLossLayer
    loss             :: T
    loss_accum :: T
    n_accum        :: Int

    tmp_blobs :: Dict{Symbol, B}
end

function setup(backend::CPUBackend, layer::GaussianKLLossLayer,
                        inputs::Vector{Blob}, diffs::Vector{Blob})
    data_type = eltype(inputs[1])
    state = GaussianKLLossLayerState(layer, zero(data_type), zero(data_type),
                                                0, Dict{Symbol, CPUBlob}())
    return state
end

function shutdown(backend::Backend, state::GaussianKLLossLayerState)
    for blob in values(state.tmp_blobs)
        destroy(blob)
    end
end

function reset_statistics(state::GaussianKLLossLayerState)
    state.n_accum = 0
    state.loss_accum = zero(typeof(state.loss_accum))
end

function dump_statistics(storage, state::GaussianKLLossLayerState, show::Bool)
    update_statistics(storage, "$(state.layer.name)-kl-loss", state.loss_accum)

    if show
        loss = @sprintf("%.4f", state.loss_accum)
        @info("    gaussian-kl-loss (avg over $(state.n_accum)) = $loss")
    end
end

function forward(backend::CPUBackend, state::GaussianKLLossLayerState,
                inputs::Vector{Blob})
    data_type = eltype(inputs[1])
    n = get_num(inputs[1])
    np = length(inputs[1])
    mu = inputs[1].data

    sigma = inputs[2].data

    state.loss = zero(data_type)
    for i in 1:np
        state.loss += mu[i]^2 + sigma[i]^2 - 2log(sigma[i]) - 1
    end
    state.loss *= 0.5 * state.layer.weight / n

    # accumulate statistics
    state.loss_accum *= state.n_accum
    state.loss_accum += state.loss * n
    state.loss_accum /= state.n_accum + n

    state.n_accum += n
end

function backward(backend::CPUBackend, state::GaussianKLLossLayerState,
                                inputs::Vector{Blob}, diffs::Vector{Blob})
    data_type = eltype(inputs[1])
    n = get_num(inputs[1])
    mu = inputs[1].data
    sigma = inputs[2].data

    if isa(diffs[1], CPUBlob)
        diffs[1].data[:] = mu * state.layer.weight / n
    end

    if isa(diffs[2], CPUBlob)
        diffs[2].data[:] = (sigma - (1 ./ sigma)) * state.layer.weight / n
    end
end


text:
@testset "Data Generation" begin
    function _is_well_conditioned(matrix)
        @test !isempty(matrix)
        @test isposdef(matrix)
        @assert length(matrix) ≤ 25
        @test cond(matrix) < 100
    end

    @testset "Generate Well Conditioned Matrix" begin
        rng = MersenneTwister(1)
        @testset "Pass in RNG" begin
            matrix = generate_well_conditioned_matrix(rng, 5)
            _is_well_conditioned(matrix)
            @testset "$T" for T in (Float64, ComplexF64)
                matrix = generate_well_conditioned_matrix(rng, T, 5)
                _is_well_conditioned(matrix)
            end
        end

        @testset "Global RNG" begin
            matrix = generate_well_conditioned_matrix(5)
            _is_well_conditioned(matrix)
            @testset "$T" for T in (Float64, ComplexF64)
                matrix = generate_well_conditioned_matrix(T, 5)
            end
        end
    end
end


text:
# Invertible CNN layer from Dinh et al. (2017)/Kingma & Dhariwal (2019)
# Author: Philipp Witte, pwitte3@gatech.edu
# Date: January 2020

using InvertibleNetworks, LinearAlgebra, Test, JOLI

# Input
nx = 64
ny = 64
n_in = 10
n_hidden = 20
batchsize = 2
X = glorot_uniform(nx, ny, n_in, batchsize)

# Observed data
nrec = 20
nt = 50
D = randn(Float32, nt*nrec, batchsize)

# Modeling/imaging operator (can be JOLI/JUDI operator or explicit matrix)
A = joMatrix(randn(Float32, nt*nrec, nx*ny))

# Link function
Ψ(η) = identity(η)

###################################################################################################
# Additive slim coupling layer (zero logdet)

# Create layer
L1 = AdditiveCouplingLayerSLIM(nx, ny, n_in, n_hidden, batchsize, Ψ; logdet=true, permute=false)

Y, logdet = L1.forward(X, D, A)
X_ = L1.inverse(Y, D, A)
@test iszero(logdet)
@test isapprox(norm(X - X_)/norm(X), 0f0; atol=1f-5)

ΔY = Y .* 0f0
X_ = L1.backward(ΔY, Y, D, A)[3]
@test isapprox(norm(X - X_)/norm(X), 0f0; atol=1f-5)

###################################################################################################
# Affine slim coupling layer (non-zero logdet)

# Create layer
L2 = AffineCouplingLayerSLIM(nx, ny, n_in, n_hidden, batchsize, Ψ; logdet=true, permute=false)

Y, logdet = L2.forward(X, D, A)
X_ = L2.inverse(Y, D, A)
@test ~iszero(logdet)
@test isapprox(norm(X - X_)/norm(X), 0f0; atol=1f-5)

ΔY = Y .* 0f0
X_ = L2.backward(ΔY, Y, D, A)[3]
@test isapprox(norm(X - X_)/norm(X), 0f0; atol=1f-5)


text:
#
# This file is part of the Actors.jl Julia package,
# MIT license, part of https://github.com/JuliaActors
#

using Actors
import Actors: spawn

greet(greeting, msg) = greeting*", "*msg*"!"

hello(greeter, to) = request(greeter, to)

greeter = spawn(Bhv(greet, "Hello"))

sayhello = spawn(Bhv(hello, greeter))

request(sayhello, "World")

request(sayhello, "Kermit")


text:
### A Pluto.jl notebook ###
# v0.15.1

using Markdown
using InteractiveUtils

# This Pluto notebook uses @bind for interactivity. When running this notebook outside of Pluto, the following 'mock version' of @bind gives bound variables a default value (instead of an error).
macro bind(def, element)
    quote
        local el = $(esc(element))
        global $(esc(def)) = Core.applicable(Base.get, el) ? Base.get(el) : missing
        el
    end
end

# ╔═╡ ef23d264-448e-11eb-10f8-ad25ae5f244d
begin
	using Plots
	using CSV
	using DataFrames
	using Dates
	using ImageFiltering
	using OffsetArrays
	using Statistics
	using PlutoUI
end

# ╔═╡ e2635196-448c-11eb-2877-c5735be35d80
md"""
## California COVID correlations

This notebook will take COVID case, hospitalization, and death data from California counties and attempt to find a lagged CFR in the style of Trevor Bedford's [analysis](https://twitter.com/trvrb/status/1326404889438801921).

The main idea is that a reasonably stable fraction of cases on a given day will die from COVID but that it takes some time for the disease to progress, so the death rate lags the case rate. Of course, we don't assume that we are identifying all the cases, so the lagged case-fatality-rate (CFR) here is not a real CFR. It is likely a big overestimate, but if it is relatively stable, it will allow us to forecast deaths 15+ days ahead of today.
"""

# ╔═╡ cdec3534-43f1-4726-af95-d82e32f3a0cb
begin
	state_case_data = CSV.read("covid19cases_test.csv", DataFrame)
	county_list = unique(state_case_data[!, :area])
	state_hosp_data = CSV.read("covid19hospitalbycounty.csv", DataFrame)
	county_list_2 = unique(state_hosp_data[!, :county])
	county_list = intersect(county_list, county_list_2)
end;

# ╔═╡ 9887d642-8387-477c-991c-4756bc137252
md"""
Using the dropdown, select the county to investigate. This analysis works best with big populations, so smaller counties may not work as well.
"""

# ╔═╡ 3ac6e767-2df5-4969-8582-11312228f534
md"""
## Data from $(@bind county_name Select(county_list, default="Santa Clara")) county

"""

# ╔═╡ 1d7590fd-8295-4964-b368-4629b1b3137c
begin
	offset = 3 #recent data is somewhat unreliable
	county_case_data  = filter(row -> row.area == county_name, state_case_data)
	county_case_dates = Date.(county_case_data[!, "date"][1:end-offset])
	county_cases = county_case_data[!, "cases"][1:end-offset]
	county_deaths = county_case_data[!, "deaths"][1:end-offset]
end;

# ╔═╡ 7a75c70f-e7d5-4505-8b6e-128e3a9c2e0b
begin
	county_hosp_data  = filter(row -> row.county == county_name, state_hosp_data)
	county_hosp_dates = Date.(county_hosp_data[!, "todays_date"])
	county_tot_patients= (county_hosp_data[!, "hospitalized_covid_confirmed_patients"] 							)#.+county_hosp_data[!, "hospitalized_suspected_covid_patients"])

	county_icu_cases = (county_hosp_data[!, "icu_covid_confirmed_patients"] 							.+county_hosp_data[!, "icu_suspected_covid_patients"])
	county_non_icu = county_tot_patients-county_icu_cases
end;

# ╔═╡ 8f0fce44-46ed-11eb-395c-b3072d1362e3
md"""
As one can see below, the case reporting data has artificial feautures due to a relative lack of reporting on Sundays. To correct for this, we'll take the 7-day average looking backwards.
"""

# ╔═╡ 9685d04e-4493-11eb-0db5-c35b82182d7f
begin
	StartDate = Date(2020,6,1);
	case_start_ind = findfirst(x -> x==StartDate, county_case_dates);
	hosp_start_ind = findfirst(x -> x==StartDate, county_hosp_dates);
end;

# ╔═╡ f7923db6-448f-11eb-0e94-e77b1a911cff
begin
	plot(county_case_dates[case_start_ind:end],
		county_cases[case_start_ind:end], label = "New Cases")
end

# ╔═╡ 2fac8934-4494-11eb-0219-7f1d44649362
kernel = OffsetArray(fill(1/7, 7), -3:3);

# ╔═╡ 110729c7-6d6e-4efc-939f-d945a6d5ee12
county_moving_avg = imfilter(county_cases[case_start_ind:end], kernel);

# ╔═╡ 257048ea-4495-11eb-0b21-f353c7997010
begin
	plotly()
	plot(county_case_dates[case_start_ind:end], county_moving_avg, label = "Avg. Cases", legend=:topleft)
	plot!(county_case_dates[case_start_ind:end],
		county_cases[case_start_ind:end], label = "New Cases")
end

# ╔═╡ 4efe6d30-4498-11eb-2e05-6924e9b3aa6a
begin
	county_avg_deaths = imfilter(county_deaths[case_start_ind:end],kernel)
	compMovingAvg = imfilter(county_cases[case_start_ind:end], kernel);
end;

# ╔═╡ 24d95b88-0521-49b6-9258-a96b10a8e541
md"""
## Comparing lagged cases with deaths
"""

# ╔═╡ f6f679d8-449a-11eb-1967-3da2b02ef0dc
@bind lag Slider(5:30, default=17, show_value=true)

# ╔═╡ 681f0498-449b-11eb-2dee-7dd6d54dfc4e
@bind lag_cfr Slider(0.001:0.001:0.03, default=0.018, show_value=true)

# ╔═╡ eed3fb32-46ed-11eb-13f6-0d79c4527fb0
md"""
Given the population of $(county_name) county, the average deaths are still fairly jagged because we still have small numbers. This death count in the county itself doesn't track the lagged case rate as well as people have seen using larger populations. Here I'm guessing we're seeing the inhomogeneity of COVID, e.g., cases counts could go up in low-risk populations and thus not see deaths rise until quite a bit later or conversely a small outbreak at a long-term care facility could lead to a lot of deaths.

Still the general trend is there, when cases rise sharply, deaths rise about $lag days later. The current fit predicts that for 100 new, identified cases, $(round((lag_cfr*100)*10)/10) people will die from COVID.
"""

# ╔═╡ 5b04aebe-4498-11eb-1309-93cbca18c737
begin
	plot(county_case_dates[case_start_ind:end]+Day(lag), lag_cfr*compMovingAvg[1:end],
		label = "Estimated deaths", legend=:topleft)
	plot!(county_case_dates[case_start_ind:end],
		county_avg_deaths, label = "County deaths")
end

# ╔═╡ a14162e8-46ee-11eb-3edb-8f55a7565c4b
md"""
Having made our rough fit, we can project deaths going foreward by taking recent case counts, multiplying by the lagged CFR and shifting forward in time. Below we see that by $(county_case_dates[end-5]+Day(lag)), there should be roughly $(round(lag_cfr*compMovingAvg[end-5])) deaths per day.

This prediction should be an overestimate given the presence of vaccines, but if the cases are concentrated in the unvaccinated, it might not be.
"""

# ╔═╡ 35eb6a82-449a-11eb-1f5e-ebe3e5fa4fb6
begin
	plotly()
	plot(county_case_dates[end-lag:end-5]+Day(lag),
		lag_cfr*compMovingAvg[end-lag:end-5],
		label = "Estimated deaths",
		legend=:topleft)
end

# ╔═╡ 291c556e-44b6-11eb-0666-df947594a060
md"""
## Comparing lagged cases to hospitalization
Now we're going to add in the number of hospitalized people. By similar arguments, a fraction of cases on a given day will eventually need hospital beds or potentially an ICU bed. We can also fit the averaged new case data to these figures as well.

Note, the adjustment factor here is not a simple hospitalization rate since people stay for multiple days in the ICU or hospital. If we knew the average time a COVID patient spends in the ICU or hospital, we could figure out the case/hospital bed or case/ICU ratio, but this would still have the issues from lack of testing and thus could not be used to predict how frequently a COVID infection requires hospital services.

Nevertheless, we can still use these correlation to predict future hospital need.
"""

# ╔═╡ ba472a38-46ef-11eb-21e6-97331ae5e715
md"""
Below, we see much better agreement between the scaled, lagged case numbers and the number of ICU patients.

However, somewhere in mid-December, just as ICUs began to approach capacity, we can see a clear change in the rate of people admitted. This may have arisen for many reasons, two of the most obvious would be only admitting the most severe cases to the ICU to reserve beds or an increase in cases from increased testing as people prepared for the holidays. The degree to which the deaths tracked cases during the same period could provide some evidence for the former vs. the latter.
"""

# ╔═╡ 3fd3dce4-44b8-11eb-0f23-93765a452257
@bind icu_lag Slider(1:20, default=15, show_value=true)

# ╔═╡ f8fffc76-44b7-11eb-3de5-9d2a8a97ca11
@bind icu_rate Slider(0.0:0.01:.3, default = 0.19, show_value=true)

# ╔═╡ 2a54ec88-44b7-11eb-196d-f7844a62e8f6
begin
	plotly()
	plot(county_hosp_dates[hosp_start_ind:end], county_icu_cases[hosp_start_ind:end], label = "ICU patients", legend=:topleft)
	plot!(county_case_dates[case_start_ind:end]+Day(icu_lag),
		icu_rate*compMovingAvg,
		label = "Scaled, lagged cases", legend=:topleft)
	#plot!(county_dates, county_icu_cases)
end

# ╔═╡ b5fb79f2-44bf-11eb-025b-ed9492e39ade
@bind hosp_lag Slider(1:20, default=13, show_value=true)

# ╔═╡ 30323758-44c0-11eb-0df3-1ddd46872b74
md"""
If we assume the average ICU patient spends 5 days there, we predict that ~$(round(icu_rate*100/5)) % of identified COVID cases need ICU beds.

We can also predict that on $(county_case_dates[end]+Day(hosp_lag)) there will be $(round(icu_rate*compMovingAvg[end])) ICU patients hospitalized with COVID19
"""

# ╔═╡ 03f58904-46f0-11eb-08bb-035012ae329d
md"""
### Non-ICU patients
We repeat the analysis with non-ICU COVID patients and see our best correlation yet. The lag is only $hosp_lag days, so our predictive powers are limited, however they show a clear indication that rising cases leads to rising COVID+ patients who are hospitalized.
"""

# ╔═╡ c0b2387c-44bf-11eb-31d1-3f403a6067f3
@bind hosp_rate Slider(0.0:0.01:.6, default = 0.47, show_value=true)

# ╔═╡ f37730a2-44b8-11eb-18d2-670aa5a0209e
begin
	plot(county_hosp_dates[hosp_start_ind:end],
		county_non_icu[hosp_start_ind:end], label= "Non-ICU Patients")
	plot!(county_case_dates[case_start_ind:end]+Day(hosp_lag),
		hosp_rate*compMovingAvg[1:end],
		label = "Scaled, lagged cases", legend=:topleft)

end

# ╔═╡ f3525c1c-44bf-11eb-0619-4f99561f4a6b
md"""
If we assume the average hospital stay is 5 days, each identified COVID case as a $(round(hosp_rate/5*100)) % chance of needing a hospital bed.
"""

# ╔═╡ ede8c6f0-51d8-11eb-2681-cb27cee40af5
md"""
Current prediction is that on $(county_case_dates[end]+Day(hosp_lag)) there will be $(round(hosp_rate*compMovingAvg[end])) non-ICU patients hospitalized with COVID19
"""

# ╔═╡ b79d0f23-c592-4e03-b9e9-dc61b3cedb6e
md"""
#### Import statements and helper code
"""

# ╔═╡ 2f74be36-44ae-11eb-278d-9db0cdf4a98b
begin
	state_cases_deaths_url = "https://data.chhs.ca.gov/dataset/f333528b-4d38-4814-bebb-12db1f10f535/resource/046cdd2b-31e5-4d34-9ed3-b48cdbc4be7a/download/covid19cases_test.csv"
	download(state_cases_deaths_url,  "covid19cases_test.csv")
	state_hosp_url = "https://data.chhs.ca.gov/dataset/2df3e19e-9ee4-42a6-a087-9761f82033f6/resource/47af979d-8685-4981-bced-96a6b79d3ed5/download/covid19hospitalbycounty.csv"
	download(state_hosp_url,  "covid19hospitalbycounty.csv")
end;

# ╔═╡ 00000000-0000-0000-0000-000000000001
PLUTO_PROJECT_TOML_CONTENTS = """
[deps]
CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
ImageFiltering = "6a3955dd-da59-5b1f-98d4-e7296123deb5"
OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
PlutoUI = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

[compat]
CSV = "~0.8.5"
DataFrames = "~1.2.0"
ImageFiltering = "~0.6.22"
OffsetArrays = "~1.10.2"
Plots = "~1.18.1"
PlutoUI = "~0.7.9"
"""

# ╔═╡ 00000000-0000-0000-0000-000000000002
PLUTO_MANIFEST_TOML_CONTENTS = """
# This file is machine-generated - editing it directly is not advised

[[AbstractFFTs]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "485ee0867925449198280d4af84bdb46a2a404d0"
uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c"
version = "1.0.1"

[[Adapt]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "84918055d15b3114ede17ac6a7182f68870c16f7"
uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
version = "3.3.1"

[[ArgTools]]
uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f"

[[Artifacts]]
uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33"

[[Base64]]
uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

[[Bzip2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c3598e525718abcc440f69cc6d5f60dda0a1b61e"
uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0"
version = "1.0.6+5"

[[CSV]]
deps = ["Dates", "Mmap", "Parsers", "PooledArrays", "SentinelArrays", "Tables", "Unicode"]
git-tree-sha1 = "b83aa3f513be680454437a0eee21001607e5d983"
uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
version = "0.8.5"

[[Cairo_jll]]
deps = ["Artifacts", "Bzip2_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"]
git-tree-sha1 = "e2f47f6d8337369411569fd45ae5753ca10394c6"
uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a"
version = "1.16.0+6"

[[CatIndices]]
deps = ["CustomUnitRanges", "OffsetArrays"]
git-tree-sha1 = "a0f80a09780eed9b1d106a1bf62041c2efc995bc"
uuid = "aafaddc9-749c-510e-ac4f-586e18779b91"
version = "0.2.2"

[[ChainRulesCore]]
deps = ["Compat", "LinearAlgebra", "SparseArrays"]
git-tree-sha1 = "dcc25ff085cf548bc8befad5ce048391a7c07d40"
uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
version = "0.10.11"

[[ColorSchemes]]
deps = ["ColorTypes", "Colors", "FixedPointNumbers", "Random", "StaticArrays"]
git-tree-sha1 = "ed268efe58512df8c7e224d2e170afd76dd6a417"
uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4"
version = "3.13.0"

[[ColorTypes]]
deps = ["FixedPointNumbers", "Random"]
git-tree-sha1 = "024fe24d83e4a5bf5fc80501a314ce0d1aa35597"
uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f"
version = "0.11.0"

[[ColorVectorSpace]]
deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "SpecialFunctions", "Statistics", "TensorCore"]
git-tree-sha1 = "42a9b08d3f2f951c9b283ea427d96ed9f1f30343"
uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4"
version = "0.9.5"

[[Colors]]
deps = ["ColorTypes", "FixedPointNumbers", "Reexport"]
git-tree-sha1 = "417b0ed7b8b838aa6ca0a87aadf1bb9eb111ce40"
uuid = "5ae59095-9a9b-59fe-a467-6f913c188581"
version = "0.12.8"

[[Compat]]
deps = ["Base64", "Dates", "DelimitedFiles", "Distributed", "InteractiveUtils", "LibGit2", "Libdl", "LinearAlgebra", "Markdown", "Mmap", "Pkg", "Printf", "REPL", "Random", "SHA", "Serialization", "SharedArrays", "Sockets", "SparseArrays", "Statistics", "Test", "UUIDs", "Unicode"]
git-tree-sha1 = "dc7dedc2c2aa9faf59a55c622760a25cbefbe941"
uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
version = "3.31.0"

[[CompilerSupportLibraries_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae"

[[ComputationalResources]]
git-tree-sha1 = "52cb3ec90e8a8bea0e62e275ba577ad0f74821f7"
uuid = "ed09eef8-17a6-5b46-8889-db040fac31e3"
version = "0.3.2"

[[Contour]]
deps = ["StaticArrays"]
git-tree-sha1 = "9f02045d934dc030edad45944ea80dbd1f0ebea7"
uuid = "d38c429a-6771-53c6-b99e-75d170b6e991"
version = "0.5.7"

[[Crayons]]
git-tree-sha1 = "3f71217b538d7aaee0b69ab47d9b7724ca8afa0d"
uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f"
version = "4.0.4"

[[CustomUnitRanges]]
git-tree-sha1 = "537c988076d001469093945f3bd0b300b8d3a7f3"
uuid = "dc8bdbbb-1ca9-579f-8c36-e416f6a65cce"
version = "1.0.1"

[[DataAPI]]
git-tree-sha1 = "ee400abb2298bd13bfc3df1c412ed228061a2385"
uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
version = "1.7.0"

[[DataFrames]]
deps = ["Compat", "DataAPI", "Future", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrettyTables", "Printf", "REPL", "Reexport", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"]
git-tree-sha1 = "1dadfca11c0e08e03ab15b63aaeda55266754bad"
uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
version = "1.2.0"

[[DataStructures]]
deps = ["Compat", "InteractiveUtils", "OrderedCollections"]
git-tree-sha1 = "4437b64df1e0adccc3e5d1adbc3ac741095e4677"
uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
version = "0.18.9"

[[DataValueInterfaces]]
git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6"
uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464"
version = "1.0.0"

[[Dates]]
deps = ["Printf"]
uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"

[[DelimitedFiles]]
deps = ["Mmap"]
uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"

[[Distributed]]
deps = ["Random", "Serialization", "Sockets"]
uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b"

[[DocStringExtensions]]
deps = ["LibGit2"]
git-tree-sha1 = "a32185f5428d3986f47c2ab78b1f216d5e6cc96f"
uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
version = "0.8.5"

[[Downloads]]
deps = ["ArgTools", "LibCURL", "NetworkOptions"]
uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6"

[[EarCut_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "92d8f9f208637e8d2d28c664051a00569c01493d"
uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"
version = "2.1.5+1"

[[Expat_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b3bfd02e98aedfa5cf885665493c5598c350cd2f"
uuid = "2e619515-83b5-522b-bb60-26c02a35a201"
version = "2.2.10+0"

[[FFMPEG]]
deps = ["FFMPEG_jll"]
git-tree-sha1 = "b57e3acbe22f8484b4b5ff66a7499717fe1a9cc8"
uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
version = "0.4.1"

[[FFMPEG_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "LibVPX_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "Pkg", "Zlib_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"]
git-tree-sha1 = "3cc57ad0a213808473eafef4845a74766242e05f"
uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5"
version = "4.3.1+4"

[[FFTViews]]
deps = ["CustomUnitRanges", "FFTW"]
git-tree-sha1 = "70a0cfd9b1c86b0209e38fbfe6d8231fd606eeaf"
uuid = "4f61f5a4-77b1-5117-aa51-3ab5ef4ef0cd"
version = "0.3.1"

[[FFTW]]
deps = ["AbstractFFTs", "FFTW_jll", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"]
git-tree-sha1 = "f985af3b9f4e278b1d24434cbb546d6092fca661"
uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
version = "1.4.3"

[[FFTW_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "3676abafff7e4ff07bbd2c42b3d8201f31653dcc"
uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a"
version = "3.3.9+8"

[[FixedPointNumbers]]
deps = ["Statistics"]
git-tree-sha1 = "335bfdceacc84c5cdf16aadc768aa5ddfc5383cc"
uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
version = "0.8.4"

[[Fontconfig_jll]]
deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "35895cf184ceaab11fd778b4590144034a167a2f"
uuid = "a3f928ae-7b40-5064-980b-68af3947d34b"
version = "2.13.1+14"

[[Formatting]]
deps = ["Printf"]
git-tree-sha1 = "8339d61043228fdd3eb658d86c926cb282ae72a8"
uuid = "59287772-0a20-5a39-b81b-1366585eb4c0"
version = "0.4.2"

[[FreeType2_jll]]
deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "cbd58c9deb1d304f5a245a0b7eb841a2560cfec6"
uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7"
version = "2.10.1+5"

[[FriBidi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "aa31987c2ba8704e23c6c8ba8a4f769d5d7e4f91"
uuid = "559328eb-81f9-559d-9380-de523a88c83c"
version = "1.0.10+0"

[[Future]]
deps = ["Random"]
uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820"

[[GLFW_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Pkg", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll"]
git-tree-sha1 = "dba1e8614e98949abfa60480b13653813d8f0157"
uuid = "0656b61e-2033-5cc2-a64a-77c0f6c09b89"
version = "3.3.5+0"

[[GR]]
deps = ["Base64", "DelimitedFiles", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Pkg", "Printf", "Random", "Serialization", "Sockets", "Test", "UUIDs"]
git-tree-sha1 = "b83e3125048a9c3158cbb7ca423790c7b1b57bea"
uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
version = "0.57.5"

[[GR_jll]]
deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Pkg", "Qt5Base_jll", "Zlib_jll", "libpng_jll"]
git-tree-sha1 = "e14907859a1d3aee73a019e7b3c98e9e7b8b5b3e"
uuid = "d2c73de3-f751-5644-a686-071e5b155ba9"
version = "0.57.3+0"

[[GeometryBasics]]
deps = ["EarCut_jll", "IterTools", "LinearAlgebra", "StaticArrays", "StructArrays", "Tables"]
git-tree-sha1 = "15ff9a14b9e1218958d3530cc288cf31465d9ae2"
uuid = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
version = "0.3.13"

[[Gettext_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "XML2_jll"]
git-tree-sha1 = "9b02998aba7bf074d14de89f9d37ca24a1a0b046"
uuid = "78b55507-aeef-58d4-861c-77aaff3498b1"
version = "0.21.0+0"

[[Glib_jll]]
deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "47ce50b742921377301e15005c96e979574e130b"
uuid = "7746bdde-850d-59dc-9ae8-88ece973131d"
version = "2.68.1+0"

[[Graphics]]
deps = ["Colors", "LinearAlgebra", "NaNMath"]
git-tree-sha1 = "2c1cf4df419938ece72de17f368a021ee162762e"
uuid = "a2bd30eb-e257-5431-a919-1863eab51364"
version = "1.1.0"

[[Grisu]]
git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2"
uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe"
version = "1.0.2"

[[HTTP]]
deps = ["Base64", "Dates", "IniFile", "Logging", "MbedTLS", "NetworkOptions", "Sockets", "URIs"]
git-tree-sha1 = "c6a1fff2fd4b1da29d3dccaffb1e1001244d844e"
uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3"
version = "0.9.12"

[[ImageCore]]
deps = ["AbstractFFTs", "ColorVectorSpace", "Colors", "FixedPointNumbers", "Graphics", "MappedArrays", "MosaicViews", "OffsetArrays", "PaddedViews", "Reexport"]
git-tree-sha1 = "75f7fea2b3601b58f24ee83617b528e57160cbfd"
uuid = "a09fc81d-aa75-5fe9-8630-4744c3626534"
version = "0.9.1"

[[ImageFiltering]]
deps = ["CatIndices", "ComputationalResources", "DataStructures", "FFTViews", "FFTW", "ImageCore", "LinearAlgebra", "OffsetArrays", "Requires", "SparseArrays", "StaticArrays", "Statistics", "TiledIteration"]
git-tree-sha1 = "79dac52336910325a5675813053b1eee3eb5dcc6"
uuid = "6a3955dd-da59-5b1f-98d4-e7296123deb5"
version = "0.6.22"

[[IniFile]]
deps = ["Test"]
git-tree-sha1 = "098e4d2c533924c921f9f9847274f2ad89e018b8"
uuid = "83e8ac13-25f8-5344-8a64-a9f2b223428f"
version = "0.5.0"

[[IntelOpenMP_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "d979e54b71da82f3a65b62553da4fc3d18c9004c"
uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0"
version = "2018.0.3+2"

[[InteractiveUtils]]
deps = ["Markdown"]
uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"

[[InvertedIndices]]
deps = ["Test"]
git-tree-sha1 = "15732c475062348b0165684ffe28e85ea8396afc"
uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f"
version = "1.0.0"

[[IterTools]]
git-tree-sha1 = "05110a2ab1fc5f932622ffea2a003221f4782c18"
uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
version = "1.3.0"

[[IteratorInterfaceExtensions]]
git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856"
uuid = "82899510-4779-5014-852e-03e436cf321d"
version = "1.0.0"

[[JLLWrappers]]
deps = ["Preferences"]
git-tree-sha1 = "642a199af8b68253517b80bd3bfd17eb4e84df6e"
uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
version = "1.3.0"

[[JSON]]
deps = ["Dates", "Mmap", "Parsers", "Unicode"]
git-tree-sha1 = "81690084b6198a2e1da36fcfda16eeca9f9f24e4"
uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
version = "0.21.1"

[[JpegTurbo_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "d735490ac75c5cb9f1b00d8b5509c11984dc6943"
uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8"
version = "2.1.0+0"

[[LAME_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "f6250b16881adf048549549fba48b1161acdac8c"
uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d"
version = "3.100.1+0"

[[LZO_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "e5b909bcf985c5e2605737d2ce278ed791b89be6"
uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac"
version = "2.10.1+0"

[[LaTeXStrings]]
git-tree-sha1 = "c7f1c695e06c01b95a67f0cd1d34994f3e7db104"
uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
version = "1.2.1"

[[Latexify]]
deps = ["Formatting", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "Printf", "Requires"]
git-tree-sha1 = "a4b12a1bd2ebade87891ab7e36fdbce582301a92"
uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
version = "0.15.6"

[[LazyArtifacts]]
deps = ["Artifacts", "Pkg"]
uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3"

[[LibCURL]]
deps = ["LibCURL_jll", "MozillaCACerts_jll"]
uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21"

[[LibCURL_jll]]
deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"]
uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0"

[[LibGit2]]
deps = ["Base64", "NetworkOptions", "Printf", "SHA"]
uuid = "76f85450-5226-5b5a-8eaa-529ad045b433"

[[LibSSH2_jll]]
deps = ["Artifacts", "Libdl", "MbedTLS_jll"]
uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8"

[[LibVPX_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "12ee7e23fa4d18361e7c2cde8f8337d4c3101bc7"
uuid = "dd192d2f-8180-539f-9fb4-cc70b1dcf69a"
version = "1.10.0+0"

[[Libdl]]
uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb"

[[Libffi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "761a393aeccd6aa92ec3515e428c26bf99575b3b"
uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490"
version = "3.2.2+0"

[[Libgcrypt_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgpg_error_jll", "Pkg"]
git-tree-sha1 = "64613c82a59c120435c067c2b809fc61cf5166ae"
uuid = "d4300ac3-e22c-5743-9152-c294e39db1e4"
version = "1.8.7+0"

[[Libglvnd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll", "Xorg_libXext_jll"]
git-tree-sha1 = "7739f837d6447403596a75d19ed01fd08d6f56bf"
uuid = "7e76a0d4-f3c7-5321-8279-8d96eeed0f29"
version = "1.3.0+3"

[[Libgpg_error_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c333716e46366857753e273ce6a69ee0945a6db9"
uuid = "7add5ba3-2f88-524e-9cd5-f83b8a55f7b8"
version = "1.42.0+0"

[[Libiconv_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "42b62845d70a619f063a7da093d995ec8e15e778"
uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531"
version = "1.16.1+1"

[[Libmount_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "9c30530bf0effd46e15e0fdcf2b8636e78cbbd73"
uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9"
version = "2.35.0+0"

[[Libtiff_jll]]
deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Pkg", "Zlib_jll", "Zstd_jll"]
git-tree-sha1 = "340e257aada13f95f98ee352d316c3bed37c8ab9"
uuid = "89763e89-9b03-5906-acba-b20f662cd828"
version = "4.3.0+0"

[[Libuuid_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7f3efec06033682db852f8b3bc3c1d2b0a0ab066"
uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700"
version = "2.36.0+0"

[[LinearAlgebra]]
deps = ["Libdl"]
uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

[[LogExpFunctions]]
deps = ["DocStringExtensions", "LinearAlgebra"]
git-tree-sha1 = "7bd5f6565d80b6bf753738d2bc40a5dfea072070"
uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
version = "0.2.5"

[[Logging]]
uuid = "56ddb016-857b-54e1-b83d-db4d58db5568"

[[MKL_jll]]
deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg"]
git-tree-sha1 = "c253236b0ed414624b083e6b72bfe891fbd2c7af"
uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7"
version = "2021.1.1+1"

[[MacroTools]]
deps = ["Markdown", "Random"]
git-tree-sha1 = "6a8a2a625ab0dea913aba95c11370589e0239ff0"
uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
version = "0.5.6"

[[MappedArrays]]
git-tree-sha1 = "18d3584eebc861e311a552cbb67723af8edff5de"
uuid = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900"
version = "0.4.0"

[[Markdown]]
deps = ["Base64"]
uuid = "d6f4376e-aef5-505a-96c1-9c027394607a"

[[MbedTLS]]
deps = ["Dates", "MbedTLS_jll", "Random", "Sockets"]
git-tree-sha1 = "1c38e51c3d08ef2278062ebceade0e46cefc96fe"
uuid = "739be429-bea8-5141-9913-cc70e7f3736d"
version = "1.0.3"

[[MbedTLS_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1"

[[Measures]]
git-tree-sha1 = "e498ddeee6f9fdb4551ce855a46f54dbd900245f"
uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e"
version = "0.3.1"

[[Missings]]
deps = ["DataAPI"]
git-tree-sha1 = "4ea90bd5d3985ae1f9a908bd4500ae88921c5ce7"
uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
version = "1.0.0"

[[Mmap]]
uuid = "a63ad114-7e13-5084-954f-fe012c677804"

[[MosaicViews]]
deps = ["MappedArrays", "OffsetArrays", "PaddedViews", "StackViews"]
git-tree-sha1 = "b34e3bc3ca7c94914418637cb10cc4d1d80d877d"
uuid = "e94cdb99-869f-56ef-bcf0-1ae2bcbe0389"
version = "0.3.3"

[[MozillaCACerts_jll]]
uuid = "14a3606d-f60d-562e-9121-12d972cd8159"

[[NaNMath]]
git-tree-sha1 = "bfe47e760d60b82b66b61d2d44128b62e3a369fb"
uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
version = "0.3.5"

[[NetworkOptions]]
uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908"

[[OffsetArrays]]
deps = ["Adapt"]
git-tree-sha1 = "2bf78c5fd7fa56d2bbf1efbadd45c1b8789e6f57"
uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
version = "1.10.2"

[[Ogg_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7937eda4681660b4d6aeeecc2f7e1c81c8ee4e2f"
uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051"
version = "1.3.5+0"

[[OpenSSL_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "15003dcb7d8db3c6c857fda14891a539a8f2705a"
uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
version = "1.1.10+0"

[[OpenSpecFun_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1"
uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e"
version = "0.5.5+0"

[[Opus_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "51a08fb14ec28da2ec7a927c4337e4332c2a4720"
uuid = "91d4177d-7536-5919-b921-800302f37372"
version = "1.3.2+0"

[[OrderedCollections]]
git-tree-sha1 = "85f8e6578bf1f9ee0d11e7bb1b1456435479d47c"
uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
version = "1.4.1"

[[PCRE_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b2a7af664e098055a7529ad1a900ded962bca488"
uuid = "2f80f16e-611a-54ab-bc61-aa92de5b98fc"
version = "8.44.0+0"

[[PaddedViews]]
deps = ["OffsetArrays"]
git-tree-sha1 = "0fa5e78929aebc3f6b56e1a88cf505bb00a354c4"
uuid = "5432bcbf-9aad-5242-b902-cca2824c8663"
version = "0.5.8"

[[Parsers]]
deps = ["Dates"]
git-tree-sha1 = "c8abc88faa3f7a3950832ac5d6e690881590d6dc"
uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
version = "1.1.0"

[[Pixman_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "b4f5d02549a10e20780a24fce72bea96b6329e29"
uuid = "30392449-352a-5448-841d-b1acce4e97dc"
version = "0.40.1+0"

[[Pkg]]
deps = ["Artifacts", "Dates", "Downloads", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"]
uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"

[[PlotThemes]]
deps = ["PlotUtils", "Requires", "Statistics"]
git-tree-sha1 = "a3a964ce9dc7898193536002a6dd892b1b5a6f1d"
uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
version = "2.0.1"

[[PlotUtils]]
deps = ["ColorSchemes", "Colors", "Dates", "Printf", "Random", "Reexport", "Statistics"]
git-tree-sha1 = "501c20a63a34ac1d015d5304da0e645f42d91c9f"
uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043"
version = "1.0.11"

[[Plots]]
deps = ["Base64", "Contour", "Dates", "FFMPEG", "FixedPointNumbers", "GR", "GeometryBasics", "JSON", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "PlotThemes", "PlotUtils", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs"]
git-tree-sha1 = "b93181645c1209d912d5632ba2d0094bc00703ad"
uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
version = "1.18.1"

[[PlutoUI]]
deps = ["Base64", "Dates", "InteractiveUtils", "JSON", "Logging", "Markdown", "Random", "Reexport", "Suppressor"]
git-tree-sha1 = "44e225d5837e2a2345e69a1d1e01ac2443ff9fcb"
uuid = "7f904dfe-b85e-4ff6-b463-dae2292396a8"
version = "0.7.9"

[[PooledArrays]]
deps = ["DataAPI", "Future"]
git-tree-sha1 = "cde4ce9d6f33219465b55162811d8de8139c0414"
uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720"
version = "1.2.1"

[[Preferences]]
deps = ["TOML"]
git-tree-sha1 = "00cfd92944ca9c760982747e9a1d0d5d86ab1e5a"
uuid = "21216c6a-2e73-6563-6e65-726566657250"
version = "1.2.2"

[[PrettyTables]]
deps = ["Crayons", "Formatting", "Markdown", "Reexport", "Tables"]
git-tree-sha1 = "0d1245a357cc61c8cd61934c07447aa569ff22e6"
uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
version = "1.1.0"

[[Printf]]
deps = ["Unicode"]
uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7"

[[Qt5Base_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Pkg", "Xorg_libXext_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "xkbcommon_jll"]
git-tree-sha1 = "ad368663a5e20dbb8d6dc2fddeefe4dae0781ae8"
uuid = "ea2cea3b-5b76-57ae-a6ef-0a8af62496e1"
version = "5.15.3+0"

[[REPL]]
deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"]
uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"

[[Random]]
deps = ["Serialization"]
uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"

[[RecipesBase]]
git-tree-sha1 = "b3fb709f3c97bfc6e948be68beeecb55a0b340ae"
uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
version = "1.1.1"

[[RecipesPipeline]]
deps = ["Dates", "NaNMath", "PlotUtils", "RecipesBase"]
git-tree-sha1 = "2a7a2469ed5d94a98dea0e85c46fa653d76be0cd"
uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c"
version = "0.3.4"

[[Reexport]]
git-tree-sha1 = "5f6c21241f0f655da3952fd60aa18477cf96c220"
uuid = "189a3867-3050-52da-a836-e630ba90ab69"
version = "1.1.0"

[[Requires]]
deps = ["UUIDs"]
git-tree-sha1 = "4036a3bd08ac7e968e27c203d45f5fff15020621"
uuid = "ae029012-a4dd-5104-9daa-d747884805df"
version = "1.1.3"

[[SHA]]
uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"

[[Scratch]]
deps = ["Dates"]
git-tree-sha1 = "0b4b7f1393cff97c33891da2a0bf69c6ed241fda"
uuid = "6c6a2e73-6563-6170-7368-637461726353"
version = "1.1.0"

[[SentinelArrays]]
deps = ["Dates", "Random"]
git-tree-sha1 = "ffae887d0f0222a19c406a11c3831776d1383e3d"
uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c"
version = "1.3.3"

[[Serialization]]
uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"

[[SharedArrays]]
deps = ["Distributed", "Mmap", "Random", "Serialization"]
uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383"

[[Showoff]]
deps = ["Dates", "Grisu"]
git-tree-sha1 = "91eddf657aca81df9ae6ceb20b959ae5653ad1de"
uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
version = "1.0.3"

[[Sockets]]
uuid = "6462fe0b-24de-5631-8697-dd941f90decc"

[[SortingAlgorithms]]
deps = ["DataStructures"]
git-tree-sha1 = "b3363d7460f7d098ca0912c69b082f75625d7508"
uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c"
version = "1.0.1"

[[SparseArrays]]
deps = ["LinearAlgebra", "Random"]
uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"

[[SpecialFunctions]]
deps = ["ChainRulesCore", "LogExpFunctions", "OpenSpecFun_jll"]
git-tree-sha1 = "a50550fa3164a8c46747e62063b4d774ac1bcf49"
uuid = "276daf66-3868-5448-9aa4-cd146d93841b"
version = "1.5.1"

[[StackViews]]
deps = ["OffsetArrays"]
git-tree-sha1 = "46e589465204cd0c08b4bd97385e4fa79a0c770c"
uuid = "cae243ae-269e-4f55-b966-ac2d0dc13c15"
version = "0.1.1"

[[StaticArrays]]
deps = ["LinearAlgebra", "Random", "Statistics"]
git-tree-sha1 = "a43a7b58a6e7dc933b2fa2e0ca653ccf8bb8fd0e"
uuid = "90137ffa-7385-5640-81b9-e52037218182"
version = "1.2.6"

[[Statistics]]
deps = ["LinearAlgebra", "SparseArrays"]
uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

[[StatsAPI]]
git-tree-sha1 = "1958272568dc176a1d881acb797beb909c785510"
uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0"
version = "1.0.0"

[[StatsBase]]
deps = ["DataAPI", "DataStructures", "LinearAlgebra", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"]
git-tree-sha1 = "2f6792d523d7448bbe2fec99eca9218f06cc746d"
uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
version = "0.33.8"

[[StructArrays]]
deps = ["Adapt", "DataAPI", "StaticArrays", "Tables"]
git-tree-sha1 = "000e168f5cc9aded17b6999a560b7c11dda69095"
uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
version = "0.6.0"

[[Suppressor]]
git-tree-sha1 = "a819d77f31f83e5792a76081eee1ea6342ab8787"
uuid = "fd094767-a336-5f1f-9728-57cf17d0bbfb"
version = "0.2.0"

[[TOML]]
deps = ["Dates"]
uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76"

[[TableTraits]]
deps = ["IteratorInterfaceExtensions"]
git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39"
uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c"
version = "1.0.1"

[[Tables]]
deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "LinearAlgebra", "TableTraits", "Test"]
git-tree-sha1 = "8ed4a3ea724dac32670b062be3ef1c1de6773ae8"
uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
version = "1.4.4"

[[Tar]]
deps = ["ArgTools", "SHA"]
uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e"

[[TensorCore]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6"
uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50"
version = "0.1.1"

[[Test]]
deps = ["InteractiveUtils", "Logging", "Random", "Serialization"]
uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

[[TiledIteration]]
deps = ["OffsetArrays"]
git-tree-sha1 = "52c5f816857bfb3291c7d25420b1f4aca0a74d18"
uuid = "06e1c1a7-607b-532d-9fad-de7d9aa2abac"
version = "0.3.0"

[[URIs]]
git-tree-sha1 = "97bbe755a53fe859669cd907f2d96aee8d2c1355"
uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4"
version = "1.3.0"

[[UUIDs]]
deps = ["Random", "SHA"]
uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"

[[Unicode]]
uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"

[[Wayland_jll]]
deps = ["Artifacts", "Expat_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg", "XML2_jll"]
git-tree-sha1 = "3e61f0b86f90dacb0bc0e73a0c5a83f6a8636e23"
uuid = "a2964d1f-97da-50d4-b82a-358c7fce9d89"
version = "1.19.0+0"

[[Wayland_protocols_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Wayland_jll"]
git-tree-sha1 = "2839f1c1296940218e35df0bbb220f2a79686670"
uuid = "2381bf8a-dfd0-557d-9999-79630e7b1b91"
version = "1.18.0+4"

[[XML2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "1acf5bdf07aa0907e0a37d3718bb88d4b687b74a"
uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a"
version = "2.9.12+0"

[[XSLT_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"]
git-tree-sha1 = "91844873c4085240b95e795f692c4cec4d805f8a"
uuid = "aed1982a-8fda-507f-9586-7b0439959a61"
version = "1.1.34+0"

[[Xorg_libX11_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll", "Xorg_xtrans_jll"]
git-tree-sha1 = "5be649d550f3f4b95308bf0183b82e2582876527"
uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc"
version = "1.6.9+4"

[[Xorg_libXau_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4e490d5c960c314f33885790ed410ff3a94ce67e"
uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec"
version = "1.0.9+4"

[[Xorg_libXcursor_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"]
git-tree-sha1 = "12e0eb3bc634fa2080c1c37fccf56f7c22989afd"
uuid = "935fb764-8cf2-53bf-bb30-45bb1f8bf724"
version = "1.2.0+4"

[[Xorg_libXdmcp_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4fe47bd2247248125c428978740e18a681372dd4"
uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05"
version = "1.1.3+4"

[[Xorg_libXext_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "b7c0aa8c376b31e4852b360222848637f481f8c3"
uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3"
version = "1.3.4+4"

[[Xorg_libXfixes_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "0e0dc7431e7a0587559f9294aeec269471c991a4"
uuid = "d091e8ba-531a-589c-9de9-94069b037ed8"
version = "5.0.3+4"

[[Xorg_libXi_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXfixes_jll"]
git-tree-sha1 = "89b52bc2160aadc84d707093930ef0bffa641246"
uuid = "a51aa0fd-4e3c-5386-b890-e753decda492"
version = "1.7.10+4"

[[Xorg_libXinerama_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll"]
git-tree-sha1 = "26be8b1c342929259317d8b9f7b53bf2bb73b123"
uuid = "d1454406-59df-5ea1-beac-c340f2130bc3"
version = "1.1.4+4"

[[Xorg_libXrandr_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll"]
git-tree-sha1 = "34cea83cb726fb58f325887bf0612c6b3fb17631"
uuid = "ec84b674-ba8e-5d96-8ba1-2a689ba10484"
version = "1.5.2+4"

[[Xorg_libXrender_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "19560f30fd49f4d4efbe7002a1037f8c43d43b96"
uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa"
version = "0.9.10+4"

[[Xorg_libpthread_stubs_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "6783737e45d3c59a4a4c4091f5f88cdcf0908cbb"
uuid = "14d82f49-176c-5ed1-bb49-ad3f5cbd8c74"
version = "0.1.0+3"

[[Xorg_libxcb_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"]
git-tree-sha1 = "daf17f441228e7a3833846cd048892861cff16d6"
uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b"
version = "1.13.0+3"

[[Xorg_libxkbfile_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"]
git-tree-sha1 = "926af861744212db0eb001d9e40b5d16292080b2"
uuid = "cc61e674-0454-545c-8b26-ed2c68acab7a"
version = "1.1.0+4"

[[Xorg_xcb_util_image_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "0fab0a40349ba1cba2c1da699243396ff8e94b97"
uuid = "12413925-8142-5f55-bb0e-6d7ca50bb09b"
version = "0.4.0+1"

[[Xorg_xcb_util_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll"]
git-tree-sha1 = "e7fd7b2881fa2eaa72717420894d3938177862d1"
uuid = "2def613f-5ad1-5310-b15b-b15d46f528f5"
version = "0.4.0+1"

[[Xorg_xcb_util_keysyms_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "d1151e2c45a544f32441a567d1690e701ec89b00"
uuid = "975044d2-76e6-5fbe-bf08-97ce7c6574c7"
version = "0.4.0+1"

[[Xorg_xcb_util_renderutil_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "dfd7a8f38d4613b6a575253b3174dd991ca6183e"
uuid = "0d47668e-0667-5a69-a72c-f761630bfb7e"
version = "0.3.9+1"

[[Xorg_xcb_util_wm_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"]
git-tree-sha1 = "e78d10aab01a4a154142c5006ed44fd9e8e31b67"
uuid = "c22f9ab0-d5fe-5066-847c-f4bb1cd4e361"
version = "0.4.1+1"

[[Xorg_xkbcomp_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxkbfile_jll"]
git-tree-sha1 = "4bcbf660f6c2e714f87e960a171b119d06ee163b"
uuid = "35661453-b289-5fab-8a00-3d9160c6a3a4"
version = "1.4.2+4"

[[Xorg_xkeyboard_config_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xkbcomp_jll"]
git-tree-sha1 = "5c8424f8a67c3f2209646d4425f3d415fee5931d"
uuid = "33bec58e-1273-512f-9401-5d533626f822"
version = "2.27.0+4"

[[Xorg_xtrans_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "79c31e7844f6ecf779705fbc12146eb190b7d845"
uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10"
version = "1.4.0+3"

[[Zlib_jll]]
deps = ["Libdl"]
uuid = "83775a58-1f1d-513f-b197-d71354ab007a"

[[Zstd_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "cc4bf3fdde8b7e3e9fa0351bdeedba1cf3b7f6e6"
uuid = "3161d3a3-bdf6-5164-811a-617609db77b4"
version = "1.5.0+0"

[[libass_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "acc685bcf777b2202a904cdcb49ad34c2fa1880c"
uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0"
version = "0.14.0+4"

[[libfdk_aac_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "7a5780a0d9c6864184b3a2eeeb833a0c871f00ab"
uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280"
version = "0.1.6+4"

[[libpng_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "94d180a6d2b5e55e447e2d27a29ed04fe79eb30c"
uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f"
version = "1.6.38+0"

[[libvorbis_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll", "Pkg"]
git-tree-sha1 = "c45f4e40e7aafe9d086379e5578947ec8b95a8fb"
uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a"
version = "1.3.7+0"

[[nghttp2_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d"

[[p7zip_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0"

[[x264_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "d713c1ce4deac133e3334ee12f4adff07f81778f"
uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a"
version = "2020.7.14+2"

[[x265_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "487da2f8f2f0c8ee0e83f39d13037d6bbf0a45ab"
uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76"
version = "3.0.0+3"

[[xkbcommon_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Wayland_jll", "Wayland_protocols_jll", "Xorg_libxcb_jll", "Xorg_xkeyboard_config_jll"]
git-tree-sha1 = "ece2350174195bb31de1a63bea3a41ae1aa593b6"
uuid = "d8fb68d0-12a3-5cfd-a85a-d49703b185fd"
version = "0.9.1+5"
"""

# ╔═╡ Cell order:
# ╟─e2635196-448c-11eb-2877-c5735be35d80
# ╠═ef23d264-448e-11eb-10f8-ad25ae5f244d
# ╠═cdec3534-43f1-4726-af95-d82e32f3a0cb
# ╟─9887d642-8387-477c-991c-4756bc137252
# ╟─3ac6e767-2df5-4969-8582-11312228f534
# ╠═1d7590fd-8295-4964-b368-4629b1b3137c
# ╠═7a75c70f-e7d5-4505-8b6e-128e3a9c2e0b
# ╟─8f0fce44-46ed-11eb-395c-b3072d1362e3
# ╟─f7923db6-448f-11eb-0e94-e77b1a911cff
# ╠═9685d04e-4493-11eb-0db5-c35b82182d7f
# ╠═2fac8934-4494-11eb-0219-7f1d44649362
# ╠═110729c7-6d6e-4efc-939f-d945a6d5ee12
# ╠═257048ea-4495-11eb-0b21-f353c7997010
# ╟─4efe6d30-4498-11eb-2e05-6924e9b3aa6a
# ╟─24d95b88-0521-49b6-9258-a96b10a8e541
# ╟─eed3fb32-46ed-11eb-13f6-0d79c4527fb0
# ╠═f6f679d8-449a-11eb-1967-3da2b02ef0dc
# ╠═681f0498-449b-11eb-2dee-7dd6d54dfc4e
# ╟─5b04aebe-4498-11eb-1309-93cbca18c737
# ╟─a14162e8-46ee-11eb-3edb-8f55a7565c4b
# ╟─35eb6a82-449a-11eb-1f5e-ebe3e5fa4fb6
# ╟─291c556e-44b6-11eb-0666-df947594a060
# ╟─ba472a38-46ef-11eb-21e6-97331ae5e715
# ╠═3fd3dce4-44b8-11eb-0f23-93765a452257
# ╠═f8fffc76-44b7-11eb-3de5-9d2a8a97ca11
# ╠═2a54ec88-44b7-11eb-196d-f7844a62e8f6
# ╟─30323758-44c0-11eb-0df3-1ddd46872b74
# ╟─03f58904-46f0-11eb-08bb-035012ae329d
# ╠═b5fb79f2-44bf-11eb-025b-ed9492e39ade
# ╠═c0b2387c-44bf-11eb-31d1-3f403a6067f3
# ╟─f37730a2-44b8-11eb-18d2-670aa5a0209e
# ╟─f3525c1c-44bf-11eb-0619-4f99561f4a6b
# ╟─ede8c6f0-51d8-11eb-2681-cb27cee40af5
# ╟─b79d0f23-c592-4e03-b9e9-dc61b3cedb6e
# ╠═2f74be36-44ae-11eb-278d-9db0cdf4a98b
# ╟─00000000-0000-0000-0000-000000000001
# ╟─00000000-0000-0000-0000-000000000002

max_stars_repo_name: sragole/COVIDCorrelations

max_issues_repo_name: sragole/COVIDCorrelations

max_forks_repo_name: sragole/COVIDCorrelations


text:
module JMcDM

using DataFrames
using LinearAlgebra
using JuMP
using Cbc
using StatsBase

# includes
include("types.jl")
include("utilities.jl")
include("topsis.jl")
include("vikor.jl")
include("electre.jl")
include("moora.jl")
include("dematel.jl")
include("ahp.jl")
include("nds.jl")
include("singlecriterion.jl")
include("game.jl")
include("dataenvelop.jl")
include("grey.jl")
include("saw.jl")
include("aras.jl")
include("wpm.jl")
include("waspas.jl")
include("edas.jl")
include("marcos.jl")
include("mabac.jl")
include("mairca.jl")
include("copras.jl")

# export MCDM types
export MCDMResult
export TopsisResult
export VikorResult
export ElectreResult
export MooraResult
export AHPConsistencyResult
export AHPResult
export NDSResult
export GreyResult
export SawResult
export ARASResult
export WPMResult
export WASPASResult
export EDASResult
export MARCOSResult
export MABACResult
export MAIRCAResult
export COPRASResult

# export game type
export GameResult

#  export SCDM types
export SCDMResult
export LaplaceResult
export MaximinResult
export MaximaxResult
export MinimaxResult
export MiniminResult
export SavageResult
export HurwiczResult
export MLEResult
export ExpectedRegretResult
export DataEnvelopResult

# export utility functions
export euclidean
export normalize
export colmaxs
export colmins
export unitize
export makeDecisionMatrix
export reverseminmax
export makeminmax

#  export MCDM tools
export topsis
export vikor
export electre
export moora
export dematel
export ahp_RI, ahp_consistency, ahp
export nds
export grey
export saw
export aras
export wpm
export waspas
export edas
export marcos
export mabac
export mairca
export copras

#  export SCDM tools
export laplace
export maximin
export maximax
export minimax
export minimin
export savage
export hurwicz
export mle
export expectedregret

# export game solver
export game

# export data envelop
export dataenvelop

end # module

max_stars_repo_name: ersagunkuruca/JMcDM

max_issues_repo_name: ersagunkuruca/JMcDM

max_forks_repo_name: ersagunkuruca/JMcDM


text:
function score(x, y)
	distance = sqrt(x^2 + y^2)
	inner_radius = 1
	middle_radius = 5
	outer_radius = 10
	if distance <= inner_radius
		return 10
	elseif distance <= middle_radius
		return 5
	elseif distance <= outer_radius
		return 1
	else
		return 0
    end
end

max_stars_repo_name: tamireinhorn/exercism

max_issues_repo_name: tamireinhorn/exercism

max_forks_repo_name: tamireinhorn/Exercism


text:
using Stochastics
using Test

@testset "Inference.jl" begin
    x = [1, 2]
    y = [3, 4]
    x₁ = [5.2, 5.8, 4.3, 5.2, 4.6, 4.7, 5.8, 5.5]
    y₁ = [5.6, 6.3, 4.9, 5.8, 5.5, 5.7, 6.1, 5.4]
    @test Stochastics.two_sample_degrees_of_freedom_unknown_variance(x, y) == 2
    @test round.(Stochastics.normal_interval_two_sample_paired(x₁, y₁, 0.025), digits=2) == [0.24, 0.81]
end

max_issues_repo_name: persson-io/Stochastics

max_forks_repo_name: persson-io/Stochastics


text:
@testset "638.shopping-offers.jl" begin
    @test shopping_offers([2, 5], [[3, 0, 5], [1, 2, 10]], [3, 2]) == 14
    @test shopping_offers([2, 3, 4], [[1, 1, 0, 4], [2, 2, 1, 9]], [1, 2, 1]) == 11
    @test shopping_offers([0, 0, 0], [[1, 1, 0, 4], [2, 2, 1, 9]], [1, 1, 1]) == 0
end


text:
module BC

using ..lattice: LatticeD2Q4,LatticeD2Q5,LatticeD2Q9
using ..Parameters: Param,BCDirichlet,BCRiemann

export setBCs!

function setBCs!(lat::LatticeD2Q4,param::Param)
   T = param.T
   nI,nJ = param.nI,param.nJ
   BCtype= param.BCtype
   w = lat.w

   # Left
   if BCtype[1] == BCDirichlet
      lat.f[1,1,:] .= (w[1]+w[2])*T[1] .- lat.f[2,1,:]
   else
      lat.f[1,1,:] .= lat.f[1,2,:]
   end

   # Right
   if BCtype[2] == BCDirichlet
      lat.f[2,nI,:] .= (w[1]+w[2])*T[2] .- lat.f[1,nI,:]
   else
      lat.f[2,nI,:] .= lat.f[2,nI-1,:]
   end

   # Bottom
   if BCtype[3] == BCDirichlet
      lat.f[3,:,1] .= (w[3]+w[4])*T[3] .- lat.f[4,:,1]
   else
      lat.f[3,:,1] .= lat.f[3,:,2]
   end

   # Top
   if BCtype[4] == BCDirichlet
      lat.f[4,:,nJ] .= (w[3]+w[4])*T[4] .- lat.f[3,:,nJ]
   else
      lat.f[4,:,nJ] .= lat.f[2,nJ-1,:]
   end

end

function setBCs!(lat::LatticeD2Q5,param::Param)
   T = param.T
   nI,nJ = param.nI,param.nJ
   BCtype= param.BCtype
   w = lat.w

   # Left
   if BCtype[1] == BCDirichlet
      lat.f[1,1,:] .= (w[1]+w[2])*T[1] .- lat.f[2,1,:]
      lat.f[5,1,:] .= w[5]*T[1]
   else
      lat.f[1,1,:] .= lat.f[1,2,:]
   end

   # Right
   if BCtype[2] == BCDirichlet
      lat.f[2,nI,:] .= (w[1]+w[2])*T[2] .- lat.f[1,nI,:]
      lat.f[5,nI,:] .= w[5]*T[2]
   else
      lat.f[2,nI,:] .= lat.f[2,nI-1,:]
   end

   # Bottom
   if BCtype[3] == BCDirichlet
      lat.f[3,:,1] .= (w[3]+w[4])*T[3] .- lat.f[4,:,1]
      lat.f[5,:,1] .= w[5]*T[3]
   else
      lat.f[3,:,1] .= lat.f[3,:,2]
   end

   # Top
   if BCtype[4] == BCDirichlet
      lat.f[4,:,nJ] .= (w[3]+w[4])*T[4] .- lat.f[3,:,nJ]
      lat.f[5,:,nJ] .= w[5]*T[4]
   else
      lat.f[4,:,nJ] .= lat.f[4,:,nJ-1]
   end
end

function setBCs!(lat::LatticeD2Q9,param::Param)
   T = param.T
   nI,nJ = param.nI,param.nJ
   BCtype= param.BCtype
   w = lat.w

   if BCtype[1] == BCDirichlet
      lat.f[1,1,:] .= (w[1]+w[3])*T[1] .- lat.f[3,1,:]
      lat.f[5,1,:] .= (w[5]+w[7])*T[1] .- lat.f[7,1,:]
      lat.f[8,1,:] .= (w[8]+w[6])*T[1] .- lat.f[6,1,:]
      lat.f[9,1,:] .= w[9]*T[1]
   elseif BCtype[1] == BCRiemann
      lat.f[1,1,:] .= lat.f[8,2,:]
      lat.f[5,1,:] .= lat.f[1,2,:]
      lat.f[8,1,:] .= lat.f[5,2,:]
   end

   if BCtype[2] == BCDirichlet
      lat.f[3,nI,:] .= (w[3]+w[1])*T[2] .- lat.f[1,nI,:]
      lat.f[7,nI,:] .= (w[7]+w[5])*T[2] .- lat.f[5,nI,:]
      lat.f[6,nI,:] .= (w[6]+w[8])*T[2] .- lat.f[8,nI,:]
      lat.f[9,nI,:] .= w[9]*T[2]
   elseif BCtype[2] == BCRiemann
      lat.f[6,nI,:] .= lat.f[8,nI,:]
      lat.f[3,nI,:] .= lat.f[1,nI,:]
      lat.f[7,nI,:] .= lat.f[5,nI,:]
   end

   if BCtype[3] == BCDirichlet
      lat.f[2,:,1] .= (w[2]+w[4])*T[3] .- lat.f[4,:,1]
      lat.f[5,:,1] .= (w[5]+w[8])*T[3] .- lat.f[8,:,1]
      lat.f[6,:,1] .= (w[6]+w[7])*T[3] .- lat.f[7,:,1]
      lat.f[9,:,1] .= w[9]*T[3]
   elseif BCtype[3] == BCRiemann
      lat.f[2,:,1] .= lat.f[2,:,1]
      lat.f[5,:,1] .= lat.f[5,:,1]
      lat.f[6,:,1] .= lat.f[6,:,1]
   end

   if BCtype[4] == BCDirichlet
      lat.f[4,:,nJ] .= (w[4]+w[2])*T[4] .- lat.f[2,:,nJ]
      lat.f[8,:,nJ] .= (w[8]+w[6])*T[4] .- lat.f[6,:,nJ]
      lat.f[7,:,nJ] .= (w[7]+w[5])*T[4] .- lat.f[5,:,nJ]
      lat.f[9,:,nJ] .= w[9]*T[4]
   elseif BCtype[4] == BCRiemann
      lat.f[4,:,nJ] .= lat.f[4,:,nJ-1]
      lat.f[8,:,nJ] .= lat.f[8,:,nJ-1]
      lat.f[7,:,nJ] .= lat.f[7,:,nJ-1]
   end

end

end


text:
"""
      SeisProcessFile(in,out,operators,parameters;<keyword arguments>)

Run processing flows that read and write from disk

f is a function that has the following syntax: d2 = f(d1,param),
where
param is list of keyword arguments for the function.
Note that f can be a vector of functions. They will be executed
sequentially on the same group of traces.

# Arguments
- `in`: input filename of type String or Array{String,1} - Seis format
- `out`: output filenames of type String or Array{String,1} - Seis format
- `operators`
- `parameters`

# Keyword arguments
- `group="gather"` : Options are all, some or gather
- `key=["imx","imy"]` : Defines type of gather
- `itrace=1` : Initial traces
- `ntrace=10000` : Total number of traces to process at once

# Example
Apply a bandpass filter to a seismic cube sequentially, by shot gather.
Assume dt is equal to 0.002.
```
julia> operators = [SeisBandPass]
julia> param = [Dict(:dt=>0.002, :fa=>20,:fb=>30,:fc=>80,:fd=>90)]
julia> SeisProcessFile(filein,fileout,operators,param,key=["sx"])
```
"""
function SeisProcessFile(in::String,out::String,operators,parameters;group="gather",key=["imx","imy"],itrace=1,ntrace=0)

	if (group=="all")
		d1,h1,e1 = SeisMain.SeisRead(in,group=group,key=key,itrace=1,ntrace=ntrace)
		for j = 1 : length(operators)
			op = operators[j]
			d2 = op(d1;parameters[j]...)
			d1 = copy(d2)
		end
		SeisMain.SeisWrite(out,d1,h1,e1)
	else
		#itrace_in = 1
		#itrace_out = 1
        itrace_in = itrace
        itrace_out = itrace
        n_tr = SeisMain.GetNumTraces(in)
        if ntrace == 0
            nx = n_tr
        else
            nx = ntrace
        end
        while itrace_out < itrace_in+nx && itrace_out <= n_tr
			d1,h1,e1 = SeisMain.SeisRead(in,group=group,key=key,itrace=itrace_in,ntrace=nx)
            		nt=size(d1,1)
			num_traces_in = size(reshape(d1,nt,:),2)
            #println("nx = ",nx)
			for j = 1 : length(operators)
				op = operators[j]
				d2 = op(d1;parameters[j]...)
				d1 = copy(d2)
			end
			num_traces_out = size(d1,2)
            #println("itrace_in= ",itrace_in," itrace_out = ",itrace_out," nx = ",nx," itrace+nx= ",itrace+nx)
			SeisMain.SeisWrite(out,d1,h1,e1,itrace=itrace_out)
			itrace_in += num_traces_in
			itrace_out += num_traces_out

		end
	end

end

function SeisProcessFile(in::Array{String,1},out::Array{String,1},operators,parameters;group="gather",key=["imx","imy"],itrace=1,ntrace=10000)
	for j = 1 : length(in)
		SeisProcess(in[j],out[j],parameters;group=group,key=key,itrace=itrace,ntrace=ntrace)
	end

end

"""
      SeisProcessFile(in1,in2,out,operators,parameters;<keyword arguments>)

Run processing flows that read from 2 files and write to disk

# Arguments
- `in1::String`: input filename - Seis format.
- `in2::String`: input filename - Seis format.
- `out::String`: output filename - Seis format.
- `operators`
- `parameters`

# Keyword arguments
- `group="gather"` : Options are all, some or gather
- `key=["imx","imy"]` : Defines type of gather
- `itrace=1` : Initial traces
- `ntrace=10000` : Total number of traces to process at once

# Example
Apply a bandpass filter to a seismic cube sequentially, by shot gather.
Assume dt is equal to 0.002.
```
julia> operators = [SeisBandPass]
julia> param = [Dict(:dt=>0.002, :fa=>20,:fb=>30,:fc=>80,:fd=>90)]
julia> SeisProcessFile(filein,fileout,operators,param,key=["sx"])
```
"""
function SeisProcessFile(in1::String,in2::String,out::String,operators,parameters;group="gather",key=["imx","imy"],itrace=1,ntrace=10000)
	group = get(param,"group","some")
	key = get(param,"key",["imx","imy"])
	ntrace = get(param,"ntrace",100)

	if (group=="all")
		d1,h1 = SeisMain.SeisRead(in1,group=group,key=key,itrace=1,ntrace=ntrace)
		d2,h2 = SeisMain.SeisRead(in2,group=group,key=key,itrace=1,ntrace=ntrace)
		for ifunc = 1 : length(operators)
			func = operators[ifunc]
			d3= func(d1,d2,param)
			d1 = copy(d3)
		end
		SeisMain.SeisWrite(out,d1,h1)
	else
        itrace_in = itrace
        itrace_out = itrace
        n_tr = SeisMain.GetNumTraces(in)
        if ntrace == 0
            nx = n_tr
        else
            nx = ntrace
        end
		while itrace_out < itrace+nx && itrace_out <= n_tr
			d1 = SeisMain.SeisRead(in1,group=group,key=key,itrace=itrace_in,ntrace=ntrace)
			d2 = SeisMain.SeisRead(in2,group=group,key=key,itrace=itrace_in,ntrace=ntrace)
            		nt = size(d1,1)
			num_traces_in = size(reshape(d1,nt,:),2)
			for ifunc = 1 : length(operators)
				func = operators[ifunc]
				d3 = func(d1,d2,param)
				d1 = copy(d3)
			end
            		nt_out = size(d1,1)
			num_traces_out = size(reshape(d1,nt_out,:),2)
			SeisMain.SeisWrite(out,d1,h1,itrace=itrace_out)
			itrace_in += num_traces_in
			itrace_out += num_traces_out
		end

	end

end


text:
# ---
# title: 1143. Longest Common Subsequence
# id: problem1143
# author: Qling
# date: 2021-04-03
# difficulty: Medium
# categories: Dynamic Programming
# link: <https://leetcode.com/problems/longest-common-subsequence/description/>
# hidden: true
# ---
#
# Given two strings `text1` and `text2`, return the length of their longest
# common subsequence.
#
# A _subsequence_ of a string is a new string generated from the original string
# with some characters(can be none) deleted without changing the relative order
# of the remaining characters. (eg, "ace" is a subsequence of "abcde" while
# "aec" is not). A _common subsequence_  of two strings is a subsequence that is
# common to both strings.
#
#
#
# If there is no common subsequence, return 0.
#
#
#
# **Example 1:**
#
#
#
#     Input: text1 = "abcde", text2 = "ace"
#     Output: 3
#     Explanation: The longest common subsequence is "ace" and its length is 3.
#
#
# **Example 2:**
#
#
#
#     Input: text1 = "abc", text2 = "abc"
#     Output: 3
#     Explanation: The longest common subsequence is "abc" and its length is 3.
#
#
# **Example 3:**
#
#
#
#     Input: text1 = "abc", text2 = "def"
#     Output: 0
#     Explanation: There is no such common subsequence, so the result is 0.
#
#
#
#
# **Constraints:**
#
#   * `1 <= text1.length <= 1000`
#   * `1 <= text2.length <= 1000`
#   * The input strings consist of lowercase English characters only.
#
#
## @lc code=start
using LeetCode

function longest_common_subsequence(itr1, itr2)::Int32
    m, n = length(itr1) + 1, length(itr2) + 1
    dp = fill(0, m, n)

    for i in 2:m, j in 2:n
        dp[i, j] = (itr1[i - 1] == itr2[j - 1]) ? (dp[i - 1, j - 1] + 1) : max(dp[i - 1, j], dp[i, j - 1])
    end

    return dp[m, n]
end
## @lc code=end


text:
# Incluimos el módulo que escribimos con el juego, y la biblioteca para trabajar con ventanas Gtk
include("gato.jl")
using .Gato
using Gtk.ShortNames

# Comienza un juego

t = nvo_juego()

# Esta función es la que hace que el juego y la interfaz se hablen. Se llama con la señal de un click sobre un botón.

button_clicked_cb(widget) = button_clicked_cb(widget, t)

function button_clicked_cb(widget, t::Tablero)
	# Pedimos la posicíon del click, que es el nombre del botón
	pos = getproperty(widget, :label, AbstractString)
	pos = Int(pos[1]) - 48 # Lo convertimos a un entero entre 1 y 9

	# Si el botón ya había sido escogido, no hace nada
	if !tiro_valido(t,pos)
		return
	end

	# Mandamos la posición del click a la función que actualiza el tiro. Regresa true si hubo un ganador.
	termina, ganador = turno(t, pos)

	# Si hay ganador:
	if termina
# 		info_dialog("Gana "*ganador*"!")
		Gtk.gtk_quit()
		println("Gana ", ganador, "!")
	end

	println(t)

	# Si no hubo ganador, incrementa el número de turnos, para terminar el juego si hubo empate.
	if t.cuenta_turnos < 8
		t.cuenta_turnos +=1
	else
# 		info_dialog("Empate!")
		Gtk.gtk_quit()
		println("Empate!")
	end

# 	caracter = t.representacion[pos]
# 	setproperty!(widget, :label, caracter)
end

include("gui.jl")

max_stars_repo_name: rodrigolece/juego-gato

max_issues_repo_name: rodrigolece/juego-gato

max_forks_repo_name: rodrigolece/juego-gato


text:
ClimateMachine.init()
const ArrayType = ClimateMachine.array_type()
const mpicomm = MPI.COMM_WORLD
const FT = Float64
Ω = Circle(-1,1) × Circle(-1,1) × Circle(-1,1)
dims = ndims(Ω)
ex, ey, ez = (3,4,2)
ClimateMachine.gpu_allowscalar(true)
# Define Grid: might want to loop over element sizes and polynomial orders
grid = DiscontinuousSpectralElementGrid(Ω, elements = (ex, ey, ez), polynomialorder = (1,3,2), array = ArrayType)

x, y, z = coordinates(grid)

xC, yC, zC = cellcenters(grid)

p = getperm(xC, yC, zC, ex, ey, ez)
newX = reshape(xC[p], (ex, ey, ez))
newY = reshape(yC[p], (ex, ey, ez))
newZ = reshape(zC[p], (ex, ey, ez))
lin = reshape(collect(1:length(xC)), (ex, ey, ez))

@testset "Unique Permutation" begin
    @test prod( sort(p) .== collect(1:length(p)))
end

@testset "Check lin" begin
    for i in 1:10
        rng = MersenneTwister(i);
        ix, iy, iz = rand(rng, 1:ex), rand(rng, 1:ey), rand(rng, 1:ez)
        ind = lin[ix, iy, iz]
        @test newX[ix, iy, iz] == xC[p[ind]]
        @test newY[ix, iy, iz] == yC[p[ind]]
        @test newZ[ix, iy, iz] == zC[p[ind]]
    end
end

@testset "Check Permutation" begin
    tol = eps(2.0)
    for i in 1:ex
        @test prod( abs.(newX[i, :, :] .- newX[i, 1, 1]) .< tol)
    end
    for i in 1:ey
        @test prod( abs.(newY[:, i, :] .- newY[1, i, 1]) .< tol)
    end
    for i in 1:ez
        @test prod( abs.(newZ[:, :, i] .- newZ[1, 1, i]) .< tol)
    end
end

max_stars_repo_name: CliMA/ImperoHooks

max_issues_repo_name: CliMA/ImperoHooks

max_forks_repo_name: CliMA/ImperoHooks


text:
### A Pluto.jl notebook ###
# v0.12.4

using Markdown
using InteractiveUtils

# ╔═╡ 4af16cf0-1e38-11eb-09fa-899a13969de5
using Genie

# ╔═╡ ba2c764e-1e38-11eb-11e4-1964cbc5ad18
using Genie.Router

# ╔═╡ 2d20c1b0-1e3a-11eb-080b-d1f8f0980523

# ╔═╡ ba15e10e-1e38-11eb-0fac-b3d9e5dfec95
route("/Ankit_hello") do
  "Hello - Welcome to Genie!"
end

# ╔═╡ b9fab7f0-1e38-11eb-1072-67c12e4288cc
up()

# ╔═╡ b9decb80-1e38-11eb-39c4-9142abc81d48

# ╔═╡ b9b3c3e0-1e38-11eb-1934-b37e8c24b84d

# ╔═╡ Cell order:
# ╠═2d20c1b0-1e3a-11eb-080b-d1f8f0980523
# ╠═4af16cf0-1e38-11eb-09fa-899a13969de5
# ╠═ba2c764e-1e38-11eb-11e4-1964cbc5ad18
# ╠═ba15e10e-1e38-11eb-0fac-b3d9e5dfec95
# ╠═b9fab7f0-1e38-11eb-1072-67c12e4288cc
# ╠═b9decb80-1e38-11eb-39c4-9142abc81d48
# ╠═b9b3c3e0-1e38-11eb-1934-b37e8c24b84d


text:
export ∫, StandardNormal

struct StandardNormal end

"""
    ∫(::StandardNormal, f::GP{<:EQ})

Return the scalar-valued process which results from computing the expectation of `f`, whose
mean and kernel are the zero-function and `EQ` resp., under a standard normal distribution.
"""
∫(::StandardNormal, f::GP{<:μFun, <:EQ}) = GP(∫, StandardNormal(), f)
μ_p′(::typeof(∫), ::StandardNormal, f::GP{<:μFun, <:EQ}) = ZeroMean()
k_p′(::typeof(∫), ::StandardNormal, f::GP{<:μFun, <:EQ}) = Finite(Constant(1 / sqrt(3)), [1])
k_pp′(f_p::GP, ::typeof(∫), ::StandardNormal, f::GP) =
    f_p === f ?
        RhsFinite((x, ::Any)->exp(-0.25 * x^2) / sqrt(2), [1]) :
        throw(error("Don't know how to compute xcovs for general graphs for integration."))
k_p′p(f_p::GP, ::typeof(∫), ::StandardNormal, f::GP) =
    f_p === f ?
        LhsFinite((::Any, x′)->exp(-0.25 * x′^2) / sqrt(2), [1]) :
        throw(error("Don't know how to compute xcovs for general graphs for integration."))


text:
struct DeltaMoment{T} <: GSAMethod
    nboot::Int
    conf_level::Float64
    Ygrid_length::Int
    num_classes::T
end
DeltaMoment(;nboot=500, conf_level=0.95, Ygrid_length=2048, num_classes=nothing) = DeltaMoment(nboot, conf_level, Ygrid_length, num_classes)

struct DeltaResult{T}
    deltas::T
    adjusted_deltas::T
    adjusted_deltas_low::T
    adjusted_deltas_hi::T
end
function _calc_delta(Xi, Y, Ygrid, class_cutoffs)

    # Make sure Ys are not identical, otherwise KDE will be undefined.
    # If Ys are identical, then we know X and Y are independent, so return 0
    if all(Y[1] .== Y)
            return 0
    end

    N = length(Y) # Number of simulations
    @assert length(Xi) == N # Length of Y should equal length of X

     # Model pdf of Y using KDE, kde uses normal kernel by default
    fy = pdf(kde(Y), Ygrid) # eq 23.1

    # Get probability of each y in Ygrid.
    x_rank = competerank(Xi) # Does what scipy.stats rankdata does. If tie, all tied values get same rank.
    d_hat = 0 # the delta estimator.

    # Iterate over each class
    weighted_class_seps = zeros(length(class_cutoffs)-1)
    for j in 1:length(class_cutoffs)-1
        # get X and Y indicies for samples that are in this class (where
        # class designation is based on the X value)
        condition(x) = (x > class_cutoffs[j]) ==  (x <= class_cutoffs[j+1])
        in_class_indices = findall(condition, x_rank)
        number_in_class = length(in_class_indices)
        # Get the the subset of Y values in this class
        in_class_Y = Y[in_class_indices]
        if length(in_class_Y) == 0
                continue
        end
        # get the separation between the total y pdf and the condition y pdf induced by this class
        fyc = pdf(kde(in_class_Y), Ygrid) # eq 23.2 - Estimated conditional distribution of y (using normal kernel)
        pdf_diff = abs.(fy .- fyc) # eq 24
        # Use trapezoidal rule to estimate the difference between the curves.
        class_separation = trapz(Ygrid, pdf_diff) # eq 25
        # Increment estimator
        weighted_class_seps[j] = number_in_class * class_separation # eq 26
    end

    d_hat = sum(weighted_class_seps)/(2*N)
    return d_hat
end

function gsa(f, method::DeltaMoment, p_range; N, batch = false, rng::AbstractRNG = Random.default_rng(), kwargs...)
    lb = [i[1] for i in p_range]
    ub = [i[2] for i in p_range]
    X = QuasiMonteCarlo.sample(N, lb, ub, QuasiMonteCarlo.SobolSample())
    # Create number of classes and class cutoffs.
    if method.num_classes === nothing
        exp = (2 / (7 + tanh((1500 - N) / 500)))
        M = Integer(round(min(Integer(ceil(N^exp)), 48))) # Number of classes
    else
        M = num_classes
    end
    class_cutoffs =  range(0, N, length=M+1) # class cutoffs.

    if batch
        Y = f(X)
        multioutput = Y isa AbstractMatrix
        if multioutput
            throw(ArgumentError("DeltaMoment sensitivity only supports scalar output functions"))
        end
    else
        Y = [f(X[:, j]) for j in axes(X, 2)]
        multioutput = !(eltype(Y) <: Number)
        if eltype(Y) <: RecursiveArrayTools.AbstractVectorOfArray
            y_size = size(Y[1])
            Y = vec.(Y)
            desol = true
        end
        if multioutput
            throw(ArgumentError("DeltaMoment sensitivity only supports scalar output functions"))
        end
    end

    # quadrature points.
    # Length should be a power of 2 for efficient FFT in kernel density estimates.
    Ygrid = range(minimum(Y), maximum(Y), length = method.Ygrid_length)

    num_factors = size(X, 1)

    deltas = zeros(num_factors)
    adjusted_deltas = zeros(num_factors)
    adjusted_deltas_conf = zeros(num_factors)
    adjusted_deltas_low = zeros(num_factors)
    adjusted_deltas_high = zeros(num_factors)

    for factor_num in 1:num_factors
        Xi = view(X, factor_num, :)
        delta = _calc_delta(Xi, Y, Ygrid, class_cutoffs)
        deltas[factor_num] = delta
        # eq. 30, bias reduction via bootstrapping.
        bootstrap_deltas = zeros(method.nboot)
        r = rand(rng, 1:N, method.nboot, N)
        for i in 1:method.nboot
            r_i = r[i, :]
            bootstrap_deltas[i] = _calc_delta(Xi[r_i], Y[r_i], Ygrid, class_cutoffs)
        end
        adjusted_deltas[factor_num] = 2 * delta - mean(bootstrap_deltas)
        band = quantile(Normal(0.0, 1.0), 0.5+method.conf_level/2)*std(bootstrap_deltas)/(sqrt(method.nboot))
        adjusted_deltas_low[factor_num] = adjusted_deltas[factor_num] - band
        adjusted_deltas_high[factor_num] = adjusted_deltas[factor_num] + band
    end

    return DeltaResult(deltas, adjusted_deltas, adjusted_deltas_low, adjusted_deltas_high)
end


text:
function _precompile_()
    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing

    # for T in (Float32, Float64)
    #     precompile(Tuple{typeof(lsqnonneg), Matrix{T}, Vector{T}})
    #     precompile(Tuple{typeof(lsqnonneg_reg), Matrix{T}, Vector{T}, T})
    #     precompile(Tuple{typeof(lsqnonneg_lcurve), Matrix{T}, Vector{T}})
    #     precompile(Tuple{typeof(EPGdecaycurve), Int, T, T, T, T, T})
    #     precompile(Tuple{typeof(T2mapSEcorr), Array{T,4}})
    #     precompile(Tuple{typeof(T2partSEcorr), Array{T,4}})
    # end

    for T in (Float32, Float64)
        precompile(Tuple{typeof(sorted_arg_table_entries), T2mapOptions{T}, T2partOptions{T}})
    end
    precompile(Tuple{typeof(get_parsed_args_subset), Dict{Symbol,Any}, Dict{Symbol,Type}})
    precompile(Tuple{typeof(create_argparse_settings)})
    precompile(Tuple{typeof(ArgParse.parse_args), Vector{String}, ArgParse.ArgParseSettings})
    # precompile(Tuple{typeof(main), Vector{String}})
end


text:
using Documenter
using DustExtinction

DocMeta.setdocmeta!(DustExtinction, :DocTestSetup, :(using DustExtinction); recursive = true)

makedocs(modules = [DustExtinction],
    sitename = "DustExtinction.jl",
    format = Documenter.HTML(prettyurls = get(ENV, "CI", nothing) == "true"),
    authors = "Kyle Barbary, Mosé Giordano, Miles Lucas",
    pages = [
        "Home" => "index.md",
        "Color Laws" => "color_laws.md",
        "Dust Maps" => "dust_maps.md"
    ],
)

deploydocs(repo = "github.com/JuliaAstro/DustExtinction.jl.git", push_preview = true)


text:
# timestamp.jl
#
#   Convert difference timestamps
#
# Jeremy Rüffer
# Thünen Institut
# Institut für Agrarklimaschutz
# Junior Research Group NITROSPHERE
# Julia 0.6
# 12.05.2017
# Last Edit: 18.06.2018

# include("/home/jeremy/BF-Eddy/Code/Julia/Jeremy/timestamp.jl")

VERSION >= v"0.7-alpha.0" ? using Dates : nothing

"""# timestamp

Parse to and from various timestamp formats: Aerodyne, Licor, and LGR (Los Gatos Research)

See the following functions for more information:
* **timestamp_aerodyne**
* **timestamp_licor**
* **timestamp_lgr**
"""
function timestamp()

end

"""# timestamp_aerodyne

Parse an Aerodyne timestamp to DateTime and vise versa

---

### Examples

`time = timestamp_aerodyne(3577305600.510)`\n
`05/11/2017 00:00:00.51`\n

---

`time = timestamp_aerodyne(DateTime(2017,5,11,0,0,0,510))`\n
`3577305600.510`\n

---

### Function Definitions

`time = timestamp_aerodyne(t::Number)`\n
* **t**::Number = Aerodyne timestamp
* **time**::DateTime = Converted timestamp

`time = timestamp_aerodyne(t::DateTime)`\n
* **t**::DateTime = Aerodyne timestamp
* **time**::Float64 = Converted timestamp
"""
function timestamp_aerodyne(t::Number)
	# t = 3577305600.510040 # 05/11/2017 00:00:01
	epoch_aerodyne = DateTime(1904,1,1,0,0,0)

	#secs = Dates.Second(floor(t))
	#millisecs = Dates.Millisecond(floor(1000(t - floor(t))))
	#time = epoch_aerodyne + secs + millisecs
	return epoch_aerodyne + Dates.Second(floor(t)) + Dates.Millisecond(floor(1000(t - floor(t))))
end

# t = DateTime(2017,4,26,9)
function timestamp_aerodyne(t::DateTime)
	epoch_aerodyne = DateTime(1904,1,1,0,0,0)
	return convert(Float64,Dates.value(t - epoch_aerodyne))/1000
end

"""# timestamp_licor

Parse an Licor timestamp to DateTime and vise versa

---

### Examples

`time = timestamp_licor(1481490002,550000000)`\n
`2016-12-11T22:00:02.05`\n

---

`seconds, nanoseconds = timestamp_licor(DateTime(2016,12,11,22,0,2,50))`\n
`1481490002,550000000`\n

---

### Function Definitions

`time = timestamp_licor(s::Number,ns::Number)`\n
* **s**::Number = Seconds
* **ns**::Number = Nanoseconds
* **time**::DateTime = Converted timestamp

`s, ns = timestamp_licor(t::DateTime)`\n
* **s**::Number = Seconds
* **ns**::Number = Nanoseconds
* **time**::DateTime = Converted timestamp
"""
function timestamp_licor(s::Number,ns::Number)
	# s = 1481490002.0 # Seconds
	# ns = 550000000.0 # Nanoseconds
	# 	=> 2016-12-11T22:00:02.55
	epoch_licor = DateTime(1970,1,1,1)
	return epoch_licor + Dates.Second(s) + Dates.Millisecond(floor(ns/1e6))
end

function timestamp_licor(t::DateTime)
	epoch_licor = DateTime(1970,1,1,1)
	s = convert(Float64,Dates.value(t - epoch_licor))/1000
	ns = 1e9s - 1e9floor(s)
	s = floor(s)
	return s, ns
end

"""# timestamp_lgr

Parse an LGR (Los Gatos Research) timestamp to DateTime and vise versa

---

### Examples

`time = timestamp_lgr("15/05/2017 15:13:47.994")`\n
`2017-15-05T15:13:47.994`\n

---

`time = timestamp_lgr(DateTime(2017,5,15,15,13,47,993))`\n
`"15/05/2017 15:13:47.994"`\n

---

### Function Definitions

`time = timestamp_lgr(t::String)`\n
* **t**::String = LGR Timestamp
* **time**::DateTime = Converted timestamp

`time = timestamp_lgr(t::DateTime)`\n
* **t**::DateTime = DateTime timestamp
* **time**::String = Converted timestamp
"""
function timestamp_lgr(t::String)
	# x = "30/01/2015 15:13:47.994"
	dfmt = Dates.DateFormat("dd/mm/yyyy HH:MM:SS.sss")
	return DateTime(t,dfmt)
end

function timestamp_lgr(t::DateTime)
	dfmt = Dates.DateFormat("dd/mm/yyyy HH:MM:SS.sss")
	return Dates.format(t,dfmt)
end


text:
######### gradle-to-gate calculation

# the direct requirements coefficients
A = [0.4  0.2  0.1 ;  # 1/Manufacturing/US
     0.2  0.1  0.1 ;  # 2/Transport/US
     0.3  0.3  0.2 ]  # 3/Energy/US

# the satellite table
B = [2.0  0.5  1]     # CO2

# the demand vector
f = [200.0 ;
       0.0 ;
      50.0 ]

# the scaling vector
I = eye(size(A)[1])
s = (I - A) \ f

# the total LCI result
g = B * s  # 1163.27 kg CO2

# the direct contribution results
G = B * diagm(s)   # [836.735  61.2245  265.306]  kg CO2

######### additional requirements in the distribution phase

# additional requirements matrix of the distribution phase
K = [ 0.0  0.0  0.0 ;  # 1/Manufacturing/US
      0.3  0.0  0.1 ;  # 2/Transport/US
      0.0  0.0  0.0 ]  # 3/Energy/US

# demand vector of the distribution phase
fd = K * f  # [0.0  65.0  0.0]'

# the scaling vector of the distribution phase
sd = (I - A) \ fd

# the total LCI result of the distribution phase
gd = B * sd  # 160.131 kg CO2

# the direct contribution results of the distribution phase
Gd = B * diagm(sd)   # [72.0117  42.6385  45.481]  kg CO2

######### additional emissions in the distribution phase

Bd = [ 0.0  0.0  5.0]  # kg CO2

gd2 = Bd * f   # 250.0 kg CO2

Gd2 = Bd * diagm(f)  # [0.0  0.0  250.0] kg CO2

max_stars_repo_name: USEPA/IO-Model-Builder

max_issues_repo_name: USEPA/IO-Model-Builder

max_forks_repo_name: USEPA/IO-Model-Builder


text:
@tags html head body title meta div p h1 h2 h3 h4 h5 hr intro table thead tbody tr th td img a
@tags_noescape script style
@tags intro

function _webgen_offline_css(path_web)
    sheet_urls_css = [
        "cdn/css/",
        "https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.1.1/css/bootstrap.css",
        "https://cdn.datatables.net/1.10.19/css/dataTables.bootstrap4.min.css",
        "https://cdn.datatables.net/v/bs4/dt-1.10.18/b-1.5.2/b-html5-1.5.2/fc-3.2.5/fh-3.1.4/sc-1.5.0/datatables.min.css"
    ]

    for sheet_urls in sheet_urls_css
        dir  = sheet_urls[1]
        urls = sheet_urls[2:end]
        file_names = basename.(urls)
        file_paths = string.(path_web, dir, file_names)
        println(file_paths)
    end
end

function _webgen_offline_s(path_web)
    sheet_urls_js  = [
        "cdn/js/",
        "https://code.jquery.com/jquery-3.3.1.js",
        "https://cdn.datatables.net/1.10.19/js/jquery.dataTables.min.js",
        "https://cdn.datatables.net/1.10.19/js/dataTables.bootstrap4.min.js",
        "https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.1.36/pdfmake.min.js",
        "https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.1.36/vfs_fonts.js",
        "https://cdn.datatables.net/v/bs4/dt-1.10.18/b-1.5.2/b-html5-1.5.2/fc-3.2.5/fh-3.1.4/sc-1.5.0/datatables.min.js"
    ]

    for sheet_urls in sheet_urls_js
        dir  = sheet_urls[1]
        urls = sheet_urls[2:end]
        file_names = basename.(urls)
        file_paths = string.(path_web, dir, file_names)
        println(file_paths)
    end
end

function _webgen_head(;title_in="")
    node = m("head",
        m("title", title_in),
        m("meta"; charset="utf-8"),
        m("link"; rel="stylesheet", :type=>"text/css", href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.1.1/css/bootstrap.css"),
        m("link"; rel="stylesheet", :type=>"text/css", href="https://cdn.datatables.net/1.10.19/css/dataTables.bootstrap4.min.css"),
        m("link"; rel="stylesheet", :type=>"text/css", href="https://cdn.datatables.net/v/bs4/dt-1.10.18/b-1.5.2/b-html5-1.5.2/fc-3.2.5/fh-3.1.4/sc-1.5.0/datatables.min.css"),
        m("style"; :type=>"text/css", class="init"),
        m("script"; :type=>"text/javascript", language="javascript", src="https://code.jquery.com/jquery-3.3.1.js"),
        m("script"; :type=>"text/javascript", language="javascript", src="https://cdn.datatables.net/1.10.19/js/jquery.dataTables.min.js"),
        m("script"; :type=>"text/javascript", language="javascript", src="https://cdn.datatables.net/1.10.19/js/dataTables.bootstrap4.min.js"),
        m("script"; :type=>"text/javascript", src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.1.36/pdfmake.min.js"),
        m("script"; :type=>"text/javascript", src="https://cdnjs.cloudflare.com/ajax/libs/pdfmake/0.1.36/vfs_fonts.js"),
        m("script"; :type=>"text/javascript", src="https://cdn.datatables.net/v/bs4/dt-1.10.18/b-1.5.2/b-html5-1.5.2/fc-3.2.5/fh-3.1.4/sc-1.5.0/datatables.min.js"),
        m("script"; :type=>"text/javascript", class="init"),
        script("
        \$(document).ready(function() {
            \$('#example').DataTable();
        } );"; :type=>"text/javascript", class="init")
    )
end

function _webgen_home_intro(mission_name::String)
    node_intro = intro(
        m("div"; class="se-pre-con"),
        div(class="container",
            m("div"; class="container"),
            m("h1", "JAXTAM.jl WebView - $mission_name"),
            m("hr"),
            m("p", "JAXTAM reports summary page for $mission_name")
        )
    )
end

function _add_obsid_url(df::DataFrames.DataFrame, path_web)
    obsid_url = Array{Union{Hyperscript.Node{Hyperscript.HTMLSVG},String},1}(undef, size(df, 1))

    report_path_rel = replace.(df[:report_path], path_web=>"./")

    obsid_url[  df[:report_exists]] = [a(df[i, :obsid], href=report_path_rel[i]) for i in findall(df[:report_exists])]
    obsid_url[.!df[:report_exists]] = df[.!df[:report_exists], :obsid]

    return obsid_url
end

function _webgen_table(df::DataFrames.DataFrame, path_web; table_id="example")
    # Replaces plain string obsid with hyperlink to the report
    if haskey(df, :obsid)
        obsid_url = _add_obsid_url(df, path_web)
        deletecols!(df, [:obsid, :report_path])
        df[:obsid] = obsid_url
        permutecols!(df, [:obsid; names(df)[1:end-1][:]])
    end

    if haskey(df, :countrate)
        df[:countrate][df[:countrate] .== Inf] .= -2.0
        df[:countrate][isnan.(df[:countrate])] .= -3.0
        df[:countrate] = round.(Int, df[:countrate])
    end

    if haskey(df, :time) && table_id=="report_page"
        # Include MJD time in report summary
        df[:time] = string.(df[:time], " | ", round.(JAXTAM._datetime2mjd.(convert.(Dates.DateTime, df[:time])), digits=6), " (MJD 6dp)")
    end

    rows, cols = size(df)
    headers = names(df)

    replace!(headers, :subject_category=>:cat)
    replace!(headers, :reports_exist=>:report)

    node_table = div(class="container",
        table(id=table_id, class="table table-striped table-bordered", style="width:100%",
            thead(
                tr(
                    th.(headers)
                )
            ),
            tbody(
                tr.([td.([df[r, c] for c in 1:cols]) for r in 1:rows])
            )
        )
    )
end

function _webgen_table(df_row::DataFrames.DataFrameRow, path_web; table_id="example")
    df = DataFrame(Dict(zip(keys(df_row), values(df_row)))) # Convert DataFrameRow to DataFrame for table gen

    return _webgen_table(df, path_web; table_id=table_id)
end

function webgen_mission(mission::Mission; master_cache=false)
    c = 0

    master_df = master(mission, cache=master_cache)

    included_cols = [
        :name,
        :obsid,
        :subject_category,
        :obs_type,
        :publicity,
        :downloaded,
        :time,
        :report_path,
        :report_exists
    ]

    if haskey(master_df, :countrate)
        append!(included_cols, [:countrate])

        countrate = master_df[:countrate]
        countrate = floor.(Int, countrate)
    end

    html_out = html(
        _webgen_head(;title_in="JAXTAM $(_mission_name(mission)) homepage"),
        body(
            _webgen_home_intro(_mission_name(mission)),
            _webgen_table(master_df[:, included_cols], mission_paths(mission).web)
        )
    )

    path_web_mission = joinpath(mission_paths(mission).web, "index.html")

    write(path_web_mission, string(Pretty(html_out)))

    return path_web_mission
end