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

using Markdown
using InteractiveUtils

# ╔═╡ d3e1eb22-9a63-11ec-27a9-43c3ded20267
using DataFrames, CSV, Downloads, Dates, ShiftedArrays, WorldBankData

# ╔═╡ 45feeff5-5c9d-42e4-ba63-c25ca387fefe
using FixedEffectModels, RegressionTables

# ╔═╡ 82ff3ce4-4f3c-414d-8f6a-57cfec9fe65b
using Makie, CairoMakie

# ╔═╡ 0f14368c-6e71-4cd5-86fa-df85081229b8
using Statistics

# ╔═╡ cabd4851-d3a6-43a4-9655-40b3d4b09eee
md"""
This notebook reproduces and improves some results from [Chisadza et al (2021)](https://www.mdpi.com/2071-1050/13/6/3042/htm).

"""

# ╔═╡ cd54e8bc-ecb2-4455-bda0-b89ab41cca30
md"""
# Data

The main source of data is the [Oxford Covid Government Response Tracker (OxCGRT)](https://www.bsg.ox.ac.uk/research/research-projects/covid-19-government-response-tracker).
"""

# ╔═╡ 2130f4e4-45fa-47f6-9412-57f2e9d662d5
ox = let
	url = "https://github.com/OxCGRT/covid-policy-tracker/raw/master/data/OxCGRT_latest.csv"
	CSV.read(Downloads.download(url), DataFrame)
end

# ╔═╡ c845fdde-bb29-4fc3-a744-80002bed5111
describe(ox)

# ╔═╡ 189fde90-f8ad-4a5c-9566-cad610830a26
begin

"""
    panellag(x::Symbol, data::AbstractDataFrame, id::Symbol, t::Symbol,
              lags::Integer=1)
Create lags of variables in panel data.
# Arguments
- `x` variable to create lag of
- `data` DataFrame containing `x`, `id`, and `t`
- `id` cross-section identifier
- `t` time variable
- `lags` number of lags. Can be negative, in which cause leads will
   be created
# Returns
- A vector containing lags of data[x]. Will be missing for `id` and
  `t` combinations where the lag is not contained in `data`.
"""
function panellag(x::Symbol, data::AbstractDataFrame, id::Symbol, t::Symbol,
                   lags::Integer=1)
  if (!issorted(data, [id, t]))
    @warn "data is not sorted, panellag() will be more efficient with a sorted DataFrame"
    p = sortperm(data, [id, t])
    df = data[p,:]
  else
    p = nothing
    df = data
  end
  idlag= ShiftedArrays.lag(df[!,id], lags)
  tlag = ShiftedArrays.lag(df[!,t], lags)
  xlag = ShiftedArrays.lag(df[!,x], lags)
  xlag = copy(xlag)
  xlag[ ismissing.(tlag) .|
        (tlag .!= df[!,t].-lags) .|
        (idlag .!= df[!,id]) ] .= missing
  if (p == nothing)
    return(xlag)
  else
    xout = similar(xlag)
    xout[p] .= xlag
    return(xout)
  end
end

function panellag(x::AbstractArray, id::AbstractVector, t::AbstractVector,
                  lags::Integer=1)
  idlag= ShiftedArrays.lag(id, lags)
  tlag = ShiftedArrays.lag(t, lags)
  xlag = copy(ShiftedArrays.lag(x, lags))
  xlag[ ismissing.(tlag) .|
        (tlag .!= t.-lags) .|
        (idlag .!= id) ] .= missing
  return(xlag)
end

end

# ╔═╡ 858035fe-22e5-4a6b-9129-107777496234
md"""

We obtain country GDP, population, Diabetes prevalence, hospital beds, and old age dependency ratio (Chisadza et al (2021) uses median age, but we could not find such a variable) from the World Bank.
"""

# ╔═╡ 075ca6b5-5e09-474a-aecb-9fac1673bca7
wbdf = let
	wbvars = Dict(:GDPpc => "NY.GDP.PCAP.CD",
		 	:Diabetes_prevalence => "SH.STA.DIAB.ZS",
		 	:Old_age_DR => "SP.POP.DPND.OL",
		 	:Hospital_bed_per1000 => "SH.MED.BEDS.ZS",
			:Population => "SP.POP.TOTL")
	inds = [values(wbvars)...]
	wbdf = wdi(inds, "all", 2009, 2019)
	gwdf = groupby(wbdf, :country)
	function foo(x)
		cx = collect(skipmissing(x))
		if length(cx)==0
			return(missing)
		else
			return(last(cx))
		end
	end
	gwdf
	combine(gwdf, Symbol.(replace.(values(wbvars), r"\." => s"_")) .=> foo .=> keys(wbvars))
end

# ╔═╡ ef58ffa9-08a7-4dfa-a9ed-17b0c561da70
gmr = let
	#url = "https://www.gstatic.com/covid19/mobility/Global_Mobility_Report.csv"
	#gmr=CSV.read(Downloads.download(url), DataFrame)
	#filter(r->ismissing(r.sub_region_1),gmr)
	nothing
end;

# ╔═╡ fcb62e62-178b-461c-90e8-dd89494cd2c3
md"""
## Data Preparation
"""

# ╔═╡ 19c54112-1e98-4e08-84e5-03df35f18c5f
ox0 = let
	function datefromint(d)
		y, r= divrem(d,10000)
		return(Date(y, divrem(r, 100)...))
	end
	ox.date = datefromint.(ox.Date)
	df = filter(x->x.Jurisdiction.=="NAT_TOTAL", ox)
	df.t = Dates.value.(df.date - Date(2020,1,1))
	sort!(df, [:CountryCode, :t])
	df.deaths = df.ConfirmedDeaths - panellag(:ConfirmedDeaths, df, :CountryCode, :t)
	df.cases = df.ConfirmedCases - panellag(:ConfirmedCases, df, :CountryCode, :t)
	df.deathslag = panellag(:deaths, df, :CountryCode, :t)
	leftjoin(df, wbdf, on = :CountryName => :country)
end;

# ╔═╡ c56f41a6-e62f-4399-a34e-732f01520667
ox1 = let
	ox1 = deepcopy(ox0)
	ox1.deaths = (ox1.ConfirmedDeaths - panellag(:ConfirmedDeaths, ox1, :CountryCode, :t, 1))./1
	ox1.cases = (ox1.ConfirmedCases - panellag(:ConfirmedCases, ox1, :CountryCode, :t, 1))./1
	ox1.deaths = max.(ox1.deaths,0)
	ox1.cases = max.(ox1.cases,0)
	ox1.casesp100k = ox1.cases./(ox1.Population/1e5)
	ox1.deathspm = ox1.deaths./(ox1.Population/1e6)
	ox1.deathspmlag = panellag(:deathspm, ox1, :CountryCode, :t, 1)
	ox1.indexlag21 = panellag(:StringencyIndex, ox1, :CountryCode, :t, 21)
	ox1.deathslag21 = panellag(:deathspm, ox1, :CountryCode, :t, 21)
	ox1.casesp100klag21 = panellag(:casesp100k, ox1, :CountryCode, :t, 21)
	ox1.logdeathspm = log.(ox1.deathspm.+1e-6)
	ox1.deathpmgrowth = log.(ox1.deathspm.+1e-6) - log.(panellag(:deathspm, ox1, :CountryCode, :t, 1).+1e-6) #./
	ox1.deathgrowth = log.(ox1.deaths.+1) - log.(panellag(:deaths, ox1, :CountryCode, :t, 1).+1)
	  #(panellag(:deaths, ox1, :CountryCode, :t, 7) .+ 1)
	#ox1.deathgrowth = min.(ox1.deathgrowth,10.0)
	ox1 = filter(x->((x.date.>=Date(2020,03,1)) .& (x.date .< Date(2020,10,1))), ox1)
	#ox1 = leftjoin(ox1, gmr, on=[:CountryName=>:country_region,:date=>:date])
end;

# ╔═╡ c7664c08-a426-450d-b455-4da3ccb9c829
md"""
# Analysis

## Chisadza results

The table below shows two specifications similar to Table 1 of Chisadza et al (2021). Column (1) regresses daily deaths per million on current stringency index, one-day lagged deaths per million, and controls. Unlike Chisadza et al (2021), we estimate a linear regression instead of a Poisson regression. Column (2) is similar, but with log deaths per million. In both columns, we see that a higher current stringency index is associated with more current deaths.

"""

# ╔═╡ c3aad65d-198a-48ff-996d-b5ed3268a522
let
	chisadza_lm = reg(ox1, @formula(deathspm ~ StringencyIndex + deathspmlag +
		log(GDPpc) + Diabetes_prevalence + Hospital_bed_per1000 + Old_age_DR
	), Vcov.cluster(:CountryCode))

	#chisadza_iid = reg(ox1, @formula(deathspm ~ StringencyIndex + deathspmlag +
	#	log(GDPpc) + Diabetes_prevalence + Hospital_bed_per1000 + Old_age_DR
	#))

	chisadza_log = reg(ox1, @formula(logdeathspm ~ StringencyIndex + log(deathspmlag+1e-6) +
	log(GDPpc) + Diabetes_prevalence + Hospital_bed_per1000 + Old_age_DR
), Vcov.cluster(:CountryCode))
	regtable(chisadza_lm, chisadza_log,
		renderSettings=latexOutput("chisadza.tex"),estimformat="%.3g")
	io = IOBuffer()
	regtable(chisadza_lm, chisadza_log, renderSettings=htmlOutput(), out_buffer=io,
		estimformat="%.3g")
	table=HTML(String(take!(io)))
end

# ╔═╡ 886dc221-4a45-4454-9062-a0adfd81d519
md"""

The table below shows results when we allow for a 21 day lag between policy changes and deaths. Column (1) has deaths per million as the dependent variable. Column (2) has log deaths per million as the dependent variable. These columns show a positive association between stringency and deaths. However, the specification in these columns is not well-motivated by epidemiology. Basic epidemiological models imply that changes in the contact rate between people should affect the **growth rate** of disease, not the level.

Columns (4)-(6) have the daily change in log deaths (which is approximately the growth rate of deaths) as the dependent variable. Here, we find a negative association between stringency and death growth. The magnitude of the coefficient is substantial. The average death growth rate is 0.0059. Thus, the estimates imply that going from a stringency of 0 to 100 would almost completely eliminate the growth in deaths.
"""

# ╔═╡ 022eebe9-e173-443e-a48e-e0c5845337bc
let
	lag = reg(ox1, @formula(deathspm ~ indexlag21 + deathslag21 +
		log(GDPpc) + Diabetes_prevalence + Hospital_bed_per1000 + Old_age_DR
	), Vcov.cluster(:CountryCode))
	laglog2 = reg(ox1, @formula(logdeathspm ~ indexlag21 + log(deathslag21+1e-6) +
	log(casesp100klag21+1) + casesp100klag21 + deathslag21 +
		log(GDPpc) + Diabetes_prevalence + Hospital_bed_per1000 + Old_age_DR
	), Vcov.cluster(:CountryCode))
	laglog = reg(ox1, @formula(logdeathspm ~ indexlag21 + log(deathslag21+1e-6) +
		log(GDPpc) + Diabetes_prevalence + Hospital_bed_per1000 + Old_age_DR
	), Vcov.cluster(:CountryCode))
	growth = reg(ox1, @formula(deathgrowth ~ indexlag21 + deathslag21 +
		log(GDPpc) + Diabetes_prevalence + Hospital_bed_per1000 + Old_age_DR
	), Vcov.cluster(:CountryCode))
	growth2 = reg(ox1, @formula(deathgrowth ~ indexlag21 + deathslag21 + log(deathslag21+1e-6) +
		log(GDPpc) + Diabetes_prevalence + Hospital_bed_per1000 + Old_age_DR
	), Vcov.cluster(:CountryCode))
	growth3 = reg(ox1, @formula(deathgrowth ~ indexlag21 + deathslag21 + log(deathslag21+1e-6) + casesp100klag21 + log(casesp100klag21 + 1) +
		log(GDPpc) + Diabetes_prevalence + Hospital_bed_per1000 + Old_age_DR
	), Vcov.cluster(:CountryCode))
	regtable(lag, laglog, laglog2, growth,growth2, growth3,
		renderSettings=latexOutput("lag.tex"), estimformat="%.3g")
	io = IOBuffer()
	regtable(lag, laglog, laglog2, growth,growth2, growth3, renderSettings=htmlOutput(), out_buffer=io, estimformat="%.3g")
	table=HTML(String(take!(io)))
end

# ╔═╡ 584e79e9-2df9-458a-aca5-e230de4d951b
mean(skipmissing(ox1.deathgrowth))

# ╔═╡ 95f2b750-876b-44f4-a457-f3089ccfdec2
let
	df = #filter(r->(!ismissing(r.ConfirmedDeaths) && r.ConfirmedDeaths≥1000), ox1)
		filter(r->(r.date >= Date(2020,3,01)), ox1)
	fig = Figure()
	first = true
	for g in groupby(df, [:CountryCode])
		if first
			lines(fig[1,1], g.t, g.StringencyIndex)
			first = false
		else
			lines!(fig[1,1], g.t, g.StringencyIndex)
		end
	end
	scatter(fig[2,1], df.t, df.deathgrowth)
	fig
end

# ╔═╡ 54fb7fbc-ba4b-45d9-b8d4-f089ba1a49d3
hist(collect(skipmissing(ox1.deathgrowth)),bins=100)

# ╔═╡ 50fdce71-2d0f-4d21-a2af-21ceec8f9695
let
	g = groupby(ox1, [:CountryCode])
	df = combine(g, :StringencyIndex => mean, :ConfirmedDeaths=>last, :Population=>last)
	fig = Figure()
	df.deaths_per_million = df.ConfirmedDeaths_last./df.Population_last*1e6
	scatter(fig[1,1],df.StringencyIndex_mean, df.deaths_per_million)
	for r in eachrow(df)
		if !ismissing(r.StringencyIndex_mean) && !ismissing(r.deaths_per_million)
			text!(fig[1,1],r.CountryCode, position=Point(r.StringencyIndex_mean, r.deaths_per_million))
		end
	end
	fig
	#reg(df, @formula(ConfirmedDeaths_last ~ StringencyIndex_sum))
	#df
end

# ╔═╡ 00000000-0000-0000-0000-000000000001
PLUTO_PROJECT_TOML_CONTENTS = """
[deps]
CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
CairoMakie = "13f3f980-e62b-5c42-98c6-ff1f3baf88f0"
DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
Downloads = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
FixedEffectModels = "9d5cd8c9-2029-5cab-9928-427838db53e3"
Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"
RegressionTables = "d519eb52-b820-54da-95a6-98e1306fdade"
ShiftedArrays = "1277b4bf-5013-50f5-be3d-901d8477a67a"
Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
WorldBankData = "2ff30676-a39f-58b2-ad74-5d1012d57b9b"

[compat]
CSV = "~0.10.2"
CairoMakie = "~0.7.4"
DataFrames = "~0.22.7"
FixedEffectModels = "~1.6.3"
Makie = "~0.16.5"
RegressionTables = "~0.5.3"
ShiftedArrays = "~1.0.0"
WorldBankData = "~0.4.1"
"""

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

julia_version = "1.7.2"
manifest_format = "2.0"

[[deps.AbstractFFTs]]
deps = ["ChainRulesCore", "LinearAlgebra"]
git-tree-sha1 = "6f1d9bc1c08f9f4a8fa92e3ea3cb50153a1b40d4"
uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c"
version = "1.1.0"

[[deps.AbstractTrees]]
git-tree-sha1 = "03e0550477d86222521d254b741d470ba17ea0b5"
uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
version = "0.3.4"

[[deps.Adapt]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "af92965fb30777147966f58acb05da51c5616b5f"
uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
version = "3.3.3"

[[deps.Animations]]
deps = ["Colors"]
git-tree-sha1 = "e81c509d2c8e49592413bfb0bb3b08150056c79d"
uuid = "27a7e980-b3e6-11e9-2bcd-0b925532e340"
version = "0.4.1"

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

[[deps.ArrayInterface]]
deps = ["Compat", "IfElse", "LinearAlgebra", "Requires", "SparseArrays", "Static"]
git-tree-sha1 = "d49f55ff9c7ee06930b0f65b1df2bfa811418475"
uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
version = "4.0.4"

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

[[deps.Automa]]
deps = ["Printf", "ScanByte", "TranscodingStreams"]
git-tree-sha1 = "d50976f217489ce799e366d9561d56a98a30d7fe"
uuid = "67c07d97-cdcb-5c2c-af73-a7f9c32a568b"
version = "0.8.2"

[[deps.AxisAlgorithms]]
deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"]
git-tree-sha1 = "66771c8d21c8ff5e3a93379480a2307ac36863f7"
uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950"
version = "1.0.1"

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

[[deps.Bzip2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "19a35467a82e236ff51bc17a3a44b69ef35185a2"
uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0"
version = "1.0.8+0"

[[deps.CEnum]]
git-tree-sha1 = "215a9aa4a1f23fbd05b92769fdd62559488d70e9"
uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82"
version = "0.4.1"

[[deps.CSV]]
deps = ["CodecZlib", "Dates", "FilePathsBase", "InlineStrings", "Mmap", "Parsers", "PooledArrays", "SentinelArrays", "Tables", "Unicode", "WeakRefStrings"]
git-tree-sha1 = "9519274b50500b8029973d241d32cfbf0b127d97"
uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
version = "0.10.2"

[[deps.Cairo]]
deps = ["Cairo_jll", "Colors", "Glib_jll", "Graphics", "Libdl", "Pango_jll"]
git-tree-sha1 = "d0b3f8b4ad16cb0a2988c6788646a5e6a17b6b1b"
uuid = "159f3aea-2a34-519c-b102-8c37f9878175"
version = "1.0.5"

[[deps.CairoMakie]]
deps = ["Base64", "Cairo", "Colors", "FFTW", "FileIO", "FreeType", "GeometryBasics", "LinearAlgebra", "Makie", "SHA", "StaticArrays"]
git-tree-sha1 = "aedc7c910713eb616391cf95218277b714a7913f"
uuid = "13f3f980-e62b-5c42-98c6-ff1f3baf88f0"
version = "0.7.4"

[[deps.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 = "4b859a208b2397a7a623a03449e4636bdb17bcf2"
uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a"
version = "1.16.1+1"

[[deps.Calculus]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "f641eb0a4f00c343bbc32346e1217b86f3ce9dad"
uuid = "49dc2e85-a5d0-5ad3-a950-438e2897f1b9"
version = "0.5.1"

[[deps.CategoricalArrays]]
deps = ["DataAPI", "Future", "JSON", "Missings", "Printf", "Statistics", "StructTypes", "Unicode"]
git-tree-sha1 = "18d7f3e82c1a80dd38c16453b8fd3f0a7db92f23"
uuid = "324d7699-5711-5eae-9e2f-1d82baa6b597"
version = "0.9.7"

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

[[deps.ChangesOfVariables]]
deps = ["ChainRulesCore", "LinearAlgebra", "Test"]
git-tree-sha1 = "bf98fa45a0a4cee295de98d4c1462be26345b9a1"
uuid = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0"
version = "0.1.2"

[[deps.CodecZlib]]
deps = ["TranscodingStreams", "Zlib_jll"]
git-tree-sha1 = "ded953804d019afa9a3f98981d99b33e3db7b6da"
uuid = "944b1d66-785c-5afd-91f1-9de20f533193"
version = "0.7.0"

[[deps.ColorBrewer]]
deps = ["Colors", "JSON", "Test"]
git-tree-sha1 = "61c5334f33d91e570e1d0c3eb5465835242582c4"
uuid = "a2cac450-b92f-5266-8821-25eda20663c8"
version = "0.4.0"

[[deps.ColorSchemes]]
deps = ["ColorTypes", "Colors", "FixedPointNumbers", "Random"]
git-tree-sha1 = "12fc73e5e0af68ad3137b886e3f7c1eacfca2640"
uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4"
version = "3.17.1"

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

[[deps.ColorVectorSpace]]
deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "SpecialFunctions", "Statistics", "TensorCore"]
git-tree-sha1 = "3f1f500312161f1ae067abe07d13b40f78f32e07"
uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4"
version = "0.9.8"

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

[[deps.Combinatorics]]
git-tree-sha1 = "08c8b6831dc00bfea825826be0bc8336fc369860"
uuid = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
version = "1.0.2"

[[deps.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 = "44c37b4636bc54afac5c574d2d02b625349d6582"
uuid = "34da2185-b29b-5c13-b0c7-acf172513d20"
version = "3.41.0"

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

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

[[deps.Crayons]]
git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15"
uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f"
version = "4.1.1"

[[deps.DataAPI]]
git-tree-sha1 = "cc70b17275652eb47bc9e5f81635981f13cea5c8"
uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
version = "1.9.0"

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

[[deps.DataStructures]]
deps = ["Compat", "InteractiveUtils", "OrderedCollections"]
git-tree-sha1 = "3daef5523dd2e769dad2365274f760ff5f282c7d"
uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
version = "0.18.11"

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

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

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

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

[[deps.Distributions]]
deps = ["FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SparseArrays", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns"]
git-tree-sha1 = "a837fdf80f333415b69684ba8e8ae6ba76de6aaa"
uuid = "31c24e10-a181-5473-b8eb-7969acd0382f"
version = "0.24.18"

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

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

[[deps.DualNumbers]]
deps = ["Calculus", "NaNMath", "SpecialFunctions"]
git-tree-sha1 = "84f04fe68a3176a583b864e492578b9466d87f1e"
uuid = "fa6b7ba4-c1ee-5f82-b5fc-ecf0adba8f74"
version = "0.6.6"

[[deps.EarCut_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "3f3a2501fa7236e9b911e0f7a588c657e822bb6d"
uuid = "5ae413db-bbd1-5e63-b57d-d24a61df00f5"
version = "2.2.3+0"

[[deps.EllipsisNotation]]
deps = ["ArrayInterface"]
git-tree-sha1 = "d7ab55febfd0907b285fbf8dc0c73c0825d9d6aa"
uuid = "da5c29d0-fa7d-589e-88eb-ea29b0a81949"
version = "1.3.0"

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

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

[[deps.FFMPEG_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_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 = "d8a578692e3077ac998b50c0217dfd67f21d1e5f"
uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5"
version = "4.4.0+0"

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

[[deps.FFTW_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "c6033cc3892d0ef5bb9cd29b7f2f0331ea5184ea"
uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a"
version = "3.3.10+0"

[[deps.FileIO]]
deps = ["Pkg", "Requires", "UUIDs"]
git-tree-sha1 = "80ced645013a5dbdc52cf70329399c35ce007fae"
uuid = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
version = "1.13.0"

[[deps.FilePathsBase]]
deps = ["Compat", "Dates", "Mmap", "Printf", "Test", "UUIDs"]
git-tree-sha1 = "04d13bfa8ef11720c24e4d840c0033d145537df7"
uuid = "48062228-2e41-5def-b9a4-89aafe57970f"
version = "0.9.17"

[[deps.FillArrays]]
deps = ["LinearAlgebra", "Random", "SparseArrays"]
git-tree-sha1 = "693210145367e7685d8604aee33d9bfb85db8b31"
uuid = "1a297f60-69ca-5386-bcde-b61e274b549b"
version = "0.11.9"

[[deps.FixedEffectModels]]
deps = ["DataFrames", "FixedEffects", "LinearAlgebra", "Printf", "Reexport", "Statistics", "StatsBase", "StatsFuns", "StatsModels", "Tables", "Vcov"]
git-tree-sha1 = "d2b82dcf3624ed1e2a1e5c126aa317d163243168"
uuid = "9d5cd8c9-2029-5cab-9928-427838db53e3"
version = "1.6.3"

[[deps.FixedEffects]]
deps = ["DataAPI", "LinearAlgebra", "Printf", "Requires", "StatsBase"]
git-tree-sha1 = "cf454d95fe0ebac4c97d1bd5f01b080cec533c68"
uuid = "c8885935-8500-56a7-9867-7708b20db0eb"
version = "2.0.6"

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

[[deps.Fontconfig_jll]]
deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Pkg", "Zlib_jll"]
git-tree-sha1 = "21efd19106a55620a188615da6d3d06cd7f6ee03"
uuid = "a3f928ae-7b40-5064-980b-68af3947d34b"
version = "2.13.93+0"

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

[[deps.FreeType]]
deps = ["CEnum", "FreeType2_jll"]
git-tree-sha1 = "cabd77ab6a6fdff49bfd24af2ebe76e6e018a2b4"
uuid = "b38be410-82b0-50bf-ab77-7b57e271db43"
version = "4.0.0"

[[deps.FreeType2_jll]]
deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "87eb71354d8ec1a96d4a7636bd57a7347dde3ef9"
uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7"
version = "2.10.4+0"

[[deps.FreeTypeAbstraction]]
deps = ["ColorVectorSpace", "Colors", "FreeType", "GeometryBasics", "StaticArrays"]
git-tree-sha1 = "770050893e7bc8a34915b4b9298604a3236de834"
uuid = "663a7486-cb36-511b-a19d-713bb74d65c9"
version = "0.9.5"

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

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

[[deps.GLM]]
deps = ["Distributions", "LinearAlgebra", "Printf", "Reexport", "SparseArrays", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "StatsModels"]
git-tree-sha1 = "fb764dacfa30f948d52a6a4269ae293a479bbc62"
uuid = "38e38edf-8417-5370-95a0-9cbb8c7f171a"
version = "1.6.1"

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

[[deps.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"

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

[[deps.Graphics]]
deps = ["Colors", "LinearAlgebra", "NaNMath"]
git-tree-sha1 = "1c5a84319923bea76fa145d49e93aa4394c73fc2"
uuid = "a2bd30eb-e257-5431-a919-1863eab51364"
version = "1.1.1"

[[deps.Graphite2_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "344bf40dcab1073aca04aa0df4fb092f920e4011"
uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472"
version = "1.3.14+0"

[[deps.GridLayoutBase]]
deps = ["GeometryBasics", "InteractiveUtils", "Observables"]
git-tree-sha1 = "169c3dc5acae08835a573a8a3e25c62f689f8b5c"
uuid = "3955a311-db13-416c-9275-1d80ed98e5e9"
version = "0.6.5"

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

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

[[deps.HarfBuzz_jll]]
deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg"]
git-tree-sha1 = "129acf094d168394e80ee1dc4bc06ec835e510a3"
uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566"
version = "2.8.1+1"

[[deps.HypergeometricFunctions]]
deps = ["DualNumbers", "LinearAlgebra", "SpecialFunctions", "Test"]
git-tree-sha1 = "65e4589030ef3c44d3b90bdc5aac462b4bb05567"
uuid = "34004b35-14d8-5ef3-9330-4cdb6864b03a"
version = "0.3.8"

[[deps.IfElse]]
git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1"
uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
version = "0.1.1"

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

[[deps.ImageIO]]
deps = ["FileIO", "JpegTurbo", "Netpbm", "OpenEXR", "PNGFiles", "QOI", "Sixel", "TiffImages", "UUIDs"]
git-tree-sha1 = "464bdef044df52e6436f8c018bea2d48c40bb27b"
uuid = "82e4d734-157c-48bb-816b-45c225c6df19"
version = "0.6.1"

[[deps.Imath_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "87f7662e03a649cffa2e05bf19c303e168732d3e"
uuid = "905a6f67-0a94-5f89-b386-d35d92009cd1"
version = "3.1.2+0"

[[deps.IndirectArrays]]
git-tree-sha1 = "012e604e1c7458645cb8b436f8fba789a51b257f"
uuid = "9b13fd28-a010-5f03-acff-a1bbcff69959"
version = "1.0.0"

[[deps.Inflate]]
git-tree-sha1 = "f5fc07d4e706b84f72d54eedcc1c13d92fb0871c"
uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9"
version = "0.1.2"

[[deps.IniFile]]
git-tree-sha1 = "f550e6e32074c939295eb5ea6de31849ac2c9625"
uuid = "83e8ac13-25f8-5344-8a64-a9f2b223428f"
version = "0.5.1"

[[deps.InlineStrings]]
deps = ["Parsers"]
git-tree-sha1 = "61feba885fac3a407465726d0c330b3055df897f"
uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48"
version = "1.1.2"

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

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

[[deps.Interpolations]]
deps = ["AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"]
git-tree-sha1 = "b15fc0a95c564ca2e0a7ae12c1f095ca848ceb31"
uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59"
version = "0.13.5"

[[deps.IntervalSets]]
deps = ["Dates", "EllipsisNotation", "Statistics"]
git-tree-sha1 = "3cc368af3f110a767ac786560045dceddfc16758"
uuid = "8197267c-284f-5f27-9208-e0e47529a953"
version = "0.5.3"

[[deps.InverseFunctions]]
deps = ["Test"]
git-tree-sha1 = "a7254c0acd8e62f1ac75ad24d5db43f5f19f3c65"
uuid = "3587e190-3f89-42d0-90ee-14403ec27112"
version = "0.1.2"

[[deps.InvertedIndices]]
git-tree-sha1 = "bee5f1ef5bf65df56bdd2e40447590b272a5471f"
uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f"
version = "1.1.0"

[[deps.IrrationalConstants]]
git-tree-sha1 = "7fd44fd4ff43fc60815f8e764c0f352b83c49151"
uuid = "92d709cd-6900-40b7-9082-c6be49f344b6"
version = "0.1.1"

[[deps.Isoband]]
deps = ["isoband_jll"]
git-tree-sha1 = "f9b6d97355599074dc867318950adaa6f9946137"
uuid = "f1662d9f-8043-43de-a69a-05efc1cc6ff4"
version = "0.1.1"

[[deps.IterTools]]
git-tree-sha1 = "fa6287a4469f5e048d763df38279ee729fbd44e5"
uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e"
version = "1.4.0"

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

[[deps.JLLWrappers]]
deps = ["Preferences"]
git-tree-sha1 = "abc9885a7ca2052a736a600f7fa66209f96506e1"
uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210"
version = "1.4.1"

[[deps.JSON]]
deps = ["Dates", "Mmap", "Parsers", "Unicode"]
git-tree-sha1 = "3c837543ddb02250ef42f4738347454f95079d4e"
uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
version = "0.21.3"

[[deps.JpegTurbo]]
deps = ["CEnum", "FileIO", "ImageCore", "JpegTurbo_jll", "TOML"]
git-tree-sha1 = "a77b273f1ddec645d1b7c4fd5fb98c8f90ad10a5"
uuid = "b835a17e-a41a-41e7-81f0-2f016b05efe0"
version = "0.1.1"

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

[[deps.KernelDensity]]
deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"]
git-tree-sha1 = "591e8dc09ad18386189610acafb970032c519707"
uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b"
version = "0.6.3"

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

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

[[deps.LaTeXStrings]]
git-tree-sha1 = "f2355693d6778a178ade15952b7ac47a4ff97996"
uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
version = "1.3.0"

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

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

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

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

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

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

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

[[deps.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"

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

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

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

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

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

[[deps.LogExpFunctions]]
deps = ["ChainRulesCore", "ChangesOfVariables", "DocStringExtensions", "InverseFunctions", "IrrationalConstants", "LinearAlgebra"]
git-tree-sha1 = "e5718a00af0ab9756305a0392832c8952c7426c1"
uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688"
version = "0.3.6"

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

[[deps.MKL_jll]]
deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "Pkg"]
git-tree-sha1 = "e595b205efd49508358f7dc670a940c790204629"
uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7"
version = "2022.0.0+0"

[[deps.Makie]]
deps = ["Animations", "Base64", "ColorBrewer", "ColorSchemes", "ColorTypes", "Colors", "Contour", "Distributions", "DocStringExtensions", "FFMPEG", "FileIO", "FixedPointNumbers", "Formatting", "FreeType", "FreeTypeAbstraction", "GeometryBasics", "GridLayoutBase", "ImageIO", "IntervalSets", "Isoband", "KernelDensity", "LaTeXStrings", "LinearAlgebra", "MakieCore", "Markdown", "Match", "MathTeXEngine", "Observables", "OffsetArrays", "Packing", "PlotUtils", "PolygonOps", "Printf", "Random", "RelocatableFolders", "Serialization", "Showoff", "SignedDistanceFields", "SparseArrays", "StaticArrays", "Statistics", "StatsBase", "StatsFuns", "StructArrays", "UnicodeFun"]
git-tree-sha1 = "cd0fd02ab0d129f03515b7b68ca77fb670ef2e61"
uuid = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"
version = "0.16.5"

[[deps.MakieCore]]
deps = ["Observables"]
git-tree-sha1 = "c5fb1bfac781db766f9e4aef96adc19a729bc9b2"
uuid = "20f20a25-4f0e-4fdf-b5d1-57303727442b"
version = "0.2.1"

[[deps.MappedArrays]]
git-tree-sha1 = "e8b359ef06ec72e8c030463fe02efe5527ee5142"
uuid = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900"
version = "0.4.1"

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

[[deps.Match]]
git-tree-sha1 = "1d9bc5c1a6e7ee24effb93f175c9342f9154d97f"
uuid = "7eb4fadd-790c-5f42-8a69-bfa0b872bfbf"
version = "1.2.0"

[[deps.MathTeXEngine]]
deps = ["AbstractTrees", "Automa", "DataStructures", "FreeTypeAbstraction", "GeometryBasics", "LaTeXStrings", "REPL", "RelocatableFolders", "Test"]
git-tree-sha1 = "70e733037bbf02d691e78f95171a1fa08cdc6332"
uuid = "0a4f8689-d25c-4efe-a92b-7142dfc1aa53"
version = "0.2.1"

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

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

[[deps.Missings]]
deps = ["DataAPI"]
git-tree-sha1 = "f8c673ccc215eb50fcadb285f522420e29e69e1c"
uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28"
version = "0.4.5"

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

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

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

[[deps.NaNMath]]
git-tree-sha1 = "b086b7ea07f8e38cf122f5016af580881ac914fe"
uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
version = "0.3.7"

[[deps.Netpbm]]
deps = ["FileIO", "ImageCore"]
git-tree-sha1 = "18efc06f6ec36a8b801b23f076e3c6ac7c3bf153"
uuid = "f09324ee-3d7c-5217-9330-fc30815ba969"
version = "1.0.2"

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

[[deps.Observables]]
git-tree-sha1 = "fe29afdef3d0c4a8286128d4e45cc50621b1e43d"
uuid = "510215fc-4207-5dde-b226-833fc4488ee2"
version = "0.4.0"

[[deps.OffsetArrays]]
deps = ["Adapt"]
git-tree-sha1 = "043017e0bdeff61cfbb7afeb558ab29536bbb5ed"
uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
version = "1.10.8"

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

[[deps.OpenBLAS_jll]]
deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"]
uuid = "4536629a-c528-5b80-bd46-f80d51c5b363"

[[deps.OpenEXR]]
deps = ["Colors", "FileIO", "OpenEXR_jll"]
git-tree-sha1 = "327f53360fdb54df7ecd01e96ef1983536d1e633"
uuid = "52e1d378-f018-4a11-a4be-720524705ac7"
version = "0.3.2"

[[deps.OpenEXR_jll]]
deps = ["Artifacts", "Imath_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "923319661e9a22712f24596ce81c54fc0366f304"
uuid = "18a262bb-aa17-5467-a713-aee519bc75cb"
version = "3.1.1+0"

[[deps.OpenLibm_jll]]
deps = ["Artifacts", "Libdl"]
uuid = "05823500-19ac-5b8b-9628-191a04bc5112"

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

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

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

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

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

[[deps.PDMats]]
deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"]
git-tree-sha1 = "7e2166042d1698b6072352c74cfd1fca2a968253"
uuid = "90014a1f-27ba-587c-ab20-58faa44d9150"
version = "0.11.6"

[[deps.PNGFiles]]
deps = ["Base64", "CEnum", "ImageCore", "IndirectArrays", "OffsetArrays", "libpng_jll"]
git-tree-sha1 = "eb4dbb8139f6125471aa3da98fb70f02dc58e49c"
uuid = "f57f5aa1-a3ce-4bc8-8ab9-96f992907883"
version = "0.3.14"

[[deps.Packing]]
deps = ["GeometryBasics"]
git-tree-sha1 = "1155f6f937fa2b94104162f01fa400e192e4272f"
uuid = "19eb6ba3-879d-56ad-ad62-d5c202156566"
version = "0.4.2"

[[deps.PaddedViews]]
deps = ["OffsetArrays"]
git-tree-sha1 = "03a7a85b76381a3d04c7a1656039197e70eda03d"
uuid = "5432bcbf-9aad-5242-b902-cca2824c8663"
version = "0.5.11"

[[deps.Pango_jll]]
deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "FriBidi_jll", "Glib_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "3a121dfbba67c94a5bec9dde613c3d0cbcf3a12b"
uuid = "36c8627f-9965-5494-a995-c6b170f724f3"
version = "1.50.3+0"

[[deps.Parsers]]
deps = ["Dates"]
git-tree-sha1 = "13468f237353112a01b2d6b32f3d0f80219944aa"
uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0"
version = "2.2.2"

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

[[deps.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"

[[deps.PkgVersion]]
deps = ["Pkg"]
git-tree-sha1 = "a7a7e1a88853564e551e4eba8650f8c38df79b37"
uuid = "eebad327-c553-4316-9ea0-9fa01ccd7688"
version = "0.1.1"

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

[[deps.PolygonOps]]
git-tree-sha1 = "77b3d3605fc1cd0b42d95eba87dfcd2bf67d5ff6"
uuid = "647866c9-e3ac-4575-94e7-e3d426903924"
version = "0.1.2"

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

[[deps.Preferences]]
deps = ["TOML"]
git-tree-sha1 = "de893592a221142f3db370f48290e3a2ef39998f"
uuid = "21216c6a-2e73-6563-6e65-726566657250"
version = "1.2.4"

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

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

[[deps.ProgressMeter]]
deps = ["Distributed", "Printf"]
git-tree-sha1 = "afadeba63d90ff223a6a48d2009434ecee2ec9e8"
uuid = "92933f4c-e287-5a05-a399-4b506db050ca"
version = "1.7.1"

[[deps.QOI]]
deps = ["ColorTypes", "FileIO", "FixedPointNumbers"]
git-tree-sha1 = "18e8f4d1426e965c7b532ddd260599e1510d26ce"
uuid = "4b34888f-f399-49d4-9bb3-47ed5cae4e65"
version = "1.0.0"

[[deps.QuadGK]]
deps = ["DataStructures", "LinearAlgebra"]
git-tree-sha1 = "78aadffb3efd2155af139781b8a8df1ef279ea39"
uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc"
version = "2.4.2"

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

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

[[deps.Ratios]]
deps = ["Requires"]
git-tree-sha1 = "dc84268fe0e3335a62e315a3a7cf2afa7178a734"
uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439"
version = "0.4.3"

[[deps.Reexport]]
git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b"
uuid = "189a3867-3050-52da-a836-e630ba90ab69"
version = "1.2.2"

[[deps.RegressionTables]]
deps = ["Compat", "Distributions", "FixedEffectModels", "Formatting", "GLM", "Statistics", "StatsBase", "StatsModels", "UnPack"]
git-tree-sha1 = "ce53f0151420a8f9769a7fd6ed6ca9b7c0375a92"
uuid = "d519eb52-b820-54da-95a6-98e1306fdade"
version = "0.5.3"

[[deps.RelocatableFolders]]
deps = ["SHA", "Scratch"]
git-tree-sha1 = "cdbd3b1338c72ce29d9584fdbe9e9b70eeb5adca"
uuid = "05181044-ff0b-4ac5-8273-598c1e38db00"
version = "0.1.3"

[[deps.Requires]]
deps = ["UUIDs"]
git-tree-sha1 = "838a3a4188e2ded87a4f9f184b4b0d78a1e91cb7"
uuid = "ae029012-a4dd-5104-9daa-d747884805df"
version = "1.3.0"

[[deps.Rmath]]
deps = ["Random", "Rmath_jll"]
git-tree-sha1 = "bf3188feca147ce108c76ad82c2792c57abe7b1f"
uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa"
version = "0.7.0"

[[deps.Rmath_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "68db32dff12bb6127bac73c209881191bf0efbb7"
uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f"
version = "0.3.0+0"

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

[[deps.SIMD]]
git-tree-sha1 = "39e3df417a0dd0c4e1f89891a281f82f5373ea3b"
uuid = "fdea26ae-647d-5447-a871-4b548cad5224"
version = "3.4.0"

[[deps.ScanByte]]
deps = ["Libdl", "SIMD"]
git-tree-sha1 = "9cc2955f2a254b18be655a4ee70bc4031b2b189e"
uuid = "7b38b023-a4d7-4c5e-8d43-3f3097f304eb"
version = "0.3.0"

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

[[deps.SentinelArrays]]
deps = ["Dates", "Random"]
git-tree-sha1 = "6a2f7d70512d205ca8c7ee31bfa9f142fe74310c"
uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c"
version = "1.3.12"

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

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

[[deps.ShiftedArrays]]
git-tree-sha1 = "22395afdcf37d6709a5a0766cc4a5ca52cb85ea0"
uuid = "1277b4bf-5013-50f5-be3d-901d8477a67a"
version = "1.0.0"

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

[[deps.SignedDistanceFields]]
deps = ["Random", "Statistics", "Test"]
git-tree-sha1 = "d263a08ec505853a5ff1c1ebde2070419e3f28e9"
uuid = "73760f76-fbc4-59ce-8f25-708e95d2df96"
version = "0.4.0"

[[deps.Sixel]]
deps = ["Dates", "FileIO", "ImageCore", "IndirectArrays", "OffsetArrays", "REPL", "libsixel_jll"]
git-tree-sha1 = "8fb59825be681d451c246a795117f317ecbcaa28"
uuid = "45858cf5-a6b0-47a3-bbea-62219f50df47"
version = "0.1.2"

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

[[deps.SortingAlgorithms]]
deps = ["DataStructures", "Random", "Test"]
git-tree-sha1 = "03f5898c9959f8115e30bc7226ada7d0df554ddd"
uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c"
version = "0.3.1"

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

[[deps.SpecialFunctions]]
deps = ["ChainRulesCore", "IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"]
git-tree-sha1 = "cbf21db885f478e4bd73b286af6e67d1beeebe4c"
uuid = "276daf66-3868-5448-9aa4-cd146d93841b"
version = "1.8.4"

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

[[deps.Static]]
deps = ["IfElse"]
git-tree-sha1 = "65068e4b4d10f3c31aaae2e6cb92b6c6cedca610"
uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3"
version = "0.5.6"

[[deps.StaticArrays]]
deps = ["LinearAlgebra", "Random", "Statistics"]
git-tree-sha1 = "74fb527333e72ada2dd9ef77d98e4991fb185f04"
uuid = "90137ffa-7385-5640-81b9-e52037218182"
version = "1.4.1"

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

[[deps.StatsAPI]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "c3d8ba7f3fa0625b062b82853a7d5229cb728b6b"
uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0"
version = "1.2.1"

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

[[deps.StatsFuns]]
deps = ["ChainRulesCore", "HypergeometricFunctions", "InverseFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"]
git-tree-sha1 = "25405d7016a47cf2bd6cd91e66f4de437fd54a07"
uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c"
version = "0.9.16"

[[deps.StatsModels]]
deps = ["DataAPI", "DataStructures", "LinearAlgebra", "Printf", "REPL", "ShiftedArrays", "SparseArrays", "StatsBase", "StatsFuns", "Tables"]
git-tree-sha1 = "03c99c7ef267c8526953cafe3c4239656693b8ab"
uuid = "3eaba693-59b7-5ba5-a881-562e759f1c8d"
version = "0.6.29"

[[deps.StructArrays]]
deps = ["Adapt", "DataAPI", "StaticArrays", "Tables"]
git-tree-sha1 = "57617b34fa34f91d536eb265df67c2d4519b8b98"
uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
version = "0.6.5"

[[deps.StructTypes]]
deps = ["Dates", "UUIDs"]
git-tree-sha1 = "d24a825a95a6d98c385001212dc9020d609f2d4f"
uuid = "856f2bd8-1eba-4b0a-8007-ebc267875bd4"
version = "1.8.1"

[[deps.SuiteSparse]]
deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"]
uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"

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

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

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

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

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

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

[[deps.TiffImages]]
deps = ["ColorTypes", "DataStructures", "DocStringExtensions", "FileIO", "FixedPointNumbers", "IndirectArrays", "Inflate", "OffsetArrays", "PkgVersion", "ProgressMeter", "UUIDs"]
git-tree-sha1 = "991d34bbff0d9125d93ba15887d6594e8e84b305"
uuid = "731e570b-9d59-4bfa-96dc-6df516fadf69"
version = "0.5.3"

[[deps.TranscodingStreams]]
deps = ["Random", "Test"]
git-tree-sha1 = "216b95ea110b5972db65aa90f88d8d89dcb8851c"
uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"
version = "0.9.6"

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

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

[[deps.UnPack]]
git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b"
uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed"
version = "1.0.2"

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

[[deps.UnicodeFun]]
deps = ["REPL"]
git-tree-sha1 = "53915e50200959667e78a92a418594b428dffddf"
uuid = "1cfade01-22cf-5700-b092-accc4b62d6e1"
version = "0.4.1"

[[deps.Vcov]]
deps = ["Combinatorics", "DataAPI", "LinearAlgebra", "StatsBase", "Tables"]
git-tree-sha1 = "85f4c3c95d9a4d3cce71cb6c58c3a5e496edb5af"
uuid = "ec2bfdc2-55df-4fc9-b9ae-4958c2cf2486"
version = "0.4.3"

[[deps.WeakRefStrings]]
deps = ["DataAPI", "InlineStrings", "Parsers"]
git-tree-sha1 = "c69f9da3ff2f4f02e811c3323c22e5dfcb584cfa"
uuid = "ea10d353-3f73-51f8-a26c-33c1cb351aa5"
version = "1.4.1"

[[deps.WoodburyMatrices]]
deps = ["LinearAlgebra", "SparseArrays"]
git-tree-sha1 = "de67fa59e33ad156a590055375a30b23c40299d3"
uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6"
version = "0.5.5"

[[deps.WorldBankData]]
deps = ["DataFrames", "HTTP", "JSON"]
git-tree-sha1 = "5b0ac92354f25754de6cbc3277bb8d31fb3eac81"
uuid = "2ff30676-a39f-58b2-ad74-5d1012d57b9b"
version = "0.4.1"

[[deps.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"

[[deps.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"

[[deps.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"

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

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

[[deps.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"

[[deps.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"

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

[[deps.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"

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

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

[[deps.isoband_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "51b5eeb3f98367157a7a12a1fb0aa5328946c03c"
uuid = "9a68df92-36a6-505f-a73e-abb412b6bfb4"
version = "0.2.3+0"

[[deps.libass_jll]]
deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"]
git-tree-sha1 = "5982a94fcba20f02f42ace44b9894ee2b140fe47"
uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0"
version = "0.15.1+0"

[[deps.libblastrampoline_jll]]
deps = ["Artifacts", "Libdl", "OpenBLAS_jll"]
uuid = "8e850b90-86db-534c-a0d3-1478176c7d93"

[[deps.libfdk_aac_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "daacc84a041563f965be61859a36e17c4e4fcd55"
uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280"
version = "2.0.2+0"

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

[[deps.libsixel_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "78736dab31ae7a53540a6b752efc61f77b304c5b"
uuid = "075b6546-f08a-558a-be8f-8157d0f608a5"
version = "1.8.6+1"

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

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

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

[[deps.x264_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "4fea590b89e6ec504593146bf8b988b2c00922b2"
uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a"
version = "2021.5.5+0"

[[deps.x265_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "ee567a171cce03570d77ad3a43e90218e38937a9"
uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76"
version = "3.5.0+0"
"""

# ╔═╡ Cell order:
# ╟─cabd4851-d3a6-43a4-9655-40b3d4b09eee
# ╠═d3e1eb22-9a63-11ec-27a9-43c3ded20267
# ╟─cd54e8bc-ecb2-4455-bda0-b89ab41cca30
# ╠═2130f4e4-45fa-47f6-9412-57f2e9d662d5
# ╠═c845fdde-bb29-4fc3-a744-80002bed5111
# ╟─189fde90-f8ad-4a5c-9566-cad610830a26
# ╟─858035fe-22e5-4a6b-9129-107777496234
# ╠═075ca6b5-5e09-474a-aecb-9fac1673bca7
# ╠═ef58ffa9-08a7-4dfa-a9ed-17b0c561da70
# ╟─fcb62e62-178b-461c-90e8-dd89494cd2c3
# ╠═19c54112-1e98-4e08-84e5-03df35f18c5f
# ╠═c56f41a6-e62f-4399-a34e-732f01520667
# ╠═45feeff5-5c9d-42e4-ba63-c25ca387fefe
# ╠═c7664c08-a426-450d-b455-4da3ccb9c829
# ╠═c3aad65d-198a-48ff-996d-b5ed3268a522
# ╟─886dc221-4a45-4454-9062-a0adfd81d519
# ╠═022eebe9-e173-443e-a48e-e0c5845337bc
# ╠═584e79e9-2df9-458a-aca5-e230de4d951b
# ╠═82ff3ce4-4f3c-414d-8f6a-57cfec9fe65b
# ╠═95f2b750-876b-44f4-a457-f3089ccfdec2
# ╠═0f14368c-6e71-4cd5-86fa-df85081229b8
# ╠═54fb7fbc-ba4b-45d9-b8d4-f089ba1a49d3
# ╠═50fdce71-2d0f-4d21-a2af-21ceec8f9695
# ╟─00000000-0000-0000-0000-000000000001
# ╟─00000000-0000-0000-0000-000000000002

max_stars_repo_name: ubcecon/covid-chisadzaetal

max_issues_repo_name: ubcecon/covid-chisadzaetal

max_forks_repo_name: ubcecon/covid-chisadzaetal


text:
using ValueOrientedRiskManagementInsurance

using Distributions
using DataFrames

include("ECModel_Input.jl")

println("Start ECModel ...")
#################################################################
"Create DataFrame from information on business units and total"
function getdf(bu, total)
  df =  DataFrame(BU = Array{Symbol}(undef, 0),
                  GrossNet = Array{Symbol}(undef, 0),
                  CumProb = Array{Float64}(undef, 0),
                  Profit = Array{Real}(undef, 0))

  for 𝑖 ∈ 1:length(bu)
    append!(df, DataFrame(
      BU = fill!(Array{Symbol}(undef, n_scen), bu[𝑖].id),
      GrossNet = fill!(Array{Symbol}(undef, n_scen), :gross),
      CumProb = real(collect(1:n_scen)) /  n_scen,
      Profit = sort(bu[𝑖].gross.profit)))
    append!(df, DataFrame(
      BU = fill!(Array{Symbol}(undef, n_scen), bu[𝑖].id),
      GrossNet = fill!(Array{Symbol}(undef, n_scen), :net),
      CumProb = real(collect(1:n_scen)) /  n_scen,
      Profit = sort(bu[𝑖].net.profit)))
  end
  append!(df, DataFrame(
    BU = fill(:total, n_scen),
    GrossNet = fill(:gross, n_scen),
    CumProb = real(collect(1:n_scen)) /  n_scen,
    Profit = sort(total.gross.profit)))
  append!(df, DataFrame(
    BU = fill(:total, n_scen),
    GrossNet = fill(:net, n_scen),
    CumProb = real(collect(1:n_scen)) /  n_scen,
    Profit = sort(total.net.profit)))
  append!(df, DataFrame(
    BU = fill(:risk_cap_total, 4),
    GrossNet = [:gross, :gross, :net, :net],
    CumProb = real([0., 1., 0., 1.]),
    Profit = convert(Vector{Real},
                     [fill(-total.gross.eco_cap, 2);
                      fill(-total.net.eco_cap,2)])))
  return df
end

"Construct efficient frontier"
function effline(x₀, y₀, a, y_min, y_max)
  x_min = x₀ + (y_min-y₀) / a
  x_max = x₀ + (y_max-y₀) / a
  return hcat([x_min, x₀, x_max], [y_min, y₀, y_max])
end

eff(x₀, y₀, a, x) = y₀ + a * (x-x₀)

"Equalizing risk premium"
function riskprice(ins_input::DataFrame,
                   inv_inout::DataFrame,
                   tau_kendall::Matrix{Real},
                   n_scen::Int,
                   α::Real,
                   s::Real,
                   costs_fixed::Real,
                   Δp_min::Real,
                   Δp_max::Real,
                   Δp_init::Real)
  ins = deepcopy(ins_input)
  i_max = 50 ## max 50 iterations
  rorac_gross_i = zeros(Real, i_max)
  rorac_gross_f = zeros(Real, i_max)
  Δp = zeros(Real, i_max + 1)
  Δp_tol  = 1e-5      ## break criterion : minimum price change
  row_l = ins[ins[:name] .== "Liability", :ctr][1,1]
  row_f = ins[ins[:name] .== "Fire", :ctr][1,1]
  if (row_l != ins[row_l, :ctr]) | (row_f != ins[row_f, :ctr])
    error("row_l ($row_l) or row_f ($row_f) does not match.")
  end
  n_steps = 0
  Δp[1] = Δp_init
  for 𝑖 ∈ 1:i_max
    Random.seed!(seed)
    ins[row_l, :premium] =
      ins_input[row_l, :premium] * (1 + Δp[𝑖])
    ins[row_f, :premium] =
      ins_input[row_f, :premium] -
      ins_input[row_l, :premium] * Δp[𝑖]
    fac_i = ins_input[row_l, :premium] / ins[row_l, :premium]
    fac_f = ins_input[row_f, :premium] / ins[row_f, :premium]
    ins[row_l, :loss_ratio] =
      ins_input[row_l, :loss_ratio] * fac_i
    ins[row_f, :loss_ratio] =
      ins_input[row_f, :loss_ratio] * fac_f
    ins[row_l, :cost_ratio] =
      ins_input[row_l, :cost_ratio] * fac_i
    ins[row_f, :cost_ratio] =
      ins_input[row_f, :cost_ratio] * fac_f
    ins[row_l, :re_costs] = ins_input[row_l, :re_costs] * fac_i
    ins[row_f, :re_costs] = ins_input[row_f, :re_costs] * fac_f

    bu, total =
      project(ins, inv_input, tau_kendall, n_scen, α, s,
              costs_fixed)
    rorac_gross_i[𝑖] = bu[row_l].gross.rorac
    rorac_gross_f[𝑖] = bu[row_f].gross.rorac

    if Δp_max - Δp_min < Δp_tol
      n_steps = 𝑖
      break
    end
    if rorac_gross_i[𝑖] < rorac_gross_f[𝑖]
      Δp_min = Δp[𝑖]
    else
      Δp_max = Δp[𝑖]
    end
    Δp[𝑖+1] = (Δp_min + Δp_max) / 2
  end
  return ins, Δp[1:n_steps],
         rorac_gross_i[1:n_steps], rorac_gross_f[1:n_steps]
end

"Optimizing Capitalization"
function optcap(ins_input::DataFrame,
                inv_input::DataFrame,
                tau_kendall::Matrix{Real},
                n_scen::Int,
                α::Real,
                s::Real,
                cost_fixed::Real)
  inv = deepcopy(inv_input)
  i_max = 8
  invest_init = inv[1,:init] .- collect(0:(i_max-1)) * 100.
  profit_net = zeros(Real, i_max)
  ec_net = zeros(Real, i_max)
  rorac_net = zeros(Real, i_max)
  roc_net = zeros(Real, i_max)

  for 𝑖 ∈ 1:i_max
    Random.seed!(seed)
    inv[1,:init] = invest_init[𝑖]
    bu, total =
      project(ins_input, inv, tau_kendall,
              n_scen, α, s, cost_fixed)
    profit_net[𝑖] = total.net.profit_mean
    ec_net[𝑖] = total.net.eco_cap
    rorac_net[𝑖] = total.net.rorac
    roc_net[𝑖] = total.net.profit_mean / invest_init[𝑖]
  end
  inv_init_opt = 0
  ec_net_opt = 0
  profit_net_opt = 0
  i_opt = 0
  ## only works if invest_init[1] >  ec_cap_net[1]
  for 𝑖 ∈ 1:i_max
    if invest_init[𝑖] < ec_net[𝑖]
      inv_init_opt = invest_init[𝑖-1]
      ec_net_opt = ec_net[𝑖-1]
      profit_net_opt = profit_net[𝑖-1]
      i_opt = 𝑖-1
      break
    end
  end
  inv[1, :init] = inv_init_opt
  return inv, i_opt, invest_init, ec_net, rorac_net, roc_net,
  inv_init_opt, ec_net_opt, profit_net_opt
end

"Optimizing Fire Reinsurance"
function optrefire(ins_input::DataFrame,
                   inv_input::DataFrame,
                   tau_kendall::Matrix{Real},
                   n_scen::Int,
                   α::Real,
                   s::Real,
                   cost_fixed::Real)
  ins = deepcopy(ins_input)
  n_points = 21
  points = zeros(Real, n_points+1, 4)

  i_opt = 0
  ceded_opt = 0
  profit_net_opt = 0
  ec_net_opt = 0
  rorac_net_opt = 0
  ceded = zeros(Real, n_points)
  profit_net = zeros(Real, n_points)
  ec_net = zeros(Real, n_points)
  rorac_net = zeros(Real, n_points)
  row_f = ins[ins[:name] .== "Fire", :ctr][1,1]
  if row_f != ins[row_f, :ctr]
    error("row_f ($row_f) does not match.")
  end

  for 𝑖 ∈ 1:n_points
    Random.seed!(seed)
    ceded[𝑖] = (𝑖-1) / (n_points-1)
    ins[row_f, :re_ceded] = ceded[𝑖]
    bu, total =
      project(ins, inv_input, tau_kendall,
      n_scen, α, s, cost_fixed)
    ec_net[𝑖] = total.net.eco_cap
    profit_net[𝑖] = total.net.profit_mean
    rorac_net[𝑖] = total.net.rorac
    if rorac_net[𝑖] > rorac_net_opt
      ceded_opt = ceded[𝑖]
      profit_net_opt = profit_net[𝑖]
      ec_net_opt = ec_net[𝑖]
      rorac_net_opt = rorac_net[𝑖]
      i_opt = 𝑖
    end
  end
  ins[row_f, :re_ceded] = ceded_opt
  return ins, ceded, profit_net, ec_net,
  i_opt, ceded_opt, profit_net_opt, ec_net_opt, rorac_net_opt
end

"Optimizing Reinsurance RAROC no constraints"
function optreraroc(ins_input::DataFrame,
                    inv_input::DataFrame,
                    tau_kendall::Matrix{Real},
                    n_scen::Int,
                    α::Real,
                    s::Real,
                    cost_fixed::Real,
                    n_points::Int)
  ins = deepcopy(ins_input)
  unif = Uniform()
  ceded = Array{Real}(undef, nrow(ins), n_points)
  profit_net = Array{Real}(undef, n_points)
  ec_net = Array{Real}(undef, n_points)
  rorac_net = Array{Real}(undef, n_points)
  i_opt, profit_net_opt, ec_net_opt, rorac_net_opt =
    1, 0.0, 0.0, 0.0

  for 𝑏 ∈ 1:nrow(ins)
    ceded[𝑏,:] = rand(unif, n_points)
  end
  for 𝑖 ∈ 1:n_points
    Random.seed!(seed)
    for 𝑏 ∈ 1:nrow(ins)
      ins[𝑏, :re_ceded] = ceded[𝑏, 𝑖]
    end
    bu, total =
      project(ins, inv_input, tau_kendall,
              n_scen, α, s, cost_fixed)
    profit_net[𝑖] = total.net.profit_mean
    ec_net[𝑖] = total.net.eco_cap
    rorac_net[𝑖] = total.net.rorac
    if rorac_net[𝑖] > rorac_net_opt
      i_opt = 𝑖
      profit_net_opt = profit_net[𝑖]
      ec_net_opt = ec_net[𝑖]
      rorac_net_opt = rorac_net[𝑖]
    end
  end
  for 𝑏 ∈ 1:nrow(ins)
    ins[𝑏, :re_ceded] = ceded[𝑏, i_opt]
  end
  return ins, profit_net, ec_net, rorac_net,
  profit_net_opt, ec_net_opt, rorac_net_opt
end

"Optimizing Reinsurance EVA no constraints"
function optreeva(ins_input::DataFrame,
                  inv_input::DataFrame,
                  tau_kendall::Matrix{Real},
                  n_scen::Int,
                  α::Real,
                  s::Real,
                  cost_fixed::Real,
                  n_points::Int,
                  hurdle::Real)
  ins = deepcopy(ins_input)
  unif = Uniform()
  ceded = Array{Real}(undef, nrow(ins), n_points)
  avg_ceded = Array{Real}(undef, n_points)
  eva_net = Array{Real}(undef, n_points)
  i_opt = 0
  avg_ceded_opt  = 0.0
  eva_net_opt = 0.0

  for 𝑏 ∈ 1:nrow(ins)
    ceded[𝑏,:] = rand(unif, n_points)
  end
  for 𝑖 ∈ 1:n_points
    Random.seed!(seed)
    for 𝑏 ∈ 1:nrow(ins)
      ins[𝑏, :re_ceded] = ceded[𝑏, 𝑖]
    end
    bu, total =
      project(ins, inv_input, tau_kendall,
              n_scen, α, s, cost_fixed)
    avg_ceded[𝑖] =
      ins[:re_ceded] ⋅ ins[:premium] /sum(ins[:premium])
    eva_net[𝑖] =
      total.net.profit_mean - hurdle * total.net.eco_cap
    if eva_net[𝑖] > eva_net_opt
      i_opt = 𝑖
      avg_ceded_opt = avg_ceded[𝑖]
      eva_net_opt = eva_net[𝑖]
    end
  end
  for 𝑏 ∈ 1:nrow(ins)
    ins[𝑏, :re_ceded] = ceded[𝑏, i_opt]
  end
  return ins, avg_ceded, eva_net, avg_ceded_opt, eva_net_opt
end

"Optim. reins. RAROC prescribed average reinsurance quote"
function optre(ins_input::DataFrame,
               inv_input::DataFrame,
               tau_kendall::Matrix{Real},
               n_scen::Int,
               α::Real,
               s::Real,
               cost_fixed::Real,
               n_points::Int,
               avg_ceded::Real)
  ins = deepcopy(ins_input)
  unif = Uniform()
  ceded = Array{Real}(undef, nrow(ins), n_points)
  random =  Array{Real}(undef, nrow(ins), n_points)
  profit_net = Array{Real}(undef, n_points)
  ec_net = Array{Real}(undef, n_points)
  rorac_net = Array{Real}(undef, n_points)
  i_opt, profit_net_opt, ec_net_opt, rorac_net_opt =
    0, 0.0, 0.0, 0.0

  prem_gross = sum(ins_input[:, :premium])
  for 𝑖 ∈ 1:n_points
    rand_vector_admissable = false
    while !rand_vector_admissable
      random[:,𝑖] = rand(unif, nrow(ins))
      prem_temp = random[:,𝑖] ⋅ ins_input[:, :premium]
      for 𝑏 ∈ 1:nrow(ins)
        ceded[𝑏, 𝑖] =
          avg_ceded * random[𝑏, 𝑖] * prem_gross / prem_temp
      end
      # We cannot cede more than 100%
      rand_vector_admissable =
        all(ceded[:,𝑖] .<= ones(nrow(ins)))
    end
  end
  for 𝑖 ∈ 1:n_points
    Random.seed!(seed)
    # for b = 1:nrow(ins)
    #   ceded[b, i] =
    #     avg_ceded * random[b, i] * prem_gross / prem_temp
    #   ins[b, :re_ceded] = ceded[b, i]
    # end
    ins[:, :re_ceded] = ceded[:, 𝑖]
    bu, total =
      project(ins, inv_input, tau_kendall,
              n_scen, α, s, cost_fixed)
    profit_net[𝑖] = total.net.profit_mean
    ec_net[𝑖] = total.net.eco_cap
    rorac_net[𝑖] = total.net.rorac
    if rorac_net[𝑖] > rorac_net_opt
      i_opt = 𝑖
      profit_net_opt = profit_net[𝑖]
      ec_net_opt = ec_net[𝑖]
      rorac_net_opt = rorac_net[𝑖]
    end
  end
  ins[:, :re_ceded] = ceded[:, i_opt]
  return ins, ceded, profit_net, ec_net, rorac_net,
  profit_net_opt, ec_net_opt, rorac_net_opt
end

#################################################################
row_f =
  insurance_input[insurance_input[:name] .== "Fire", :ctr][1,1]
row_l =
  insurance_input[insurance_input[:name] .==
  "Liability", :ctr][1,1]
row_t =
  insurance_input[insurance_input[:name] .== "Theft", :ctr][1,1]

pl_fire_exact_gross =
  (1 + s -
     insurance_input[row_f, :loss_ratio] -
     insurance_input[row_f, :cost_ratio]) *
  insurance_input[row_f, :premium]

pl_cap_rf = s * invest_input[1, :init]
pl_diff = pl_cap_rf - costs_fixed

Random.seed!(seed) ## fix random seed for repeatable results
bu, total =
  project(insurance_input, invest_input, tau_kendall,
          n_scen, α, s, costs_fixed)

n_bu = length(bu)
abbrevs = AbstractString[string(bu[𝑏].name[1]) for 𝑏 ∈ 1:n_bu]

diff_ec_gross =
  total.gross.eco_cap -
  sum([bu[𝑖].gross.eco_cap  for 𝑖 ∈ 1:length(bu)])
diff_ec_net =
  total.net.eco_cap -
  sum([bu[𝑖].net.eco_cap for 𝑖 ∈ 1:length(bu)])

## BU results
profit_gross = Real[bu[𝑖].gross.profit_mean for 𝑖 ∈ 1:length(bu)]
profit_net = Real[bu[𝑖].net.profit_mean for 𝑖 ∈ 1:length(bu)]

ec_gross = Real[bu[𝑖].gross.eco_cap for 𝑖 ∈ 1:length(bu)]
ec_net = Real[bu[𝑖].net.eco_cap for 𝑖 ∈ 1:length(bu)]

rorac_gross = Real[bu[𝑖].gross.rorac for 𝑖 ∈ 1:length(bu)]
rorac_net = Real[bu[𝑖].net.rorac for 𝑖 ∈ 1:length(bu)]

x = hcat(profit_gross, ec_gross, ec_net)

##  Portfolio Optimizations #####################################

ins_input = deepcopy(insurance_input)
inv_input = deepcopy(invest_input)

## Risk-Adjusted Price-Setting ==================================
println("Risk-Adjusted Price-Setting ...")
Δp_min = 0.0
Δp_max = 0.05
Δp_init = 0.0

ins_input_rp, Δp, rorac_price_gross_i, rorac_price_gross_f =
  riskprice(ins_input, inv_input, tau_kendall, n_scen, α, s,
            costs_fixed, Δp_min, Δp_max, Δp_init)

Random.seed!(seed)
bu_rp, total_rp =
  project(ins_input_rp, invest_input, tau_kendall,
          n_scen, α, s, costs_fixed)

## Optimizing Capitalization ====================================
println("Optimizing Capitalization ... ")
inv_input_oc, i_oc_opt, invest_init_oc, ec_net_oc, rorac_net_oc,
roc_net_oc, inv_init_oc_opt, ec_net_oc_opt, profit_net_oc_opt =
  optcap(ins_input_rp, inv_input, tau_kendall,
         n_scen, α, s, costs_fixed)

Random.seed!(seed)
bu_oc, total_oc =
  project(ins_input_rp, inv_input_oc, tau_kendall,
          n_scen, α, s, costs_fixed)

## Optimizing Fire Reinsurance ==================================
println("Optimizing Fire Reinsurance ...")
ins_input_ofr, ceded_ofr, profit_net_ofr, ec_net_ofr,
i_ofr, ceded_ofr_opt, profit_net_ofr_opt, ec_net_ofr_opt,
rorac_net_ofr_opt =
  optrefire(ins_input_rp, inv_input_oc, tau_kendall, n_scen, α,
            s, costs_fixed)

## Optimizing Reinsurance =======================================

## Optimizing Reinsurance RAROC no constraints ==================
println("Optimizing Reinsurance RAROC no constraints ... ")

ins_input_orraroc, profit_net_orraroc, ec_net_orraroc,
rorac_net_orraroc, profit_net_orraroc_opt, ec_net_orraroc_opt,
rorac_net_orraroc_opt =
  optreraroc(ins_input_ofr, inv_input_oc, tau_kendall,
             n_scen, α, s, costs_fixed, n_cloud)

ec_min = minimum(ec_net_orraroc)
p_min = findfirst( (in)(ec_min), ec_net_orraroc)

## Optimizing Reinsurance EVA no constraints ====================
println("Optimizing Reinsurance EVA no constraints ... ")

ins_input_oreva, avg_ceded_oreva, eva_net_oreva,
avg_ceded_opt_oreva, eva_net_opt_oreva =
  optreeva(ins_input_ofr, inv_input_oc, tau_kendall, n_scen,
           α,  s, costs_fixed, n_cloud, hurdle)

avg_ceded_ofr =
  ins_input_ofr[:re_ceded] ⋅ ins_input_ofr[:premium] /
  sum(ins_input_ofr[:premium])
eva_net_ofr = profit_net_ofr_opt - hurdle * ec_net_ofr_opt

## Optim. Reins. RAROC prescribed average reinsurance quote =====
println("Optim. Reins. RAROC prescr. average reins. quote ...")

ins_input_or, ceded_or, profit_net_or, ec_net_or, rorac_net_or,
profit_net_or_opt, ec_net_or_opt, rorac_net_or_opt =
  optre(ins_input_ofr, inv_input_oc, tau_kendall, n_scen,
        α,  s, costs_fixed, n_cloud, avg_ceded_ofr)

Random.seed!(seed)
bu_oc, total_oc =
  project(ins_input_or, inv_input_oc, tau_kendall,
          n_scen, α, s, costs_fixed)

## Other levels of confidence ===================================
println("Other levels of confidence ...")

Random.seed!(seed)
bu_final, total_final =
  project(ins_input_or, inv_input_oc, tau_kendall,
          n_scen, α, s, costs_fixed)

var_α = [0.5, 0.75, 0.9, 0.99]
var_eco_cap = [es(-total_final.net.profit, 𝛽) for 𝛽 in var_α]

print("Mean total gross profit:      ")
println(round(total.gross.profit_mean, digits = 2))
print("Mean total net profit:        ")
println(round(total.net.profit_mean, digits = 2))
print("Total gross economic capital: ")
println(round(total.gross.eco_cap, digits = 2))
print("Total net economic capital:   ")
println(round(total.net.eco_cap, digits = 2))
print("Total gross RORAC:            ")
println(round(total.gross.rorac, digits = 2))
print("Total net RORAC:              ")
println(round(total.net.rorac, digits = 2))

print("Risk adj. pricing, fire loss ratio     : ")
println(round(ins_input_rp[1, :loss_ratio], digits = 4))
print("Risk adj. pricing, liability loss ratio: ")
println(round(ins_input_rp[2, :loss_ratio], digits = 4))
print("Risk adj. pricing, theft loss ratio:     ")
println(round(ins_input_rp[3, :loss_ratio], digits = 4))

print("Optimal capital, net RORAC:  ")
println(round(ins_input_rp[3, :loss_ratio], digits = 4))

print("Optimal product mix with quota constraint, net RORAC:  ")
println(round(rorac_net_or_opt, digits = 4))

#################################################################
println("End ECModel \n")

ext: jl


text:
module Regression

export ridge, predict, mse, cross_validate, kfold, Kfold

include("cross_validation.jl")
include("ridge.jl")
include("mse.jl")

end

max_stars_repo_name: tbepler/julia-regression

max_issues_repo_name: tbepler/julia-regression

max_forks_repo_name: tbepler/julia-regression


text:
module FinEtoolsFlexBeams

__precompile__(true)

using FinEtools

include("RotUtilModule.jl")
include("VisUtilModule.jl")
include("CrossSectionModule.jl")
include("FESetCorotBeamModule.jl")
include("MeshFrameMemberModule.jl")
include("FEMMCorotBeamModule.jl")
include("FEMMPointMassModule.jl")
include("FEMMPointGroundedSpringModule.jl")

end # module


text:
using HttpServer
using WebSockets

#global Dict to store open connections in
global connections = Dict{Int,WebSocket}()
global usernames   = Dict{Int,String}()

function decodeMessage( msg )
    String(copy(msg))
end
function eval_or_describe_error(strmsg)
   try
       return eval(parse(strmsg, raise = false))
   catch err
        iob = IOBuffer()
        dump(iob, err)
        return String(take!(iob))
   end
end

wsh = WebSocketHandler() do req, client
    global connections
    connections[client.id] = client
    while true
        val = client |> read |> decodeMessage |> eval_or_describe_error
        output = String(take!(Base.mystreamvar))
        val = val == nothing ? "
" : val
        write(client,"$val
$output")
    end
end

onepage = readstring(Pkg.dir("CodeServer","src","repl.html"))
httph = HttpHandler() do req::Request, res::Response
  Response(onepage)
end

server = Server(httph, wsh)
println("Repl server listening on 8080...")

eval(Base,parse("mystreamvar = IOBuffer()"))
eval(Base,parse("STDOUT = mystreamvar"))

run(server,8080)


text:
### Broadcasting

Base.getindex(ds::AbstractDataset, idx::CartesianIndex{2}) = ds[idx[1], idx[2]]
Base.view(ds::AbstractDataset, idx::CartesianIndex{2}) = view(ds, idx[1], idx[2])
Base.setindex!(ds::AbstractDataset, val, idx::CartesianIndex{2}) =
    (ds[idx[1], idx[2]] = val)

Base.broadcastable(ds::AbstractDataset) = ds
Base.broadcastable(col::DatasetColumn) = __!(col)
Base.broadcastable(col::SubDatasetColumn) = __!(col)

function _our_copy(ds::Dataset; copycols = true)
    # TODO currently if the observation is mutable, copying data set doesn't protect it
    # Create Dataset
    newds = Dataset(copy(_columns(ds)), copy(index(ds)); copycols = copycols)
    setinfo!(newds, _attributes(ds).meta.info[])
    return newds
end

struct DatasetStyle <: Base.Broadcast.BroadcastStyle end

Base.Broadcast.BroadcastStyle(::Type{<:AbstractDataset}) =
    DatasetStyle()

Base.Broadcast.BroadcastStyle(::DatasetStyle, ::Base.Broadcast.BroadcastStyle) =
    DatasetStyle()
Base.Broadcast.BroadcastStyle(::Base.Broadcast.BroadcastStyle, ::DatasetStyle) =
    DatasetStyle()
Base.Broadcast.BroadcastStyle(::DatasetStyle, ::DatasetStyle) = DatasetStyle()

function copyto_widen!(res::AbstractVector{T}, bc::Base.Broadcast.Broadcasted,
                       pos, col) where T
    for i in pos:length(axes(bc)[1])
        val = bc[CartesianIndex(i, col)]
        S = typeof(val)
        if S <: T || promote_type(S, T) <: T
            res[i] = val
        else
            newres = similar(Vector{promote_type(S, T)}, length(res))
            copyto!(newres, 1, res, 1, i-1)
            newres[i] = val
            return copyto_widen!(newres, bc, i + 1, col)
        end
    end
    return res
end

function getcolbc(bcf::Base.Broadcast.Broadcasted{Style}, colind) where {Style}
    # we assume that bcf is already flattened and unaliased
    newargs = map(bcf.args) do x
        Base.Broadcast.extrude(x isa AbstractDataset ? _columns(x)[colind] : x)
    end
    return Base.Broadcast.Broadcasted{Style}(bcf.f, newargs, bcf.axes)
end

function Base.copy(bc::Base.Broadcast.Broadcasted{DatasetStyle})
    ndim = length(axes(bc))
    if ndim != 2
        throw(DimensionMismatch("cannot broadcast a data set into $ndim dimensions"))
    end
    bcf = Base.Broadcast.flatten(bc)
    colnames = unique!(Any[_names(ds) for ds in bcf.args if ds isa AbstractDataset])
    if length(colnames) != 1
        wrongnames = setdiff(union(colnames...), intersect(colnames...))
        if isempty(wrongnames)
            throw(ArgumentError("Column names in broadcasted data sets " *
                                "must have the same order"))
        else
            msg = join(wrongnames, ", ", " and ")
            throw(ArgumentError("Column names in broadcasted data sets must match. " *
                                "Non matching column names are $msg"))
        end
    end
    nrows = length(axes(bcf)[1])
    ds = Dataset()
    for i in axes(bcf)[2]
        if nrows == 0
            col = Any[]
        else
            bcf′ = getcolbc(bcf, i)
            v1 = bcf′[CartesianIndex(1, i)]
            startcol = similar(Vector{typeof(v1)}, nrows)
            startcol[1] = v1
            col = copyto_widen!(startcol, bcf′, 2, i)
        end
        ds[!, colnames[1][i]] = col
    end
    return ds
end

### Broadcasting assignment

struct LazyNewColDataset{T}
    ds::Dataset
    col::T
end

Base.axes(x::LazyNewColDataset) = (Base.OneTo(nrow(x.ds)),)
Base.ndims(::Type{<:LazyNewColDataset}) = 1
Base.materialize!(::DatasetColumn, ::Base.Broadcast.Broadcasted) =
        throw(ArgumentError("syntax ds.column .= val is not supported, use ds[!, column] .= val instead"))
struct ColReplaceDataset
    ds::Dataset
    cols::Vector{Int}
end

Base.axes(x::ColReplaceDataset) = (axes(x.ds, 1), Base.OneTo(length(x.cols)))
Base.ndims(::Type{ColReplaceDataset}) = 2

Base.maybeview(ds::AbstractDataset, idx::CartesianIndex{2}) = ds[idx]
Base.maybeview(ds::AbstractDataset, row::Integer, col::ColumnIndex) = ds[row, col]
Base.maybeview(ds::AbstractDataset, rows, cols) = view(ds, rows, cols)
Base.maybeview(col1::DatasetColumn, rows) = view(col1, rows)
Base.maybeview(col1::SubDatasetColumn, rows) = view(col1, rows)

function Base.dotview(ds::Dataset, ::Colon, cols::ColumnIndex)
    haskey(index(ds), cols) && return view(ds, :, cols)
    if !(cols isa SymbolOrString)
        throw(ArgumentError("creating new columns using an integer index is disallowed"))
    end
    return LazyNewColDataset(ds, Symbol(cols))
end

function Base.dotview(ds::Dataset, ::typeof(!), cols)
    if !(cols isa ColumnIndex)
        return ColReplaceDataset(ds, index(ds)[cols])
    end
    if !(cols isa SymbolOrString) && cols > ncol(ds)
        throw(ArgumentError("creating new columns using an integer index is disallowed"))
    end
    return LazyNewColDataset(ds, cols isa AbstractString ? Symbol(cols) : cols)
end

# Base.dotview(ds::SubDataset, ::typeof(!), idxs) =
    # throw(ArgumentError("broadcasting with ! row selector is not allowed for SubDataset"))

# TODO: remove the deprecations when Julia 1.7 functionality is commonly used
#       by the community
if isdefined(Base, :dotgetproperty)
    function Base.dotgetproperty(ds::Dataset, col::SymbolOrString)
        if columnindex(ds, col) == 0
            return LazyNewColDataset(ds, Symbol(col))
        else
            Base.depwarn("In the future this operation will allocate a new column " *
                         "instead of performing an in-place assignment.", :dotgetproperty)
            return getproperty(ds, col)
        end
    end

    function Base.dotgetproperty(ds::SubDataset, col::SymbolOrString)
        Base.depwarn("broadcasting getproperty is deprecated for SubDataset and " *
                     "will be disallowed in  the future. Use `ds[:, $(repr(col))] .= ... instead",
                     :dotgetproperty)
        return getproperty(ds, col)
    end
end

# TODO we shouldn't allocate a vector here
function Base.copyto!(lazyds::LazyNewColDataset, bc::Base.Broadcast.Broadcasted{T}) where T
    if bc isa Base.Broadcast.Broadcasted{<:Base.Broadcast.AbstractArrayStyle{0}}
        bc_tmp = Base.Broadcast.Broadcasted{T}(bc.f, bc.args, ())
        v = Base.Broadcast.materialize(bc_tmp)
        col = similar(Vector{Union{typeof(v), Missing}}, nrow(lazyds.ds))
        copyto!(col, bc)
    else
        col = Base.Broadcast.materialize(bc)
    end
    lazyds.ds[!, lazyds.col] = col
end

function Base.copyto!(col1::SubDatasetColumn, bc::Base.Broadcast.Broadcasted{T}) where T
    if bc isa Base.Broadcast.Broadcasted{<:Base.Broadcast.AbstractArrayStyle{0}}
        bc_tmp = Base.Broadcast.Broadcasted{T}(bc.f, bc.args, ())
        v = Base.Broadcast.materialize(bc_tmp)
        col = similar(Vector{Union{Missing, typeof(v)}}, length(col1))
        copyto!(col, bc)
    else
        col = Base.Broadcast.materialize(bc)
    end
    col1.val[col1.selected_index] = col
    if col1.col ∈ index(col1.ds).sortedcols
        _reset_grouping_info!(col1.ds)
    end
    _modified(_attributes(col1.ds))
    col
end

function _fill_copyto_helper!(incol, bc, col)
    @inbounds for row in eachindex(incol)
        incol[row] = bc[CartesianIndex(row, col)]
    end
end

function _copyto_helper!(dscol::AbstractVector, bc::Base.Broadcast.Broadcasted, col::Int)
    if axes(dscol, 1) != axes(bc)[1]
        # this should never happen unless data frame is corrupted (has unequal column lengths)
        throw(DimensionMismatch("Dimension mismatch in broadcasting. The updated" *
                                " data frame is invalid and should not be used"))
    end
    _fill_copyto_helper!(dscol, bc, col)
end
function _copyto_helper!(dscol::Union{SubDatasetColumn, DatasetColumn}, bc::Base.Broadcast.Broadcasted, col::Int)
    if axes(__!(dscol), 1) != axes(bc)[1]
        # this should never happen unless data frame is corrupted (has unequal column lengths)
        throw(DimensionMismatch("Dimension mismatch in broadcasting. The updated" *
                                " data frame is invalid and should not be used"))
    end
    _fill_copyto_helper!(__!(dscol), bc, col)
    _modified(_attributes(dscol.ds))
end

function Base.Broadcast.broadcast_unalias(dest::AbstractDataset, src)
    for i in 1:ncol(dest)
        src = Base.Broadcast.unalias(_columns(dest)[i], src)
    end
    return src
end

function Base.Broadcast.broadcast_unalias(dest, src::AbstractDataset)
    wascopied = false
    for (i, col) in enumerate(eachcol(src))
        if Base.mightalias(dest, __!(col))
            if src isa SubDataset
                if !wascopied
                    src = SubDataset(_our_copy(parent(src), copycols=false),
                                       index(src), rows(src))
                end
                parentidx = parentcols(index(src), i)
                parent(src)[!, parentidx] = Base.unaliascopy(_columns(parent(src))[parentidx])
            else
                if !wascopied
                    src = _our_copy(src, copycols=false)
                end
                src[!, i] = Base.unaliascopy(__!(col))
            end
            wascopied = true
        end
    end
    return src
end

#TODO for view of data sets parent columns are copyied, e.g. view(ds, 1:10, :) .+= 1
function _broadcast_unalias_helper(dest::AbstractDataset, scol::AbstractVector,
                                   src::AbstractDataset, col2::Int, wascopied::Bool)
    # col1 can be checked till col2 point as we are writing broadcasting
    # results from 1 to ncol
    # we go downwards because aliasing when col1 == col2 is most probable
    for col1 in col2:-1:1
        dcol = _columns(dest)[col1] #dest[!, col1]
        if Base.mightalias(dcol, scol)
            if src isa SubDataset
                if !wascopied
                    src =SubDataset(_our_copy(parent(src), copycols=false),
                                      index(src), rows(src))
                end
                parentidx = parentcols(index(src), col2)
                parent(src)[!, parentidx] = Base.unaliascopy(_columns(parent(src))[parentidx])
                # parent(src)[!, parentidx] = Base.unaliascopy(parent(src)[!, parentidx])
            else
                if !wascopied
                    src = _our_copy(src, copycols=false)
                end
                src[!, col2] = Base.unaliascopy(scol)
            end
            return src, true
        end
    end
    return src, wascopied
end

_broadcast_unalias_helper(dest::AbstractDataset, scol::DatasetColumn,
                                   src::AbstractDataset, col2::Int, wascopied::Bool) = _broadcast_unalias_helper(dest, scol.val,
                                                                      src, col2, wascopied)
_broadcast_unalias_helper(dest::AbstractDataset, scol::SubDatasetColumn,
                                 src::AbstractDataset, col2::Int, wascopied::Bool) = _broadcast_unalias_helper(dest, __!(scol),
                                                                    src, col2, wascopied)

function Base.Broadcast.broadcast_unalias(dest::AbstractDataset, src::AbstractDataset)
    if size(dest, 2) != size(src, 2)
        throw(DimensionMismatch("Dimension mismatch in broadcasting."))
    end
    wascopied = false
    for col2 in axes(dest, 2)
        scol = src[!, col2]
        src, wascopied = _broadcast_unalias_helper(dest, scol, src, col2, wascopied)
    end
    _modified(_attributes(dest))
    return src
end

function Base.copyto!(ds::AbstractDataset, bc::Base.Broadcast.Broadcasted)
    bcf = Base.Broadcast.flatten(bc)
    colnames = unique!(Any[_names(x) for x in bcf.args if x isa AbstractDataset])
    if length(colnames) > 1 || (length(colnames) == 1 && _names(ds) != colnames[1])
        push!(colnames, _names(ds))
        wrongnames = setdiff(union(colnames...), intersect(colnames...))
        if isempty(wrongnames)
            throw(ArgumentError("Column names in broadcasted data frames " *
                                "must have the same order"))
        else
            msg = join(wrongnames, ", ", " and ")
            throw(ArgumentError("Column names in broadcasted data frames must match. " *
                                "Non matching column names are $msg"))
        end
    end

    bcf′ = Base.Broadcast.preprocess(ds, bcf)
    for i in axes(ds, 2)
        _copyto_helper!(ds[!, i], getcolbc(bcf′, i), i)
    end
    return ds
end

function Base.copyto!(ds::AbstractDataset,
                      bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.AbstractArrayStyle{0}})
    # special case of fast approach when bc is providing an untransformed scalar
    if bc.f === identity && bc.args isa Tuple{Any} && Base.Broadcast.isflat(bc)
        for col in axes(ds, 2)
            fill!(_columns(ds)[col], bc.args[1][])
        end
        _modified(_attributes(ds))
        return ds
    else
        return copyto!(ds, convert(Base.Broadcast.Broadcasted{Nothing}, bc))
    end
end

create_bc_tmp(bcf′_col::Base.Broadcast.Broadcasted{T}) where {T} =
    Base.Broadcast.Broadcasted{T}(bcf′_col.f, bcf′_col.args, ())

function Base.copyto!(crds::ColReplaceDataset, bc::Base.Broadcast.Broadcasted)
    bcf = Base.Broadcast.flatten(bc)
    colnames = unique!(Any[_names(x) for x in bcf.args if x isa AbstractDataset])
    if length(colnames) > 1 ||
        (length(colnames) == 1 && view(_names(crds.ds), crds.cols) != colnames[1])
        push!(colnames, view(_names(crds.ds), crds.cols))
        wrongnames = setdiff(union(colnames...), intersect(colnames...))
        if isempty(wrongnames)
            throw(ArgumentError("Column names in broadcasted data frames " *
                                "must have the same order"))
        else
            msg = join(wrongnames, ", ", " and ")
            throw(ArgumentError("Column names in broadcasted data frames must match. " *
                                "Non matching column names are $msg"))
        end
    end

    bcf′ = Base.Broadcast.preprocess(crds, bcf)
    nrows = length(axes(bcf′)[1])
    for (i, col_idx) in enumerate(crds.cols)
        bcf′_col = getcolbc(bcf′, i)
        if bcf′_col isa Base.Broadcast.Broadcasted{<:Base.Broadcast.AbstractArrayStyle{0}}
            bc_tmp = create_bc_tmp(bcf′_col)
            v = Base.Broadcast.materialize(bc_tmp)
            newcol = similar(Vector{Union{Missing, typeof(v)}}, nrow(crds.ds))
            copyto!(newcol, bc)
        else
            if nrows == 0
                newcol = Any[]
            else
                v1 = bcf′_col[CartesianIndex(1, i)]
                startcol = similar(Vector{Union{Missing, typeof(v1)}}, nrows)
                startcol[1] = v1
                newcol = copyto_widen!(startcol, bcf′_col, 2, i)
            end
        end
        crds.ds[!, col_idx] = newcol
    end
    return crds.ds
end

Base.Broadcast.broadcast_unalias(dest::DatasetRow, src) =
    Base.Broadcast.broadcast_unalias(parent(dest), src)

function Base.copyto!(dsr::DatasetRow, bc::Base.Broadcast.Broadcasted)
    bc′ = Base.Broadcast.preprocess(dsr, bc)
    for I in eachindex(bc′)
        dsr[I] = bc′[I]
    end
    return dsr
end


text:
# This file is auto-generated by AWSMetadata.jl
using AWS
using AWS.AWSServices: route53_recovery_cluster
using AWS.Compat
using AWS.UUIDs

"""
    get_routing_control_state(routing_control_arn)
    get_routing_control_state(routing_control_arn, params::Dict{String,<:Any})

Get the state for a routing control. A routing control is a simple on/off switch that you
can use to route traffic to cells. When the state is On, traffic flows to a cell. When it's
off, traffic does not flow.  Before you can create a routing control, you first must create
a cluster to host the control. For more information, see CreateCluster. Access one of the
endpoints for the cluster to get or update the routing control state to redirect traffic.
For more information about working with routing controls, see Routing control in the Route
53 Application Recovery Controller Developer Guide.

# Arguments
- `routing_control_arn`: The Amazon Resource Number (ARN) for the routing control that you
  want to get the state for.

"""
function get_routing_control_state(
    RoutingControlArn; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_cluster(
        "GetRoutingControlState",
        Dict{String,Any}("RoutingControlArn" => RoutingControlArn);
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function get_routing_control_state(
    RoutingControlArn,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_cluster(
        "GetRoutingControlState",
        Dict{String,Any}(
            mergewith(
                _merge, Dict{String,Any}("RoutingControlArn" => RoutingControlArn), params
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_routing_control_state(routing_control_arn, routing_control_state)
    update_routing_control_state(routing_control_arn, routing_control_state, params::Dict{String,<:Any})

Set the state of the routing control to reroute traffic. You can set the value to be On or
Off. When the state is On, traffic flows to a cell. When it's off, traffic does not flow.
For more information about working with routing controls, see Routing control in the Route
53 Application Recovery Controller Developer Guide.

# Arguments
- `routing_control_arn`: The Amazon Resource Number (ARN) for the routing control that you
  want to update the state for.
- `routing_control_state`: The state of the routing control. You can set the value to be On
  or Off.

"""
function update_routing_control_state(
    RoutingControlArn,
    RoutingControlState;
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_cluster(
        "UpdateRoutingControlState",
        Dict{String,Any}(
            "RoutingControlArn" => RoutingControlArn,
            "RoutingControlState" => RoutingControlState,
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_routing_control_state(
    RoutingControlArn,
    RoutingControlState,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_cluster(
        "UpdateRoutingControlState",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "RoutingControlArn" => RoutingControlArn,
                    "RoutingControlState" => RoutingControlState,
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end

"""
    update_routing_control_states(update_routing_control_state_entries)
    update_routing_control_states(update_routing_control_state_entries, params::Dict{String,<:Any})

Set multiple routing control states. You can set the value for each state to be On or Off.
When the state is On, traffic flows to a cell. When it's off, traffic does not flow. For
more information about working with routing controls, see Routing control in the Route 53
Application Recovery Controller Developer Guide.

# Arguments
- `update_routing_control_state_entries`: A set of routing control entries that you want to
  update.

"""
function update_routing_control_states(
    UpdateRoutingControlStateEntries; aws_config::AbstractAWSConfig=global_aws_config()
)
    return route53_recovery_cluster(
        "UpdateRoutingControlStates",
        Dict{String,Any}(
            "UpdateRoutingControlStateEntries" => UpdateRoutingControlStateEntries
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end
function update_routing_control_states(
    UpdateRoutingControlStateEntries,
    params::AbstractDict{String};
    aws_config::AbstractAWSConfig=global_aws_config(),
)
    return route53_recovery_cluster(
        "UpdateRoutingControlStates",
        Dict{String,Any}(
            mergewith(
                _merge,
                Dict{String,Any}(
                    "UpdateRoutingControlStateEntries" => UpdateRoutingControlStateEntries
                ),
                params,
            ),
        );
        aws_config=aws_config,
        feature_set=SERVICE_FEATURE_SET,
    )
end


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

using Markdown
using InteractiveUtils

# ╔═╡ c09f8480-fe4b-11ea-2f60-b315991fbf20
using Pkg, DrWatson

# ╔═╡ c0c7bd2e-fe4b-11ea-3f66-6dc48fb0eace
begin
	#@quickactivate "StatisticalRethinkingStan"
	using StanSample
	using StatisticalRethinking
end

# ╔═╡ 99746fa2-fe4a-11ea-0d78-9bad2014c6ce
md"## Clip-06-01s.jl"

# ╔═╡ c0c8b03a-fe4b-11ea-33f6-91a335f4d901
begin
	N = 200
	prob = 0.1

	df = DataFrame(
	  nw = rand(Normal(), N),
	  tw = rand(Normal(), N)
	)
	df.s = df.tw + df.nw
	scale!(df, [:s, :nw, :tw])

	q = quantile(df.s, 1-prob)

	selected_df = filter(row -> row.s > q, df)
	unselected_df = filter(row -> row.s <= q, df)

	cor(selected_df.nw, selected_df.tw)
end

# ╔═╡ c0ce63ae-fe4b-11ea-0438-0359324fac9b
stan6_0 = "
data {
  int <lower=1> N;
  vector[N] nw;
  vector[N] tw;
}
parameters {
  real a;
  real aS;
  real <lower=0> sigma;
}
model {
  vector[N] mu;
  mu = a + aS * nw;
  a ~ normal(0, 5.0);
  aS ~ normal(0, 1.0);
  sigma ~ exponential(1);
  tw ~ normal(mu, sigma);
}
";

# ╔═╡ c0df6122-fe4b-11ea-0d95-5366fce018a1
begin
	m6_0s = SampleModel("m6.0s", stan6_0)
	m_6_0_data = Dict(
	  :nw => selected_df.nw_s,
	  :tw => selected_df.tw_s,
	  :N => size(selected_df, 1)
	)
	rc6_0s = stan_sample(m6_0s, data=m_6_0_data)
	success(rc6_0s) && (part6_0s = read_samples(m6_0s, :particles))
end

# ╔═╡ c0e0cf76-fe4b-11ea-0130-3f2bb12f36a0
if success(rc6_0s)
  x = -2.0:0.01:3.0
  plot(xlabel="newsworthiness", ylabel="trustworthiness",
    title="Science distortion")
  scatter!(selected_df[:, :nw], selected_df[:, :tw], color=:blue, lab="selected")
  scatter!(unselected_df[:, :nw], unselected_df[:, :tw], color=:lightgrey, lab="unselected")
  plot!(x, mean(part6_0s.a) .+ mean(part6_0s.aS) .* x, lab="Regression line")
end

# ╔═╡ 5bfe710c-fe4c-11ea-16c2-fdb21351103b
if success(rc6_0s)
  post6_0s_df = read_samples(m6_0s, :dataframe)
  fig1 = plotbounds(df, :nw, :tw, post6_0s_df , [:a, :aS, :sigma])
  scatter!(unselected_df[:, :nw], unselected_df[:, :tw], color=:lightgrey, lab="unselected")
end

# ╔═╡ c0eed12a-fe4b-11ea-2f8c-3f4aed9007fd
md"## End of clip-06-01s.jl"

# ╔═╡ Cell order:
# ╟─99746fa2-fe4a-11ea-0d78-9bad2014c6ce
# ╠═c09f8480-fe4b-11ea-2f60-b315991fbf20
# ╠═c0c7bd2e-fe4b-11ea-3f66-6dc48fb0eace
# ╠═c0c8b03a-fe4b-11ea-33f6-91a335f4d901
# ╠═c0ce63ae-fe4b-11ea-0438-0359324fac9b
# ╠═c0df6122-fe4b-11ea-0d95-5366fce018a1
# ╠═c0e0cf76-fe4b-11ea-0130-3f2bb12f36a0
# ╠═5bfe710c-fe4c-11ea-16c2-fdb21351103b
# ╟─c0eed12a-fe4b-11ea-2f8c-3f4aed9007fd