text:
const DEFAULT_NUM_POLYS = 4

struct StochGalerkinODE{
    odeFuncType,
    dimType,
    varsType,
    numPolysType,
    indsDegType,
    polysType,
    gridType,
    normMapType,
}
    ode_func!::odeFuncType
    dim_::dimType
    vars::varsType
    num_polys::numPolysType
    indices_polys::indsDegType
    poly_basis::polysType
    grid::gridType
    normalization_map::normMapType

    function StochGalerkinODE(ode_func!, dim_, vars; wType = Float64, num_polys = nothing)

        if num_polys === nothing
            num_polys = Tuple(DEFAULT_NUM_POLYS for i in Base.OneTo(length(vars)))
        end

        @assert length(vars) == length(num_polys)

        indices_polys = CartesianIndices(num_polys)
        num_vars = length(vars)

        poly_basis_temp = Vector{OrthogonalPolyBasis}(undef, num_vars)

        for i in Base.OneTo(length(vars))
            var = vars[i]
            if var isa Uniform
                @assert var.a ≈ -1.0 && var.b ≈ 1.0
                poly_basis_temp[i] = LegendrePolyBasis(num_polys[i]; wType)
            elseif var isa Normal
                # Using physicist's hermite polynomial
                @assert var.μ ≈ 0.0 && var.σ ≈ sqrt(2.0) / 2
                poly_basis_temp[i] = HermitePolyBasis(num_polys[i]; wType)
            else
                throw("Not implemented")
            end
        end

        poly_basis = Tuple(poly_basis_temp)

        grid = TensorIntegrationGrid(dim_, num_polys, vars; wType)

        normalization_map = zeros(wType, num_polys)

        for index in CartesianIndices(normalization_map)
            normalization_map[index] = mapreduce(
                i -> dot(
                    grid.quads[i].weights,
                    (x -> poly_basis[i](x, index[i] - 1)^2).(grid.quads[i].nodes),
                ),
                *,
                Base.OneTo(length(index)),
            )
        end

        return new{
            typeof(ode_func!),
            typeof(dim_),
            typeof(vars),
            typeof(num_polys),
            typeof(indices_polys),
            typeof(poly_basis),
            typeof(grid),
            typeof(normalization_map),
        }(
            ode_func!,
            dim_,
            vars,
            num_polys,
            indices_polys,
            poly_basis,
            grid,
            normalization_map,
        )
    end
end

struct StochGalerkinODECache{yHatType,yHatGridType,intEstType,argCacheType,odeCacheType}
    y_hat::yHatType
    y_hat_for_grid::yHatGridType
    integral_est::intEstType
    arg_cache::argCacheType
    ode_cache::odeCacheType

    function StochGalerkinODECache(s::StochGalerkinODE, u)
        @unpack dim_, vars, num_polys = s

        uType = eltype(u)
        num_vars = length(vars)

        y_hat = zeros(uType, dim_)
        y_hat_for_grid = zeros(uType, dim_, num_polys...)
        integral_est = zeros(uType, dim_)
        arg_cache = zeros(uType, num_vars)
        ode_cache = zeros(uType, dim_)

        return new{
            typeof(y_hat),
            typeof(y_hat_for_grid),
            typeof(integral_est),
            typeof(arg_cache),
            typeof(ode_cache),
        }(
            y_hat,
            y_hat_for_grid,
            integral_est,
            arg_cache,
            ode_cache,
        )
    end
end

@inline function compute_poly_prod(
    s::StochGalerkinODE,
    c::StochGalerkinODECache,
    index::CartesianIndex,
)
    @unpack poly_basis = s
    @unpack arg_cache = c
    prod = one(first(arg_cache))
    @inbounds for i in Base.OneTo(length(index))
        prod *= poly_basis[i](arg_cache[i], index[i] - 1)
    end
    return prod
end

@inline function compute_weights_prod(s::StochGalerkinODE, index::CartesianIndex)
    @unpack grid = s
    @unpack quads = grid
    prod = one(eltype(first(quads).weights))
    @inbounds for i in Base.OneTo(length(index))
        prod *= quads[i].weights[index[i]]
    end
    return prod
end

@inline function set_arg!(
    s::StochGalerkinODE,
    c::StochGalerkinODECache,
    index::CartesianIndex,
)
    @unpack grid = s
    @unpack arg_cache = c
    @unpack quads = grid
    @inbounds for i in Base.OneTo(length(index))
        arg_cache[i] = quads[i].nodes[index[i]]
    end
    nothing
end

function y_hat_expand!(s::StochGalerkinODE, c::StochGalerkinODECache, u)
    @unpack indices_polys, poly_basis = s
    @unpack y_hat, arg_cache = c
    yType = eltype(y_hat)
    fill!(y_hat, zero(yType))
    @inbounds for index in indices_polys
        # Compiler can't infer without this
        prod::yType = compute_poly_prod(s, c, index)
        y_hat .+= (@view u[:, index]) .* prod
    end
    nothing
end

function set_inner_prod!(s::StochGalerkinODE, c::StochGalerkinODECache, u)
    @unpack grid = s
    @unpack y_hat, y_hat_for_grid = c
    @unpack quad_indices = grid
    @inbounds for index in quad_indices
        set_arg!(s, c, index)
        y_hat_expand!(s, c, u)
        y_hat_for_grid[:, index] .= y_hat
    end
    nothing
end

function integrate!(
    s::StochGalerkinODE,
    c::StochGalerkinODECache,
    u,
    p,
    t,
    index::CartesianIndex,
)
    @unpack ode_func!, poly_basis, grid = s
    @unpack y_hat, y_hat_for_grid, integral_est, arg_cache, ode_cache = c
    @unpack quad_indices = grid
    fill!(integral_est, zero(eltype(integral_est)))
    @inbounds for index_ in quad_indices
        set_arg!(s, c, index_)
        prod = compute_poly_prod(s, c, index) * compute_weights_prod(s, index_)
        y_hat .= (@view y_hat_for_grid[:, index_])
        ode_func!(ode_cache, y_hat, p, arg_cache, t)
        integral_est .+= ode_cache .* prod
    end
    nothing
end

function stoch_galerkin_ode_dynamics!(s::StochGalerkinODE, du, u, p, t)
    c = StochGalerkinODECache(s, u)
    stoch_galerkin_ode_dynamics!(s, c, du, p, t)
    nothing
end

function stoch_galerkin_ode_dynamics!(
    s::StochGalerkinODE,
    c::StochGalerkinODECache,
    du,
    u,
    p,
    t,
)
    @unpack indices_polys, normalization_map = s
    @unpack integral_est = c
    set_inner_prod!(s, c, u)
    @inbounds for index in indices_polys
        norm_const = normalization_map[index]
        integrate!(s, c, u, p, t, index)
        du[:, index] .= integral_est ./ norm_const
    end
    nothing
end

function (s::StochGalerkinODE)(u0, tspan, p; re_use_cache = true, kwargs...)
    @unpack dim_, num_polys = s
    u_orth_0 = zeros(eltype(u0), dim_, num_polys...)
    u_orth_0[:, CartesianIndex(Tuple(1 for i in num_polys))] .= u0
    if re_use_cache
        local c = StochGalerkinODECache(s, u_orth_0)
        dynamics_iip(du, u, p, t) = stoch_galerkin_ode_dynamics!(s, c, du, u, p, t)
        prob = ODEProblem(dynamics_iip, u_orth_0, tspan, p)
        sol = solve(prob; kwargs...)
    else
        dynamics_oop(du, u, p, t) = stoch_galerkin_ode_dynamics!(s, du, u, p, t)
        prob = ODEProblem(dynamics_oop, u_orth_0, tspan, p)
        sol = solve(prob; kwargs...)
    end
    return sol
end

max_stars_repo_name: d-netto/PolyChaosODE

max_issues_repo_name: d-netto/PolyChaosODE

max_forks_repo_name: d-netto/PolyChaosODE


text:
unary_diff = Dict(
    (cos) => x -> -sin(x),
    (sin) => x -> cos(x),
    (tan) => x -> tan(x)^2 + 1,
    (acos) => x -> -1/sqrt(-x^2 + 1),
    (asin) => x -> 1/sqrt(-x^2 + 1),
    (atan) => x -> 1/(x^2 + 1),
    (+) => x -> 1,
    (-) => x -> -1)

binary1_diff = Dict(
    (+) => ( x, y ) -> 1,
    (-) => ( x, y ) -> 1,
    (*) => ( x, y ) -> y,
    (/) => ( x, y ) -> 1/y,
    (^) => ( x, y ) -> x^y*y/x)

binary2_diff = Dict(
    (+) => ( x, y ) -> 1,
    (-) => ( x, y ) -> -1,
    (*) => ( x, y ) -> x,
    (/) => ( x, y ) -> -x/y^2,
    (^) => ( x, y ) -> x^y*log(x))

ext: jl

max_stars_repo_name: sabjohnso/AutoDiff

max_issues_repo_name: sabjohnso/AutoDiff

max_forks_repo_name: sabjohnso/AutoDiff


text:
using LibBSON
@static if VERSION < v"0.7-"
    using Base.Test
else
    using Test
    using Dates
end

@testset "BSONOID" begin
    oid = BSONOID()
    @test length(string(oid)) == 24
    @test oid == oid
    @test isa(hash(oid), UInt)
    oid2 = BSONOID()
    @test oid != oid2
    @test string(BSONOID("540b628bca2e9b0d4e7dfa61")) == "540b628bca2e9b0d4e7dfa61"
end

@testset "BSONObject" begin
    bsonObject = BSONObject(Dict{Any,Any}(
        "null"=>nothing,
        "bool"=>true,
        "int"=>42,
        "double"=>0.125,
        "string"=>"Hello, Jérôme",
        "anotherNull"=>:null,
        "minkey"=>:minkey,
        "maxkey"=>:maxkey,
        "regularSymbol"=>:symbol,
        "binaryData"=>collect(map(t -> UInt8(t), 1:20)),
        "subdict"=> (Dict{Any,Any}(
            "key"=>"value"
            )),
        "array"=> Any["hello", (Dict{Any,Any}("foo" => Any[56, false]))]
        ))
    @test length(bsonObject) == 12
    #@test string(bsonObject) == "{ \"string\" : \"Hello, Jérôme\", \"anotherNull\" : null, \"null\" : null, \"regularSymbol\" : \"symbol\", \"bool\" : true, \"int\" : 42, \"minkey\" : { \"\$minKey\" : 1 }, \"maxkey\" : { \"\$maxKey\" : 1 }, \"binaryData\" : { \"\$binary\" : \"AQIDBAUGBwgJCgsMDQ4PEBESExQ=\", \"\$type\" : \"00\" }, \"array\" : [ \"hello\", { \"foo\" : [ 56, false ] } ], \"subdict\" : { \"key\" : \"value\" }, \"double\" : 0.125 }"
    @test dict(bsonObject) == Dict{Any,Any}("string"=>"Hello, Jérôme","anotherNull"=>nothing,"null"=>nothing,"regularSymbol"=>"symbol","bool"=>true,"int"=>42,"minkey"=>:minkey,"maxkey"=>:maxkey,"binaryData"=>collect(map(t -> UInt8(t), 1:20)), "array"=>Any["hello",(Dict{Any,Any}("foo"=>Any[56,false]))],"subdict"=>(Dict{Any,Any}("key"=>"value")),"double"=>0.125)
    append(bsonObject, "int64", -57)
    @test bsonObject["int64"] == -57
    append(bsonObject, "int32", 0x12345678)
    @test bsonObject["int32"] == 305419896

    @testset "BSONObject Copy Constructor" begin
        initialDict = Dict{Any,Any}("someText" => "hello")
        bsonObject = BSONObject(initialDict)
        bsonObjectCopyBad  = bsonObject
        bsonObjectCopyGood = BSONObject(bsonObject)
        append(bsonObject, "someValue", -123.456)
        @test dict(bsonObject) != initialDict
        @test dict(bsonObjectCopyBad) != initialDict
        @test dict(bsonObjectCopyGood) == initialDict
    end

    @testset "BSONObject with OID" begin
        oid = BSONOID()
        bsonObject = BSONObject(Dict{Any,Any}("oid" => oid))
        @test length(string(bsonObject)) > 0
        @test bsonObject["oid"] == oid
    end

    @testset "BSONObject with DateTime" begin
        ts = now()
        d = Date()
        obj = BSONObject(Dict("time" => ts, "date" => d))
        @test obj["time"] == ts
        @test obj["date"] == d
    end

    @testset "BSONObject from JSON" begin
        @test_throws ErrorException BSONObject("invalid JSON")
        @test BSONObject("{\"pi\": 0.125}")["pi"] == 0.125
    end

    @testset "BSONObject containing BSONObject" begin
        subBSONObject = BSONObject(Dict{Any,Any}("key"=>"value"))
        bsonObject = BSONObject(Dict{Any,Any}("sub"=>subBSONObject))
        @test string(bsonObject) == "{ \"sub\" : { \"key\" : \"value\" } }"
        @test string(bsonObject["sub"]) == "{ \"key\" : \"value\" }"
    end
end

@testset "BSONArray" begin
    bsonArray = BSONArray([
        nothing,
        true,
        42,
        0.125,
        "Hello, Jérôme",
        :null,
        :minkey,
        :maxkey,
        :symbol
        ])

    @test length(bsonArray) == 9
    #@test string(bsonArray) == "[ null, true, 42, 0.125, \"Hello, Jérôme\", null, { \"\$minKey\" : 1 }, { \"\$maxKey\" : 1 }, \"symbol\" ]"
    @test vector(bsonArray) == Any[nothing,true,42,0.125,"Hello, Jérôme",nothing,:minkey,:maxkey,"symbol"]
    append(bsonArray, BSONArray([false]))
    append(bsonArray, -67)
    append(bsonArray, ["hello", 6.7])
    @test vector(bsonArray) == Any[nothing,true,42,0.125,"Hello, Jérôme",nothing,:minkey,:maxkey,"symbol",Any[false],-67,["hello",6.7]]

    bsonArray = BSONArray()
    append(bsonArray, BSONOID())
    @test length(bsonArray) == 1

    @testset "Array of DateTimes" begin
      ts = now()
      d = Date()
      arr = BSONArray([d,ts])
      @test length(arr) == 2
      @test arr[1] == d
      @test arr[2] == ts

      for i = 1:length(arr)
        @test isa(arr[i], DateTime)
      end

    end
end

@testset "BSONObject: get!" begin
    bsonObject = BSONObject()
    @test_throws ErrorException bsonObject["foo"]
    @test get!(bsonObject, "foo", true)
    @test get!(bsonObject, "foo", true)
end

@testset "BSONError" begin
    err = BSONError()
    @test isa(string(err), AbstractString)
end

#@testset "Issue 18" begin
#    @test string(BSONObject(DataStructures.OrderedDict("a" => DataStructuresOrderedDict("b" => "c")))) --> "{ \"a\" : { \"b\" : \"c\" } }"
#end


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

using Markdown
using InteractiveUtils

# ╔═╡ d5d8aca7-1771-4bd9-9761-11b667f894fa
using Plots, Latexify, LaTeXStrings, DataFrames, PlutoUI

# ╔═╡ 7a45e73e-2bc0-489f-a7e1-4daa852589e1
md"# Máquinas de Fluxo - TR1
\
**Alunos:**
* Alessandro Cappellini Portugal
* Rodrigo Kenji Kuroda
* Jean Carlos Reisdorfer
* Laís Tussi
* Stella Colferai
"

# ╔═╡ c7180b99-37f6-4494-aafb-57bdec113524
html"""

This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License."""

# ╔═╡ b42465ab-12ae-4e2e-a4dd-ccf375cd69f4
md"## NC 2733"

# ╔═╡ 67277e58-4e39-4ced-9135-ce059ed3fe51
begin
	e = [2.15, 3.11, 4.81, 7.06, 10, 13.1, 17.1, 22.1, 25.1, 28.4, 31.6, 34.7, 36.8, 41.7, 46.6, 51.7, 56]
	b₀ = [21280, 12260, 9312, 6937, 6219, 5105, 5363, 3960, 3063, 2967, 3113, 2449, 2237, 1979, 2266, 2266, 2266]
	b₁ = [1231, 973.3, 776.8, 697.9, 589.8, 572.8, 415.7, 362.1, 366, 333.3, 281.1, 302, 314, 325.3, 302, 302, 302]
end

# ╔═╡ 6de97699-ca2f-4d84-9c6c-0d1cf2fb9781
begin
	scatter(e,b₀,legend=true, xlabel="Thickness [m]", ylabel = "Unit pressure drop [Pa/m]", labels = "b₀", title = "NC 2733", xlim=(0,60),ylim=(0,25000))
	plot!(e, b₁, label = "b₁", seriestype = :scatter)
end

# ╔═╡ d9760d43-f85c-4574-b896-f098e52a5e9f
md"### Equação dos coeficientes e matriz A:

$b_{0}(e) = \frac{a_{0}}{e} + a_{1} = a_{0}\cdot e^{-1} + a_{1} = \begin{bmatrix} e^{-1} & 1 \end{bmatrix} \cdot \begin{bmatrix} a_{0}\\a_{1} \end{bmatrix}$

$A = \begin{bmatrix} e_{0} & 1 \\ e_{1} & 1 \\ \vdots & \vdots \\ e_{16} & 1 \end{bmatrix}$"

# ╔═╡ 0e89da5e-0028-4294-abca-62aa25435d4e
begin
	A = [e[i]^j for i in 1:17, j in -1:0]
	ê₀ = A \ b₀
	b̂₀(e) = ê₀' * [e^-1,1]
	ê₁ = A \ b₁
	b̂₁(e) = ê₁' * [e^-1,1]
	Print(ê₀, ê₁)
end

# ╔═╡ 183dfa02-3e9b-4d37-af9c-e14749d7bbed
begin
	plot!(b̂₀, label = "b₀(e)")
	plot!(b̂₁, label = "b₁(e)")
end

# ╔═╡ 7ca1454b-6b82-435f-8495-378634a92ddd
md"## NCX1116"

# ╔═╡ ce7b5b46-ce40-4fde-b919-4e7aa463621b
begin
	E = [5.12, 10, 13.2, 15.6, 20.4, 21.7, 25.3, 30.7, 37.5, 41.8, 44.9, 47.2, 50.8, 55, 59.9, 62.1]
	b₂ = [5665, 2689, 2144, 2236, 1592, 1872, 1151, 1196, 1334, 947, 1076, 1060, 1093, 888.7, 817.1, 949.2]
	b₃ = [256.2, 271.7, 235.9, 208.6, 171.3, 139.5, 155.8, 127.5, 93.9, 104.2, 91.3, 86.1, 79.9, 87.6, 86.7, 82.4]
end

# ╔═╡ 2a30f4cd-65cb-4fb6-bc45-7c3999e74ce0
begin
	scatter(E,b₂,legend=true, xlabel="Thickness [m]", ylabel = "Unit pressure drop [Pa/m]", label = "b₂", title = "NCX1116", xlim=(0,70), ylim=(0,6000))
	plot!(E, b₃, label = "b₃",seriestype = :scatter)
end

# ╔═╡ 63b5568d-8a7c-456d-912e-bf0f41821a27
md"### Equação dos coeficientes e matriz B:

$b_{2}(e) = \frac{a_{2}}{e} + a_{3} = a_{2}\cdot e^{-1} + a_{3} = \begin{bmatrix} e^{-1} & 1 \end{bmatrix} \cdot \begin{bmatrix} a_{2}\\a_{3} \end{bmatrix}$

$B = \begin{bmatrix} e_{0} & 1 \\ e_{1} & 1 \\ \vdots & \vdots \\ e_{15} & 1 \end{bmatrix}$"

# ╔═╡ 4c940207-3f1d-431b-9c01-52f05ab4e7d0
begin
	B = [E[i]^j for i in 1:16, j in -1:0]
	ê₂ = B \ b₂
	b̂₂(E) = ê₂' * [E^-1,1]
	ê₃ = B \ b₃
	b̂₃(E) = ê₃' * [E^-1,1]
	Print(ê₂, ê₃)
end

# ╔═╡ 80098407-d77f-4282-8776-93bb395e23ca
begin
	plot!(b̂₂, label = "b₂(e)")
	plot!(b̂₃, label = "b₃(e)")
end

# ╔═╡ fb25f078-e1fd-46e1-b231-5404f57edc15
begin
	compₐ1 = []
	erroₐ1 = []
	a_C1 = [1623.500, 39415.000, 284.200, 2177.600]
	a_AR1 = [ê₀[2], ê₀[1], ê₁[2], ê₁[1]]
	compₐ2 = []
	erroₐ2 = []
	a_C2 = [433.890, 25798.000, 83.501, 1230.200]
	a_AR2 = [ê₂[2], ê₂[1], ê₃[2], ê₃[1]]

	for i in 1:4
		append!(compₐ1, abs(a_AR1[i]-a_C1[i]))
		append!(erroₐ1, round(compₐ1[i]/a_C1[i]*100, digits=2))
		append!(compₐ2, abs(a_AR2[i]-a_C2[i]))
		append!(erroₐ2, round(compₐ2[i]/a_C2[i]*100, digits=2))
	end

	df1 = DataFrame(a=["a₀", "a₁", "a₂", "a₃"], artigo1=a_C1, experimento1=a_AR1, erro1=erroₐ1)

	rename!(df1, ["NC 2733", "Artigo", "Experimento", "Erro [%]"])

	df2 = DataFrame(a=["a₀", "a₁", "a₂", "a₃"], artigo2=a_C2, experimento2=a_AR2, erro2=erroₐ2)

	rename!(df2, ["NCX1116", "Artigo", "Experimento", "Erro [%]"])

	md"## Tabelas dos coeficientes e respectivas equações:"
end

# ╔═╡ c3eda44f-4bf3-4e6b-b9da-a730545118f7
df1

# ╔═╡ 18d0707c-e035-4c1e-8664-7a077648a9d3
L"$$
b_0(e) = 1624,43 + \frac{39375,80}{e}
$$
$$
b_1(e) = 284,31 + \frac{2174,91}{e}
$$"

# ╔═╡ fa429a6c-e740-4317-ba60-59a5b0d99b87
df2

# ╔═╡ cf4e0ac7-15d9-402d-9c40-a5eb600449f1
L"$$
b_2(e) = 434,34 + \frac{25760,50}{e}
$$
$$
b_3(e) = 83,50 + \frac{1228,77}{e}
$$"

# ╔═╡ 00000000-0000-0000-0000-000000000001
PLUTO_PROJECT_TOML_CONTENTS = """
[deps]
DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
Latexify = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
PlutoUI = "7f904dfe-b85e-4ff6-b463-dae2292396a8"

[compat]
DataFrames = "~1.2.0"
LaTeXStrings = "~1.2.1"
Latexify = "~0.15.6"
Plots = "~1.18.2"
PlutoUI = "~0.7.9"
"""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# ╔═╡ Cell order:
# ╟─7a45e73e-2bc0-489f-a7e1-4daa852589e1
# ╟─c7180b99-37f6-4494-aafb-57bdec113524
# ╟─b42465ab-12ae-4e2e-a4dd-ccf375cd69f4
# ╠═d5d8aca7-1771-4bd9-9761-11b667f894fa
# ╠═67277e58-4e39-4ced-9135-ce059ed3fe51
# ╠═6de97699-ca2f-4d84-9c6c-0d1cf2fb9781
# ╟─d9760d43-f85c-4574-b896-f098e52a5e9f
# ╠═0e89da5e-0028-4294-abca-62aa25435d4e
# ╠═183dfa02-3e9b-4d37-af9c-e14749d7bbed
# ╟─7ca1454b-6b82-435f-8495-378634a92ddd
# ╠═ce7b5b46-ce40-4fde-b919-4e7aa463621b
# ╠═2a30f4cd-65cb-4fb6-bc45-7c3999e74ce0
# ╟─63b5568d-8a7c-456d-912e-bf0f41821a27
# ╠═4c940207-3f1d-431b-9c01-52f05ab4e7d0
# ╠═80098407-d77f-4282-8776-93bb395e23ca
# ╟─fb25f078-e1fd-46e1-b231-5404f57edc15
# ╟─c3eda44f-4bf3-4e6b-b9da-a730545118f7
# ╟─18d0707c-e035-4c1e-8664-7a077648a9d3
# ╟─fa429a6c-e740-4317-ba60-59a5b0d99b87
# ╟─cf4e0ac7-15d9-402d-9c40-a5eb600449f1
# ╟─00000000-0000-0000-0000-000000000001
# ╟─00000000-0000-0000-0000-000000000002


text:
@testset "Affine interval matrix in one interval" begin
    A0 = [1 0; 0 1.]
    A1 = [0 1; 1 0.]
    λ = 0 .. 1
    P = AffineIntervalMatrix1(A0, A1, λ)

    @test size(P) == (2, 2)
    @test P[1, 1] == interval(1)
    @test P[1, 2] == interval(0, 1)
    P[1, 1] = 2.0
    @test P[1, 1] == interval(2)

    # complex interval
    λc = λ + im*λ/2
    Pc = AffineIntervalMatrix1(A0, A1, λc)
    @test eltype(Pc) == Complex{Interval{Float64}}
end

@testset "Affine interval matrix in several intervals" begin
    A0 = [1 0; 0 1.]
    A1 = [0 1; 1 0.]; A2 = copy(A1)
    λ1 = 0 .. 1; λ2 = copy(λ1)
    P = AffineIntervalMatrix(A0, [A1, A2], [λ1, λ2])

    @test size(P) == (2, 2)
    @test P[1, 1] == interval(1)
    @test P[1, 2] == interval(0, 2)
    P[1, 1] = 5.0
    @test P[1, 1] == interval(5)

    # complex interval
    λ1c = λ1 + im*λ1/2; λ2c = λ2 - im*λ2/2
    Pc = AffineIntervalMatrix(A0, [A1, A2], [λ1c, λ2c])
    @test eltype(Pc) == Complex{Interval{Float64}}
end


text:
####
#String to vector
####

"""
   _word2vector(construct,dict_mod)

Returns the vector embedding of a give `construct` where the
length equals the number of modules in dict_mod. The occurrence of every model is counted.
Afterwards, these numbers are stored in a vector ad the correponding index index.
The corresponding index of every construct is stored in`dict_mod`.
"""
function _word2vec(construct,dict_mod)
    word2vec = zeros(Int,length(dict_mod))
    for mod in construct
        word2vec[dict_mod[mod]]+=1
    end
    return word2vec
end
"""
    _word2vec(construct,mod::GroupMod)

Returns the vector embedding of a give `construct` where the
length equals the number of modules in mod. The occurrence of every module is counted.
Afterwards, these numbers are stored in a vector and the correct index.
The corresponding index of every construct is stored in`dict_mod`.
"""
function _word2vec(construct,mod::GroupMod)
    dict_mod = Dict(mod.m .=> collect(1:length(mod.m)))
    _word2vec(construct,dict_mod)
end

####
#Q-gram distances
####
struct QGramKernel{T <: QGramDistance } <: Kernel
    d::T
end

ew(k::QGramKernel, x::AbstractVector) = [1-evaluate(k.d,xᵢ,xᵢ) for xᵢ in x]
ew(k::QGramKernel, x::AbstractVector, x′::AbstractVector) = [1-evaluate(k.d,xᵢ,xⱼ) for (xᵢ,xⱼ) in zip(x, x′)]

pw(k::QGramKernel, x::AbstractVector) = reshape([1-evaluate(k.d,xᵢ,xⱼ) for xᵢ in x for xⱼ in x] ,(length(x),length(x)))
pw(k::QGramKernel, x::AbstractVector, x′::AbstractVector) = reshape([1-evaluate(k.d,xᵢ,xⱼ) for xⱼ in x′ for xᵢ in x] ,(length(x),length(x′)))

###
#EditDistancesKernel
###
@doc raw"""
    EditDistancesKernel{T} <: Kernel

The kernel for the edit distances diffiend in the [StringDistances.jl]@ref(https://github.com/matthieugomez/StringDistances.jl) package.
`` k(x, x^\prime) = \exp(-distance(x_i,x_j))``
"""
struct EditDistancesKernel{T <: SemiMetric } <: Kernel
    d::T
end

"""
    ew(k::EditDistancesKernel, x::AbstractVector)

Internal function to fit the `EditDistancesKernel` into the Stheno framework.
More information can be found on [Stheno]@ref(https://github.com/willtebbutt/Stheno.jl)
"""

ew(k::EditDistancesKernel, x::AbstractVector) = [exp(-evaluate(k.d,xᵢ,xᵢ)) for xᵢ in x]

"""
    ew(k::EditDistancesKernel, x::AbstractVector, x′::AbstractVector)

Internal function to fit the `EditDistancesKernel` into the Stheno framework.
More information can be found on [Stheno]@ref(https://github.com/willtebbutt/Stheno.jl)
"""

ew(k::EditDistancesKernel, x::AbstractVector, x′::AbstractVector) = [exp(-evaluate(k.d,xᵢ,xⱼ)) for (xᵢ,xⱼ) in zip(x, x′)]

"""
    ew(k::EditDistancesKernel, x::AbstractVector)

Internal function to fit the `EditDistancesKernel` into the Stheno framework.
More information can be found on [Stheno]@ref(https://github.com/willtebbutt/Stheno.jl)
"""

pw(k::EditDistancesKernel, x::AbstractVector) = reshape([exp(-evaluate(k.d,xᵢ,xⱼ)) for xᵢ in x for xⱼ in x] ,(length(x),length(x)))

"""
    ew(k::EditDistancesKernel, x::AbstractVector)

Internal function to fit the `EditDistancesKernel` into the Stheno framework.
More information can be found on [Stheno]@ref(https://github.com/willtebbutt/Stheno.jl)
"""

pw(k::EditDistancesKernel, x::AbstractVector, x′::AbstractVector) = reshape([exp(-evaluate(k.d,xᵢ,xⱼ)) for xⱼ in x′ for xᵢ in x] ,(length(x),length(x′)))

######
# Compese two Kernels
######

####
#Kernels on a Graph
####

"""
    KernelGraph{T}
A Kernel wich is caluclated based on a underlying graph.
The graph constructed based on all possible combinations.
"""
abstract type KernelGraph <: Kernel end

"""
    DiffusionKernel

Struct to call the diffusion Kernel
"""
struct DiffusionKernel <: KernelGraph end

"""
    PwalkKernel{T}

Struct to call the diffusion p - random walk kernel.

"""
struct PRandomKernel <: KernelGraph
    p::Int
end

"""
    setupgraph(S,k::KernelGraph,edgerule::EdgeRule)

Intral function that returs the normalized laplacian of the given graph.
The weighed graph is generated based on the whole design space S.
The weights are calculated using the given edgeRule.
"""
function setupgraph(S,edgerule::EdgeRule)
    fullspace = collect(S)
    return  adjacency(fullspace, edgerule) |>  norm_laplacian
end

"""
     kernelgraph(l::AbstractArray,gk::Diffusion;β = 1)

Diffusion kernel on the normalized laplacian `l` wiht hyper parameter β

Smola A.J., Kondor R. (2003) Kernels and Regularization on Graphs.
In: Schölkopf B., Warmuth M.K. (eds) Learning Theory and Kernel Machines.
Lecture Notes in Computer Science, vol 2777. Springer, Berlin, Heidelberg
"""
kernelgraph(L,gk::DiffusionKernel,β) = exp(-β*L)

"""
     kernelgraph(l::AbstractArray,gk::Diffusion;a = 1)
p-random walk kernel on the normalized laplacian `l` wiht hyper parameter a

with ``a geq 2``
Smola A.J., Kondor R. (2003) Kernels and Regularization on Graphs.
In: Schölkopf B., Warmuth M.K. (eds) Learning Theory and Kernel Machines.
Lecture Notes in Computer Science, vol 2777. Springer, Berlin, Heidelberg
"""
function kernelgraph(L,gk::PRandomKernel,a)
    @assert a >= 2 "a has to be larger than 2"
    return (a*I - L)^(gk.p)
end

struct PrandomKernel <: KernelGraph
    p::Int
end

struct QgramKernel{T <: QGramDistance } <: Kernel
    d::T
end

max_stars_repo_name: SamDier/BOMoD

max_issues_repo_name: SamDier/BOMoD

max_forks_repo_name: SamDier/BOMoD


text:
@testset "kaggle" begin
    dataset = "ningjingyu/fetchtest"

    f = kdownload(dataset, pwd())
    DataDeps.unpack(f)

    open(joinpath(pwd(), "FetchTest", "FetchTest.txt"), "r") do file
        @test readline(file) == "Test"
    end

    rm(joinpath(pwd(), "FetchTest"), recursive=true, force=true)
end


text:
import PotentialUQ
using LinearAlgebra: svd, svdvals, cond, pinv, I, diagm, norm
using Statistics
using Distributions
using TransformVariables
using Random
using Turing

num_configs = 40
r = Vector{PotentialUQ.Potentials.Configuration}(undef, num_configs)
file_path = "../examples/GaN/DATA"
for j = 1:num_configs
    c = PotentialUQ.Potentials.load_lammps(file_path * "/" * string(j) * "/DATA"; atom_names = [:Ga, :N],
                    radii = [0.5, 0.5], weights = [1.0, 0.5], boundary_type = ["p", "p", "p"], units = "metal")
    r[j] = c
end

num_configs_test = 20
rtest = Vector{PotentialUQ.Potentials.Configuration}(undef, num_configs_test)
file_path = "../examples/GaN/DATA"
for j = 1:num_configs_test
    c = PotentialUQ.Potentials.load_lammps(file_path * "/" * string(40+j) * "/DATA"; atom_names = [:Ga, :N],
            radii = [0.5, 0.5], weights = [1.0, 0.5], boundary_type = ["p", "p", "p"], units = "metal")
    rtest[j] = c
end

# Set up true potential
ϵ_Ga_Ga = 0.643
σ_Ga_Ga = 2.390
ϵ_N_N   = 1.474
σ_N_N   = 1.981
A_Ga_N  = 608.54
ρ_Ga_N  = 0.435
q_Ga    = 3.0
q_N     = -3.0
ϵ0      = 55.26349406

lj_Ga_Ga = PotentialUQ.Potentials.LennardJones(ϵ_Ga_Ga,σ_Ga_Ga)
lj_N_N   = PotentialUQ.Potentials.LennardJones(ϵ_N_N, σ_N_N)
bm_Ga_N  = PotentialUQ.Potentials.BornMayer(A_Ga_N,ρ_Ga_N)
c_Ga_N   = PotentialUQ.Potentials.Coulomb(q_Ga, q_N, ϵ0)
gan = PotentialUQ.Potentials.GaN(lj_Ga_Ga, lj_N_N, bm_Ga_N, c_Ga_N)
gantest = PotentialUQ.Potentials.GaN(lj_Ga_Ga, lj_N_N, bm_Ga_N, c_Ga_N)

println(gan)
pe = PotentialUQ.Potentials.potential_energy(r, gan)
ptest = PotentialUQ.Potentials.potential_energy(rtest, gantest)
println("GaN Energy ", pe)
fo = PotentialUQ.Potentials.force(r, gan)
fotest = PotentialUQ.Potentials.force(rtest, gantest)
println("GaN Forces ")
show(stdout, "text/plain", fo[1][1:3])
println(" ")
v = PotentialUQ.Potentials.virial(r, gan)
vtest = PotentialUQ.Potentials.virial(rtest, gantest)

println("GaN virial ", v)
v_tensor = PotentialUQ.Potentials.virial_stress(r, gan)
println("GaN Virial Tensor ", v_tensor)
println(" ")
# Form right hand side
b = vcat(pe, reduce(vcat, reduce(vcat, fo)), reduce(vcat, v_tensor))
# b = [pe; vec(v_tensor)]
println("Right hand side shape: ", size(b))
show(stdout, "text/plain", b[1:10])
println(" ")

# Form SNAP A matrix
twojmax = 6
rcutfac = 4.0
snap = PotentialUQ.Potentials.SNAP(rcutfac, twojmax, r[1])
A = PotentialUQ.Potentials.get_snap(r, snap)
println("Shape of A: ", size(A))
show(stdout, "text/plain", A[1:20, 1:9])
println(" ")

# Fit
snap.β = A \ b
println("Fitted β = ")
show(stdout, "text/plain", snap.β)
println(" ")
# Test
pe_snap = PotentialUQ.Potentials.potential_energy(rtest, snap)
println("SNAP potential_energy = ", pe_snap)
println("Relative Error = ", mean(abs.(ptest - pe_snap)./abs.(ptest)))
f_snap = PotentialUQ.Potentials.force(rtest, snap)
show(stdout, "text/plain", vcat(fotest...)[1:5])
println(" ")
show(stdout, "text/plain", vcat(f_snap...)[1:5])
println(" ")
ff = vcat( (fotest - f_snap)... )
fff = vcat( fotest... )
println("Force Relative Error = ", mean( norm.(ff)./norm.(fff)  ) )
v_snap = PotentialUQ.Potentials.virial(rtest, snap)
println("SNAP Virial = ", v_snap)
println("Virial Error = ", mean(abs.(vtest - v_snap)./abs.(vtest)))

# Regularize
println("Regularizing")
AA = A' * A
println(" ")
snap.β = pinv(AA, 1e-6) * (A'*b)
println("Regularized Fitted β = ")
show(stdout, "text/plain", snap.β)
println(" ")
pe_snap = PotentialUQ.Potentials.potential_energy(rtest, snap)
println("Regularized SNAP potential_energy = ", pe_snap)
println("Regularized Relative Error = ", mean(abs.(ptest - pe_snap)./abs.(ptest)))
f_snap = PotentialUQ.Potentials.force(rtest, snap)
ff = vcat( (fotest - f_snap)... )
fff = vcat( fotest... )
println("Force Relative Error = ", mean( norm.(ff)./norm.(fff)  ) )
v_snap = PotentialUQ.Potentials.virial(rtest, snap)
println("Regularized SNAP Virial = ", v_snap)
println("Regularized Virial Error = ", mean(abs.(vtest - v_snap)./abs.(vtest)))

############### UQ ######################
# Unknowns
n, m = size(A)

β = pinv(A' * A, 1e-6)*(A'*b)
nt = (β = β, )
# println("v = ", nt)
t = PotentialUQ.namedtp_to_vec(nt)
x = TransformVariables.inverse(t, nt)

# # Prior
F = svd(A)
Σ = diagm(F.S)
scale_A = vcat(200.0 .+ 0.0 .* pe, 1.0 .+ 0.0 .*reduce(vcat, reduce(vcat,fo)), 1.0 .+ 0.0 .*reduce(vcat, v_tensor))
Q =  F.U' * ( diagm(scale_A) ) * (F.U)
Q = 1e-2*I(m) + 0.5*Q + 0.5*Q'
println("Q = ")
show(stdout, "text/plain", Q)
println(" ")
println(" y = ")
y =  F.U' * b
show(stdout, "text/plain", y)
println(" ")
sampler(rng::Random.AbstractRNG, d::ContinuousMultivariateDistribution) = β + 1e-1*randn(length(d))
logpdf(x::Vector) = loglikelihood(MvNormal(β, 1e-1*I(m)), x)
snap_prior = PotentialUQ.SNAP_Prior_Distribution(A, b, x, t, sampler, logpdf)
println("logpdf = ", Distributions.logpdf(snap_prior, x))
snap_likelihood(x::Vector) = loglikelihood( MvNormal( Σ * F.Vt*x, Q ),  y )
println("Likelihood = ", snap_likelihood(x))
dsnap = PotentialUQ.PotentialDistribution(snap, nt, snap_prior, snap_likelihood)

@time samp = PotentialUQ.Sample(dsnap; num_samples = 1000, num_adapts = 500, verbose = true)

snap.β = dsnap.x.β
println("MAP Fitted β = ")
show(stdout, "text/plain", snap.β)
println(" ")
pe_snap = PotentialUQ.Potentials.potential_energy(rtest, snap)
println("MAP SNAP potential_energy = ", pe_snap)
println("MAP Relative Error = ", mean(abs.(ptest - pe_snap)./abs.(ptest)))
f_snap = PotentialUQ.Potentials.force(rtest, snap)
ff = vcat( (fotest - f_snap)... )
fff = vcat( fotest... )
println("Force Relative Error = ", mean( norm.(ff)./norm.(fff)  ) )
v_snap = PotentialUQ.Potentials.virial(rtest, snap)
println("MAP SNAP Virial = ", v_snap)
println("MAP Virial Error = ", mean(abs.(vtest - v_snap)./abs.(vtest)))

# using Plots

# plot(pinv(AA, 1e-6) * (A'*b))
# plot!(vec(m), ribbon = vec(s), fillalpha = 0.5)
# savefig("snap_map_samples.png")


text:
abstract type AbstractRecorder end

################################################################################
### ConfigRecorder
################################################################################

"""
    ConfigRecorder(mc, model[; rate = 10])

Creates a `ConfigRecorder` object which accumulates configurations during the
simulation.

ConfigRecorder pushed to a `ConfigRecorder` objects are forwarded to
`compress(mc, model, conf)` for potential compression. When replaying a
simulation `decompress(mc, model, conf)` is called to undo this action. You may
define both to save on memory/disk space.

See also [`BufferedConfigRecorder`](@ref), [`Discarder`](@ref)
"""
struct ConfigRecorder{CT} <: AbstractRecorder
    configs::Vector{CT}
    rate::Int64
end
ConfigRecorder{CT}(rate::Integer = 10) where CT = ConfigRecorder{CT}(Vector{CT}(), rate)
function ConfigRecorder(MC::Type, M::Type, rate::Integer = 10)
    ConfigRecorder{compressed_conf_type(MC, M)}(rate)
end
function Base.push!(c::ConfigRecorder, mc, model, sweep)
    (sweep % c.rate == 0) && push!(c.configs, compress(mc, model, conf(mc)))
    nothing
end

# Base extensions
Base.length(c::ConfigRecorder) = length(c.configs)
Base.isempty(c::ConfigRecorder) = isempty(c.configs)
Base.lastindex(c::ConfigRecorder) = lastindex(c.configs)
Base.iterate(c::ConfigRecorder, i=1) = iterate(c.configs, i)
Base.getindex(c::ConfigRecorder, i) = c.configs[i]

# Compression
compress(mc, model, conf) = copy(conf)
decompress(mc, model, conf) = conf

function _save(file::JLDFile, cs::ConfigRecorder, entryname::String="configs")
    write(file, entryname * "/VERSION", 1)
    write(file, entryname * "/tag", "ConfigRecorder")
    write(file, entryname * "/type", typeof(cs))
    write(file, entryname * "/data", cs.configs)
    write(file, entryname * "/rate", cs.rate)
end
function _load(data, ::Val{:ConfigRecorder})
    if !(data["VERSION"] == 1)
        throw(ErrorException("Failed to load $T version $(data["VERSION"])"))
    end
    data["type"](data["data"], data["rate"])
end
to_tag(::Type{<: ConfigRecorder}) = Val(:ConfigRecorder)

################################################################################
### BufferedConfigRecorder
################################################################################

struct FilePath
    is_relative::Bool
    relative_path::String
    absolute_path::String
end
RelativePath(filename) = FilePath(true, filename, joinpath(pwd(), filename))
AbsolutePath(filename) = FilePath(false, filename, filename)

"""
    BufferedConfigRecorder(mc, model, filename[; rate = 10, chunk_size = 1000])

Creates a `BufferedConfigRecorder` object which accumulates configurations
during the simulation in an in-memory buffer. The buffer has a set `chunk_size`.
Every time it becomes it is commited to a JLD2 file `filename` and reset.

This uses the same configuration compression used in ConfigRecorder. I.e. every
`push!`ed configuration is passed to `compress(mc, model, conf)`.

See also [`ConfigRecorder`](@ref), [`Discarder`](@ref)
"""
mutable struct BufferedConfigRecorder{CT} <: AbstractRecorder
    filename::FilePath
    buffer::Vector{CT}
    rate::Int64
    idx::Int64
    chunk::Int64
    total_length::Int64
    save_idx::Int64
end
function BufferedConfigRecorder(fn::String, buffer, rate, idx, chunk, N, sidx)
    BufferedConfigRecorder(AbsolutePath(fn), buffer, rate, idx, chunk, N, sidx)
end
function BufferedConfigRecorder{CT}(filename, rate = 10, chunk_size = 1000) where CT
    BufferedConfigRecorder(filename, Vector{CT}(undef, chunk_size), rate, 1, 1, 0, -1)
end
function BufferedConfigRecorder(MC::Type, M::Type, filename; rate = 10, chunk_size = 1000)
    BufferedConfigRecorder{compressed_conf_type(MC, M)}(filename, rate, chunk_size)
end
function Base.push!(cr::BufferedConfigRecorder, mc, model, sweep)
    if (sweep % cr.rate == 0)
        _push!(cr, compress(mc, model, conf(mc)))
    end
end
function _push!(cr::BufferedConfigRecorder, data)
    if cr.idx == -1
        # The recorder is not working on the right chunk
        if cr.save_idx != cr.total_length
            @error "Stored data length does not match expected data length. Reseting head to last checkpoint."
            cr.total_length = cr.save_idx
        end
        # get chunk, idx of next writeable location
        chunk, idx = idx2chunk_idx(cr, cr.total_length+1)
        # load chunk if not loaded and required
        chunk != cr.chunk && idx != 1 && load_chunk!(cr, chunk)
        cr.idx = idx
    elseif cr.idx > length(cr.buffer)
        # The buffer is full - commit to file
        save_final_chunk!(cr)
        cr.chunk += 1
        cr.idx = 1
    end
    cr.buffer[cr.idx] = data
    cr.idx += 1
    cr.total_length += 1
    nothing
end

# Base extensions
Base.length(cr::BufferedConfigRecorder) = cr.total_length
Base.isempty(cr::BufferedConfigRecorder) = cr.total_length == 0
Base.lastindex(cr::BufferedConfigRecorder) = cr.total_length
Base.iterate(cr::BufferedConfigRecorder, i=1) = iterate(cr.configs, i)

function Base.getindex(cr::BufferedConfigRecorder, i)
    @boundscheck 1 <= i <= cr.total_length
    chunk, idx = idx2chunk_idx(cr, i)
    if chunk != cr.chunk
        # Save unsaved data in buffer
        cr.save_idx < cr.total_length && save_final_chunk!(cr)
        load_chunk!(cr, chunk)
    end
    return cr.buffer[idx]
end

# maps index to (chunk_idx, buffer_idx)
function idx2chunk_idx(cr::BufferedConfigRecorder, i)
    chunk_size = length(cr.buffer)
    chunk = div(i-1, chunk_size) + 1
    idx = mod1(i, chunk_size)
    return chunk, idx
end

# chunk loading and saving
function save_final_chunk!(cr::BufferedConfigRecorder)
    if cr.total_length != (cr.chunk - 1) * length(cr.buffer) + cr.idx - 1
        error("Attempting to save non-final chunk $(cr.chunk)!")
    end
    save_chunk!(cr)
    cr.save_idx = cr.total_length
    nothing
end

function save_chunk!(cr::BufferedConfigRecorder, chunk = cr.chunk)
    @boundscheck chunk > 0 && (chunk-1) * length(cr.buffer) < cr.total_length
    k = string(chunk)
    JLD2.jldopen(cr.filename.absolute_path, "a+", compress = true) do file
        if haskey(file, k)
            @debug "Replacing chunk $k"
            delete!(file, k)
        end
        file[k] = cr.buffer
    end
    nothing
end

function load_chunk!(cr::BufferedConfigRecorder, chunk)
    @boundscheck (chunk-1) * length(cr.buffer) < cr.save_idx
    JLD2.jldopen(cr.filename.absolute_path, "r") do file
        copyto!(cr.buffer, file[string(chunk)])
    end
    cr.chunk = chunk
    cr.idx = -1
end

function _save(file, cr::BufferedConfigRecorder, entryname::String="configs")
    if cr.save_idx != cr.total_length || !isfile(cr.filename.absolute_path)
        save_final_chunk!(cr)
    end

    # adjust relative FilePath
    if cr.filename.is_relative
        path, _ = splitdir(file.path)
        filepath = joinpath(path, cr.filename.relative_path)
        if filepath != cr.filename.absolute_path
            if isfile(filepath)
                new_filepath = _generate_unique_filename(filepath)
                @warn "Config file '$filepath' already exists, renaming to '$new_filepath' to avoid collision."
                filepath = new_filepath
            end
            mv(cr.filename.absolute_path, filepath)
        end
        cr.filename = FilePath(true, string(filepath[length(path)+1:end]), filepath)
    end

    write(file, entryname * "/VERSION", 2)
    write(file, entryname * "/tag", "BufferedConfigRecorder")
    write(file, entryname * "/filename", cr.filename)
    write(file, entryname * "/buffer", cr.buffer)
    write(file, entryname * "/rate", cr.rate)
    write(file, entryname * "/total_length", cr.total_length)
    write(file, entryname * "/save_idx", cr.total_length)
    nothing
end
function _load(data, ::Val{:BufferedConfigRecorder})
    if !(data["VERSION"] <= 2)
        throw(ErrorException("Failed to load BufferedConfigRecorder version $(data["VERSION"])"))
    end
    BufferedConfigRecorder(
        data["filename"], data["buffer"], data["rate"], -1, -1,
        data["total_length"], data["save_idx"]
    )
end

################################################################################
### Discarder
################################################################################

"""
    Discarder(args...; kwargs...)

Creates an object that discards all configurations pushed to it.

See also: [`BufferedConfigRecorder`](@ref), [`ConfigRecorder`](@ref)
"""
struct Discarder <: AbstractRecorder end
Discarder(args...; kwargs...) = Discarder()
Base.push!(::Discarder, args...) = nothing
Base.length(::Discarder) = 0
Base.isempty(::Discarder) = true
Base.getindex(v::Discarder, i) = BoundsError(v, i)
Base.iterate(c::Discarder, i=1) = nothing

function _save(file::JLDFile, ::Discarder, entryname::String="configs")
    write(file, entryname * "/VERSION", 1)
    write(file, entryname * "/tag", "Discarder")
end
_load(data, ::Val{:Discarder}) = Discarder()
to_tag(::Type{<: Discarder}) = Val(:Discarder)

################################################################################
### Utility
################################################################################

function Base.merge!(target::BufferedConfigRecorder, source::ConfigRecorder; rate = 1)
    for i in eachindex(source.configs)
        if i % rate == 0
            _push!(target, source.configs[i])
        end
    end
end


text:
# Tests using TaylorModel1 and RTaylorModel1

using TaylorModels
using LinearAlgebra: norm
using Test

const _num_tests = 1000

setformat(:full)

function get_random_point(ib0::IntervalBox{N, T}) where {N, T}
    xmid = mid(ib0)
    return diam.(ib0) .* (rand(N) .- 0.5) .+ xmid
end

function check_containment(ftest, xx::TaylorModelN{N,T,S}, tma::TaylorModelN{N,T,S}) where {N,T,S}
    x0 = expansion_point(tma)
    xfp = get_random_point(tma.dom)
    xbf = [big(xfp[i]) for i=1:N]
    ib = IntervalBox([@interval(xfp[i]) for i=1:N]...)
    range = evaluate(tma, ib-x0)
    bb = all(ftest(xx(xbf .- mid(x0))) ⊆ range)
    bb || @show(ftest, ib, xbf, ftest(xbf...), range)
    return bb
end

const _order = 2
const _order_max = 2*(_order+1)
set_variables(Interval{Float64}, [:x, :y], order=_order_max)

@testset "Tests for TaylorModelN " begin
    b0 = Interval(0.0) × Interval(0.0)
    ib0 = Interval(-0.5, 0.5) × Interval(-0.5, 0.5)
    b1 =  Interval(0.0) × Interval(1.0)
    ib1 = Interval(-0.5, 0.5) × Interval(0.5, 1.5)

    zi = 0..0
    xT = TaylorN(Interval{Float64}, 1, order=_order)
    yT = TaylorN(Interval{Float64}, 2, order=_order)

    @testset "TaylorModelN constructors" begin
        xm = TaylorModelN{2, Interval{Float64}, Float64}(xT, zi, b0, ib0)
        ym = TaylorModelN{2, Interval{Float64}, Float64}(yT, zi, b0, ib0)
        @test xm == TaylorModelN(xT, zi, b0, ib0)
        @test ym == TaylorModelN(yT, zi, b0, ib0)
        @test xm == TaylorModelN(1, _order, b0, ib0)
        @test ym == TaylorModelN(2, _order, b0, ib0)
        @test TaylorModelN( b1[1], 2, b0, ib0) ==
                TaylorModelN(TaylorN(b1[1], _order), zi, b0, ib0)

        @test TaylorModelN(xm, -1..1) == TaylorModelN(xT, -1..1, b0, ib0)
        @test TaylorModelN(1, _order, b0, ib0) == TaylorModelN(xm, zi)
        @test TaylorModelN(2, _order, b0, ib0) == TaylorModelN(ym, zi)

        @test isa(xm, AbstractSeries)
        @test TaylorModelN{2, Interval{Float64},Float64} <: AbstractSeries{Interval{Float64}}

        # Test errors in construction
        @test_throws AssertionError TaylorModelN(xT, zi, IntervalBox(1..1), IntervalBox(1..1))
        @test_throws AssertionError TaylorModelN(xT, zi, b0, ib1)
        @test_throws AssertionError TaylorModelN(xT, 1..1, b0, ib0)
        @test_throws BoundsError TaylorModelN(5, _order, b0, ib0) # wrong variable number

        # Tests for get_order and remainder
        @test get_order() == 6
        @test get_order(xm) == 2
        @test domain(xm) == ib0
        @test remainder(ym) == zi
        @test expansion_point(ym) == b0
        @test constant_term(xm) == interval(0.0)
        @test constant_term(ym) == interval(0.0)
        @test linear_polynomial(xm) == xT
        @test linear_polynomial(ym) == yT
        @test linear_polynomial(xm^2) == zero(xT)
    end

    @testset "Arithmetic operations" begin
        Δ = interval(-0.25, 0.25)
        xm = TaylorModelN(xT, zi, b1, ib1)
        ym = TaylorModelN(yT, zi, b1, ib1)
        a = TaylorModelN( b1[1]+xT, Δ, b1, ib1)
        @test zero(a) == TaylorModelN(zero(a.pol), 0..0, b1, ib1)
        @test one(a) == TaylorModelN(one(a.pol), 0..0, b1, ib1)
        @test a + a == TaylorModelN(2*(b1[1]+ xT), 2*Δ, b1, ib1)
        @test -a == TaylorModelN( -(b1[1]+xT), -Δ, b1, ib1)
        @test a - a == TaylorModelN(zero(a.pol), 2*Δ, b1, ib1)
        @test b1[2] + ym == TaylorModelN(b1[2] + yT, zi, b1, ib1)
        @test a - b1[1] == TaylorModelN(zero(b1[1])+xT, Δ, b1, ib1)
        @test constant_term(a) == b1[1]
        @test constant_term(b1[2] + ym) == b1[2]
        @test linear_polynomial(a) == xT
        @test linear_polynomial(b1[2] + ym) == yT
        @test linear_polynomial(ym^2) == zero(yT)

        @test xm * ym == TaylorModelN( xT * yT, zi, b1, ib1)
        b = a * ym
        @test b == TaylorModelN( xT * yT, Δ*ym.pol(ib1-b1), b1, ib1)
        b = ym * TaylorModelN(xT^2, zi, b1, ib1)
        @test b == TaylorModelN( zero(xT), (ib1[1]-b1[1])^2*(ib1[2]-b1[2]), b1, ib1 )
        b = b1[2] * a
        @test b == TaylorModelN( b1[2]*a.pol, Δ*b1[2], b1, ib1 )
        @test b / b1[2] == a
        @test_throws AssertionError TaylorModelN(TaylorN(1, order=_order_max), zi, b1, ib1) *
            TaylorModelN(TaylorN(2, order=_order_max), zi, b1, ib1)

        remt = remainder(1/(1-TaylorModel1(_order, b1[1], ib1[1])))
        @test remainder(1 / (1-xm)) == remt
        @test remainder(ym / (1-xm)) == Interval(-0.25, 0.25)

        @test remainder(xm^2) == remainder(ym^2)
        @test (xm.dom[1]-xm.x0[1])^3 == remainder(xm^3)
        @test (ym.dom[2]-ym.x0[2])^4 ⊆ remainder(ym^4)
    end

    @testset "RPAs, functions and remainders" begin
        xm = TaylorModelN(1, _order, b1, ib1)
        ym = TaylorModelN(2, _order, b1, ib1)

        @test rpa(x->5+zero(x), xm) == 5+zero(xm)
        @test rpa(x->5+one(x), ym) == 5+one(ym)
        @test rpa(x->5*x, ym) == 5*ym
        remT = remainder(5*TaylorModel1(2, b1[1], ib1[1])^4)
        @test rpa(x->5*x^4, xm) == TaylorModelN(zero(xT), remT, b1, ib1)
        remT = 5 * (ib1[1]-b1[1])^2 * (2*(ib1[2]-b1[2])+(ib1[2]-b1[2])^2)
        @test rpa(x->5*x^2, xm*ym) == TaylorModelN( 5*xT^2, remT, b1, ib1)

        # Testing remainders of an RPA
        ftest = x -> exp(x)-1
        xx = xm + ym
        tma = rpa(ftest, xx)
        tmb = ftest(xx)
        @test tma.pol == tmb.pol
        @test remainder(tma) ⊆ remainder(tmb)
        # fT, Δ, ξ0 = rpafp(tma)
        # @test interval(ftest(ii.lo)-fT(ii.lo-ξ0),
        #                 ftest(ii.hi)-fT(ii.hi-ξ0)) ⊆ remainder(tma)
        for ind = 1:_num_tests
            @test check_containment(ftest, xx, tma)
        end
        @test_throws AssertionError tmb(ib1.+1.0)
        @test_throws AssertionError tmb(ib1.+Interval(1))

        # test for TM with scalar coefficients
        tmc = fp_rpa(tma)
        @test fp_rpa(tmc) == tmc

        ftest = x -> exp(x)
        xx = xm + 2*ym
        tma = rpa(ftest, xx)
        tmb = ftest(xx)
        @test tma.pol == tmb.pol
        @test remainder(tma) ⊆ remainder(tmb)
        # fT, Δ, ξ0 = rpafp(tma)
        # @test interval(ftest(ii.lo)-fT(ii.lo-ξ0),
        #                 ftest(ii.hi)-fT(ii.hi-ξ0)) ⊆ remainder(tma)
        for ind = 1:_num_tests
            @test check_containment(ftest, xx, tma)
        end
        @test_throws AssertionError tmb(ib1.+1.0)
        @test_throws AssertionError tmb(ib1.+Interval(1))

        ftest = x -> sin(x)
        xx = 1- xm^2 + ym
        tma = rpa(ftest, xx)
        tmb = ftest(xx)
        @test tma.pol == tmb.pol
        @test remainder(tma) ⊆ remainder(tmb)
        # fT, Δ, ξ0 = rpafp(tma)
        # @test interval(ftest(ii.lo)-fT(ii.lo-ξ0),
        #                 ftest(ii.hi)-fT(ii.hi-ξ0)) ⊆ remainder(tma)
        for ind = 1:_num_tests
            @test check_containment(ftest, xx, tma)
        end
        @test_throws AssertionError tmb(ib1.+1.0)
        @test_throws AssertionError tmb(ib1.+Interval(1))

        ftest = x -> sqrt(x)
        xx = xm^2 + ym
        tma = rpa(ftest, xx)
        tmb = ftest(xx)
        @test tma.pol == tmb.pol
        @test remainder(tma) ⊆ remainder(tmb)
        # fT, Δ, ξ0 = rpafp(tma)
        # @test interval(ftest(ii.lo)-fT(ii.lo-ξ0),
        #                 ftest(ii.hi)-fT(ii.hi-ξ0)) ⊆ remainder(tma)
        for ind = 1:_num_tests
            @test check_containment(ftest, xx, tma)
        end
        @test_throws AssertionError tmb(ib1.+1.0)
        @test_throws AssertionError tmb(ib1.+Interval(1))

        ftest = x -> inv(x)
        xx = 1 + xm + ym
        tma = rpa(ftest, xx)
        tmb = ftest(xx)
        @test tma.pol == tmb.pol
        @test remainder(tma) ⊆ remainder(tmb)
        # fT, Δ, ξ0 = rpafp(tma)
        # @test interval(ftest(ii.lo)-fT(ii.lo-ξ0),
        #                 ftest(ii.hi)-fT(ii.hi-ξ0)) ⊆ remainder(tma)
        for ind = 1:_num_tests
            @test check_containment(ftest, xx, tma)
        end
        @test_throws AssertionError tmb(ib1.+1.0)
        @test_throws AssertionError tmb(ib1.+Interval(1))
    end

    @testset "Composition of functions and their inverses" begin
        xm = TaylorModelN(xT, zi, b1, ib1)
        ym = TaylorModelN(yT, zi, b1, ib1)

        tma = exp(ym)
        tmb = log(tma)
        @test tmb == log(exp(ym))
        @test tmb.pol == ym.pol

        tma = sin(xm)
        tmb = asin(tma)
        @test tmb == asin(sin(xm))
        @test tmb.pol == xm.pol

        tma = asin(xm)
        tmb = sin(tma)
        @test tmb == sin(asin(xm))
        @test tmb.pol == xm.pol

        tma = acos(ym)
        tmb = cos(tma)
        @test tmb == cos(acos(ym))
        @test sup(norm(tmb.pol - ym.pol, Inf)) < 1.0e-16

        tma = tan(xm)
        tmb = atan(tma)
        @test tmb == atan(tan(xm))
        @test tmb.pol == xm.pol

        tma = atan(xm)
        tmb = tan(tma)
        @test tmb == tan(atan(xm))
        @test tmb.pol == xm.pol

        ####
        tma = log(1+ym)
        tmb = exp(tma)
        @test tmb == exp(log(1+ym))
        @test tmb.pol == (1+ym).pol

        tma = cos(1+ym)
        tmb = acos(tma)
        @test tmb == acos(cos(1+ym))
        @test sup(norm(tmb.pol - (1+ym).pol, Inf)) < 1.0e-15
    end

    @testset "Tests for integrate" begin
        ib0 = (0. .. 1.) × (0. .. 1.)
        b0 = (0.5 .. 0.5) × (0.5 .. 0.5)
        xm = TaylorModelN(1, _order, b0, ib0)
        ym = TaylorModelN(2, _order, b0, ib0)

        f = (x, y) -> cos(x)
        ∫fdx = (x, y) -> sin(x)
        ∫fdy = (x, y) -> cos(x) * y
        fT = f(xm, ym)
        ∫fTdx = integrate(fT, :x)
        ∫fTdy = integrate(fT, :y)

        for ind in 1:_num_tests
            xtest = get_random_point(ib0)
            cx = [mid(ib0[1]), xtest[2]]
            cy = [xtest[1], mid(ib0[2])]
            aux = IntervalBox(xtest) - b0
            @test (∫fdx(xtest...) - ∫fdx(cx...)) ∈ ∫fTdx(aux)
            @test (∫fdy(xtest...) - ∫fdy(cy...)) ∈ ∫fTdy(aux)
        end

        f = (x, y) -> sin(x) * cos(y)
        ∫fdx = (x, y) -> -cos(x) * cos(y)
        ∫fdy = (x, y) -> sin(x) * sin(y)
        fT = f(xm, ym)
        ∫fTdx = integrate(fT, :x)
        ∫fTdy = integrate(fT, :y)

        for ind in 1:_num_tests
            xtest = get_random_point(ib0)
            cx = [mid(ib0[1]), xtest[2]]
            cy = [xtest[1], mid(ib0[2])]
            aux = IntervalBox(xtest) - b0
            @test (∫fdx(xtest...) - ∫fdx(cx...)) ∈ ∫fTdx(aux)
            @test (∫fdy(xtest...) - ∫fdy(cy...)) ∈ ∫fTdy(aux)
        end

        f = (x, y) -> exp(x)
        ∫fdx = (x, y) -> exp(x)
        ∫fdy = (x, y) -> exp(x) * y
        fT = f(xm, ym)
        ∫fTdx = integrate(fT, :x)
        ∫fTdy = integrate(fT, :y)

        for ind in 1:_num_tests
            xtest = get_random_point(ib0)
            cx = [mid(ib0[1]), xtest[2]]
            cy = [xtest[1], mid(ib0[2])]
            aux = IntervalBox(xtest) - b0
            @test (∫fdx(xtest...) - ∫fdx(cx...)) ∈ ∫fTdx(aux)
            @test (∫fdy(xtest...) - ∫fdy(cy...)) ∈ ∫fTdy(aux)
        end

        f = (x, y) -> log(x) * x^2 + cos(x * y) + sin(x * y)
        ∫fdx = (x, y) -> (x^3 * y * (3log(x) - 1) + 9sin(x * y) - 9cos(x * y)) / 9y
        ∫fdy = (x, y) -> (x^3 * y * log(x) + sin(x * y) - cos(x * y)) / x
        fT = f(xm, ym)
        ∫fTdx = integrate(fT, :x)
        ∫fTdy = integrate(fT, :y)

        for ind in 1:_num_tests
            xtest = get_random_point(ib0)
            cx = [mid(ib0[1]), xtest[2]]
            cy = [xtest[1], mid(ib0[2])]
            aux = IntervalBox(xtest) - b0
            @test (∫fdx(xtest...) - ∫fdx(cx...)) ∈ ∫fTdx(aux)
            @test (∫fdy(xtest...) - ∫fdy(cy...)) ∈ ∫fTdy(aux)
        end

        f = (x, y) -> exp(-0.5 * (x^2 + y^2)) * x
        ∫fdx = (x, y) -> -exp(-0.5 * (x^2 + y^2))
        fT = f(xm, ym)
        ∫fTdx = integrate(fT, :x)

        for ind in 1:_num_tests
            xtest = get_random_point(ib0)
            cx = [mid(ib0[1]), xtest[2]]
            aux = IntervalBox(xtest) - b0
            @test (∫fdx(xtest...) - ∫fdx(cx...)) ∈ ∫fTdx(aux)
        end

        f = (x, y) -> x * cos(y) * exp(x + y)
        ∫fdx = (x, y) -> (x - 1) * exp(x + y) * cos(y)
        ∫fdy = (x, y) -> 0.5 * x * exp(x + y) * (sin(y) + cos(y))
        fT = f(xm, ym)
        ∫fTdx = integrate(fT, :x)
        ∫fTdy = integrate(fT, :y)

        for ind in 1:_num_tests
            xtest = get_random_point(ib0)
            cx = [mid(ib0[1]), xtest[2]]
            cy = [xtest[1], mid(ib0[2])]
            aux = IntervalBox(xtest) - b0
            @test (∫fdx(xtest...) - ∫fdx(cx...)) ∈ ∫fTdx(aux)
            @test (∫fdy(xtest...) - ∫fdy(cy...)) ∈ ∫fTdy(aux)
        end
    end

    @testset "Display" begin
        xm = TaylorModelN(1, _order, b1, ib1)
        ym = TaylorModelN(2, _order, b1, ib1)
        use_show_default(true)
        if VERSION < v"1.6"
            @test string(xm+ym) == "TaylorModelN{2,Interval{Float64},Float64}" *
                "(TaylorN{Interval{Float64}}" *
                "(HomogeneousPolynomial{Interval{Float64}}" *
                "[HomogeneousPolynomial{Interval{Float64}}" *
                "(Interval{Float64}[Interval(1.0, 1.0)], 0), " *
                "HomogeneousPolynomial{Interval{Float64}}" *
                "(Interval{Float64}[Interval(1.0, 1.0), Interval(1.0, 1.0)], 1), " *
                "HomogeneousPolynomial{Interval{Float64}}" *
                "(Interval{Float64}[Interval(0.0, 0.0), Interval(0.0, 0.0), " *
                "Interval(0.0, 0.0)], 2)], 2), Interval(0.0, 0.0), IntervalBox(Interval(0.0, 0.0), " *
                "Interval(1.0, 1.0)), IntervalBox(Interval(-0.5, 0.5), Interval(0.5, 1.5)))"
        else
            @test string(xm+ym) == "TaylorModelN{2, Interval{Float64}, Float64}" *
                "(TaylorN{Interval{Float64}}" *
                "(HomogeneousPolynomial{Interval{Float64}}" *
                "[HomogeneousPolynomial{Interval{Float64}}" *
                "(Interval{Float64}[Interval(1.0, 1.0)], 0), " *
                "HomogeneousPolynomial{Interval{Float64}}" *
                "(Interval{Float64}[Interval(1.0, 1.0), Interval(1.0, 1.0)], 1), " *
                "HomogeneousPolynomial{Interval{Float64}}" *
                "(Interval{Float64}[Interval(0.0, 0.0), Interval(0.0, 0.0), " *
                "Interval(0.0, 0.0)], 2)], 2), Interval(0.0, 0.0), IntervalBox(Interval(0.0, 0.0), " *
                "Interval(1.0, 1.0)), IntervalBox(Interval(-0.5, 0.5), Interval(0.5, 1.5)))"
        end
        use_show_default(false)
        @test string((xm+ym)^2) == " Interval(1.0, 1.0) + Interval(2.0, 2.0) x + " *
            "Interval(2.0, 2.0) y + Interval(1.0, 1.0) x² + Interval(2.0, 2.0) x y + " *
            "Interval(1.0, 1.0) y² + Interval(0.0, 0.0)"
    end

    @testset "Tests for bounders" begin
        beale(x, y) = (1.5 - x * (1 - y))^2 + (2.25 - x * (1 - y^2))^2 +
                          (2.625 - x * (1 - y^3))^2
        rosenbrock(x, y) = 100 * (y - x^2)^2 + (1 - x)^2
        mccormick(x, y) = sin(x + y) + (x - y)^2 - 1.5x + 2.5y + 1
        beale_min = rosenbrock_min = 0.
        mccormick_min = -1.9133

        @testset "Tests for linear dominated bounder" begin
            ib0 = IntervalBox(2.875 .. 3.0625, 0.5 .. 0.625) # A box near global minimum
            c = mid(ib0)
            b0 = Interval(c[1]) × Interval(c[2])
            xm = TaylorModelN(1, _order, b0, ib0)
            ym = TaylorModelN(2, _order, b0, ib0)
            fT = beale(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_ldb = linear_dominated_bounder(fT)
            @test bound_ldb ⊆ bound_naive_tm
            @test beale_min ∈ bound_ldb

            # Same as previous, but with Float64 coefficients
            xT = TaylorN(Float64, 1, order=_order)
            yT = TaylorN(Float64, 2, order=_order)
            xT = xT + c[1]
            yT = yT + c[2]
            xm = TaylorModelN(xT, 0 .. 0, b0, ib0)
            ym = TaylorModelN(yT, 0 .. 0, b0, ib0)
            fT = beale(xm, ym)
            @test bound_ldb ⊆ bound_naive_tm
            @test beale_min ∈ bound_ldb

            ib0 = IntervalBox(2.875 .. 3.0625, 0.375 .. 0.5)
            c = mid(ib0)
            b0 = Interval(c[1]) × Interval(c[2])
            xm = TaylorModelN(1, _order, b0, ib0)
            ym = TaylorModelN(2, _order, b0, ib0)
            fT = beale(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_ldb = linear_dominated_bounder(fT)
            @test bound_ldb ⊆ bound_naive_tm
            @test beale_min ∈ bound_ldb

            xT = TaylorN(Float64, 1, order=_order)
            yT = TaylorN(Float64, 2, order=_order)
            xT = xT + c[1]
            yT = yT + c[2]
            xm = TaylorModelN(xT, 0 .. 0, b0, ib0)
            ym = TaylorModelN(yT, 0 .. 0, b0, ib0)
            fT = beale(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_ldb = linear_dominated_bounder(fT)
            @test bound_ldb ⊆ bound_naive_tm
            @test beale_min ∈ bound_ldb

            ib0 = IntervalBox(1.01176 .. 1.1353, 0.888235 .. 1.01177)
            c = mid(ib0)
            b0 = Interval(c[1]) × Interval(c[2])
            xm = TaylorModelN(1, _order, b0, ib0)
            ym = TaylorModelN(2, _order, b0, ib0)
            fT = rosenbrock(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_ldb = linear_dominated_bounder(fT)
            @test bound_ldb ⊆ bound_naive_tm

            xT = TaylorN(Float64, 1, order=_order)
            yT = TaylorN(Float64, 2, order=_order)
            xT = xT + c[1]
            yT = yT + c[2]
            xm = TaylorModelN(xT, 0 .. 0, b0, ib0)
            ym = TaylorModelN(yT, 0 .. 0, b0, ib0)
            fT = rosenbrock(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_ldb = linear_dominated_bounder(fT)
            @test bound_ldb ⊆ bound_naive_tm

            ib0 = IntervalBox(-0.647059 .. -0.588235, -1.58824 .. -1.52941)
            c = mid(ib0)
            b0 = Interval(c[1]) × Interval(c[2])
            xm = TaylorModelN(1, _order, b0, ib0)
            ym = TaylorModelN(2, _order, b0, ib0)
            fT = mccormick(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_ldb = linear_dominated_bounder(fT)
            @test bound_ldb ⊆ bound_naive_tm

            xT = TaylorN(Float64, 1, order=_order)
            yT = TaylorN(Float64, 2, order=_order)
            xT = xT + c[1]
            yT = yT + c[2]
            xm = TaylorModelN(xT, 0 .. 0, b0, ib0)
            ym = TaylorModelN(yT, 0 .. 0, b0, ib0)
            fT = mccormick(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_ldb = linear_dominated_bounder(fT)
            @test bound_ldb ⊆ bound_naive_tm
        end
        @testset "Tests for quadratic fast bounder" begin
            δ = 0.1
            ib0 = IntervalBox((3 - δ) .. (3 + δ), (0.5 - δ) .. (0.5 + δ))
            c = mid(ib0)
            b0 = Interval(c[1]) × Interval(c[2])
            xm = TaylorModelN(1, _order, b0, ib0)
            ym = TaylorModelN(2, _order, b0, ib0)
            fT = beale(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_qfb = quadratic_fast_bounder(fT)
            @test bound_qfb ⊆ bound_naive_tm
            @test beale_min ∈ bound_qfb

            ib0 = IntervalBox((1. - δ) .. (1. + δ), (1. - δ) .. (1 + δ))
            c = mid(ib0)
            b0 = Interval(c[1]) × Interval(c[2])
            xm = TaylorModelN(1, _order, b0, ib0)
            ym = TaylorModelN(2, _order, b0, ib0)
            fT = rosenbrock(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_qfb = quadratic_fast_bounder(fT)
            @test bound_qfb ⊆ bound_naive_tm
            @test rosenbrock_min ∈ bound_qfb

            ib0 = IntervalBox((-0.54719 - δ) .. (-0.54719 + δ),
                              (-1.54719 - δ) .. (-1.54719 + δ))
            c = mid(ib0)
            b0 = Interval(c[1]) × Interval(c[2])
            xm = TaylorModelN(1, _order, b0, ib0)
            ym = TaylorModelN(2, _order, b0, ib0)
            fT = mccormick(xm, ym)
            bound_naive_tm = fT(fT.dom - fT.x0)
            bound_qfb = quadratic_fast_bounder(fT)
            @test bound_qfb ⊆ bound_naive_tm
            @test mccormick_min ∈ bound_qfb
        end
    end
end


text:
facts("Clone a git repo, create a tar file and a source directory") do
  url = "file:///" * Pkg.dir("DebbyPacker")
  pack = DebbyPacker.Package("DebbyPacker", DebbyPacker.GitSource(url, "5c894bf"))

  context("Check name, buildir, tarfile and such") do
    workdir = joinpath("/", "yo")
    tar = DebbyPacker.tarfile(pack, workdir)
    build = DebbyPacker.builddir(pack, workdir)
    source = DebbyPacker.sourcedir(pack, workdir)

    @fact build[1:length(workdir)] => workdir
    @fact source[1:length(build)] => build
    @fact tar[1:length(build)] => build
    @fact tar => joinpath(build, basename(tar))
  end

  context("Runs prepare_source on DebbyPacker local repo") do
    workdir = mktempdir()
    name = DebbyPacker.package_name(pack)
    tar = DebbyPacker.tarfile(pack, workdir)
    try
      DebbyPacker.prepare_source(pack, workdir; from_scratch=true)

      @fact joinpath(workdir, name) => isdir
      @fact joinpath(workdir, name, name) => isdir
      @fact joinpath(workdir, name, name, "LICENSE.md") => isfile
      @fact joinpath(workdir, name, name, "src", "DebbyPacker.jl") => isfile
      @fact tar => isfile

      # does not throw on second run
      @fact DebbyPacker.prepare_source(pack, workdir; from_scratch=true) => anyof(anything, nothing)
    finally
      rm(workdir; recursive=true)
    end
  end

end

max_stars_repo_name: UCL/DebbyPacker

max_issues_repo_name: UCL/DebbyPacker

max_forks_repo_name: UCL/DebbyPacker


text:
# Simple control problem
# Code was initially written by Jenny Hong for EE103
# Translated to lsqpy by Keegan Go
# Written in LinearLeastSquares.jl by Karanveer Mohan and David Zeng
#
# In this control problem, the object starts from the origin

using LinearLeastSquares
using Gadfly

# Some constraints on our motion
# The object should start from the origin, and end at rest
initial_velocity = [-20; 100]
final_position = [100; 100]

T = 100 # The number of timesteps
h = 0.1 # The time between time intervals
mass = 1 # Mass of object
drag = 0.1 # Drag on object
g = [0, -9.8] # Gravity on object

# Declare the variables we need
position = Variable(2, T)
velocity = Variable(2, T)
force = Variable(2, T - 1)

# Create a problem instance
mu = 1
constraints = []

# Add constraints on our variables
for i in 1 : T - 1
  constraints += position[:, i + 1] == position[:, i] + h * velocity[:, i]
end

for i in 1 : T - 1
  acceleration = force[:, i]/mass + g - drag * velocity[:, i]
  constraints += velocity[:, i + 1] == velocity[:, i] + h * acceleration
end

# Add position constraints
constraints += position[:, 1] == 0
constraints += position[:, T] == final_position

# Add velocity constraints
constraints += velocity[:, 1] == initial_velocity
constraints += velocity[:, T] == 0

# Solve the problem
optval = minimize!(sum_squares(force), constraints)

pos = evaluate(position)
p = plot(
  layer(x=[pos[1, 1]], y=[pos[2, 1]], Geom.point, Theme(default_color=color("blue"))),
  layer(x=[pos[1, T]], y=[pos[2, T]], Geom.point, Theme(default_color=color("green"))),
  layer(x=pos[1, :], y=pos[2, :], Geom.line(preserve_order=true)),
  Theme(panel_fill=color("white"))
)
#draw(PNG("position.png", 16cm, 12cm), p)

p = plot(x=1:T, y=sum(evaluate(force).^2, 1), Geom.line, Theme(panel_fill=color("white")))
#draw(PNG("force.png", 16cm, 12cm), p)


text:
facts("Create and activate a virtual machine") do
  vm = Machine("ThisIsARUDEOILTestMachineThatShouldNotExist2"; docreate=false)
  try
    @fact exists(vm) => false
    start_machine(vm)
    @fact exists(vm) => true

    config = RudeOil.config(vm)
    @fact length(config) => greater_than(0)
    @fact config => x -> ismatch(r"--tls", x)

    remove!(vm)
    @fact exists(vm) => false
  finally
    if exists(vm)
      remove!(vm)
    end
  end
end


text:
#####
##### Hyperparameters
#####
Network = ResNet

netparams = ResNetHP(
  num_filters=128,
  num_blocks=15,
  conv_kernel_size=(3, 3),
  num_policy_head_filters=256,
  num_value_head_filters=256,
  batch_norm_momentum=0.1)

self_play = SelfPlayParams(
  num_games=1000,
  reset_mcts_every=1,
  mcts=MctsParams(
    use_gpu=true,
    num_workers=32,
    num_iters_per_turn=500,
    cpuct=3.0,
    prior_temperature=0.7,
    temperature=PLSchedule([0, 12], [1.0, 0.1]),
    dirichlet_noise_ϵ=0.25,
    dirichlet_noise_α=0.75))

arena = ArenaParams(
  num_games=400,
  reset_mcts_every=1,
  flip_probability=0.1,
  update_threshold=1.0,
  play_swiss_style=true,
  mcts=MctsParams(
    self_play.mcts,
    temperature=ConstSchedule(0.2),
    dirichlet_noise_ϵ=0.05))

learning = LearningParams(
  use_gpu=true,
  use_position_averaging=true,
  samples_weighing_policy=LOG_WEIGHT,
  batch_size=64,
  loss_computation_batch_size=256,
  optimiser=Adam(lr=1e-3),
  l2_regularization=1e-4,
  nonvalidity_penalty=1.,
  min_checkpoints_per_epoch=1,
  max_batches_per_checkpoint=8000,
  num_checkpoints=1)

params = Params(
  arena=arena,
  self_play=self_play,
  learning=learning,
  num_iters=100,
  ternary_rewards=false,
  use_symmetries=true,
  memory_analysis=MemAnalysisParams(
    num_game_stages=4),
  mem_buffer_size=PLSchedule(
  [      0,        100],
  [200_000,    750_000]))

#####
##### Benchmarks
#####

mcts_baseline =
  Benchmark.MctsRollouts(
    MctsParams(
      arena.mcts,
      num_iters_per_turn=1000,
      num_workers=1,
      cpuct=1.))

minmax_baseline = Benchmark.MinMaxTS(depth=5, amplify_rewards=true, τ=0.2)

solver_baseline = Benchmark.Solver(ϵ=0)

players = [
  #Benchmark.Full(arena.mcts),
  Benchmark.Full(arena.mcts),
  Benchmark.Full(arena.mcts),
  Benchmark.NetworkOnly(τ=0.5, use_gpu=true)]

baselines = [
  #solver_baseline,
  mcts_baseline,
  minmax_baseline,
  mcts_baseline]

make_duel(player, baseline) =
  Benchmark.Duel(
    player,
    baseline,
    num_games=200,
    flip_probability=0.1,
    color_policy=ALTERNATE_COLORS,
    play_swiss_style=true)

benchmark = [make_duel(p, b) for (p, b) in zip(players, baselines)]

max_stars_repo_name: btheodorou/Bridge-NN-Research

max_issues_repo_name: btheodorou/Bridge-NN-Research

max_forks_repo_name: btheodorou/Bridge-NN-Research


text:
# Author: Ritchie Lee, ritchie.lee@sv.cmu.@schedule
# Date: 12/11/2014

module GenerativeModel

export
    AbstractGenerativeModel,
    initialize,
    update,
    get,
    isterminal,

    SimpleTCAS_EvU_params,
    SimpleTCAS_EvU,

    SimpleTCAS_EvE_params,
    SimpleTCAS_EvE,

    ACASX_GM_params,
    ACASX_GM

import CommonInterfaces: initialize, update

using AbstractGenerativeModelImpl

include("common/common.jl")

using SimpleTCAS_EvU_Impl

using SimpleTCAS_EvE_Impl

using ACASX_GM_Impl

end


text:
using WebIO, JSExpr

struct ThreeScreen <: Base.AbstractDisplay
    context::Scope
end

function ThreeScreen()
    threejs = Scope(imports = [
        "//cdnjs.cloudflare.com/ajax/libs/three.js/84/three.min.js",
    ]);

    onimport(threejs, @js function (THREE, OrbitControlsModule)
        @var container = this.dom.querySelector("#container");
        @var scene; @var renderer;
        @var geometry; @var material; @var mesh;
        @var scope = this

        function onWindowResize(event)
            scope.camera.aspect = window.innerWidth / window.innerHeight
            scope.camera.updateProjectionMatrix()
        end
        function animate()
            requestAnimationFrame(animate)
            render()
        end
        function render()
            renderer.render(scene, scope.camera)
        end

        function init()
            renderer = @new THREE.WebGLRenderer()
            scope.THREE = THREE
            scope.camera = @new THREE.PerspectiveCamera(50, window.innerWidth / window.innerHeight, 1, 5000);
            scope.camera.position.z = 1400;
            scene = @new THREE.Scene()
            scope.scene = scene
            renderer.setPixelRatio(window.devicePixelRatio)
            renderer.setSize(window.innerWidth, window.innerHeight)
            container.appendChild(renderer.domElement)
            window.addEventListener("resize", onWindowResize, false)
        end
        init()
        animate()
    end)
    ThreeScreen(threejs)
end
screen = ThreeScreen()
mesh_add = Observable(screen.context, "mesh_add", true)

onjs(mesh_add, @js function (val)
    @var THREE = this.THREE
    @var geometry = @new THREE.CubeGeometry(200, 200, 200)

    @var material = @new THREE.MeshBasicMaterial(d(color = "#00ff00"))
    @var mesh = @new THREE.Mesh(geometry, material)
    this.scene.add(mesh)
end)

using Blink
w = Window()
body!(w, screen.context(dom"div#container"()))
scene = scatter(rand(10), rand(10), rand(10))
function to_obs(scene, x, name)
    obs = Observable(scene.context, name, x[])
    foreach(x) do val
        obs[] = val
    end
    obs
end
pos = to_obs(screen, scene.camera_controls[].eyeposition, "eyeposition")

onjs(pos, @js function (pos)
    console.log(pos)
    # @var THREE = this.THREE
    # @var camera = this.camera
    # camera.position.set(100, 100, 1400)
    # camera.updateProjectionMatrix();
end)

evaljs(screen.context, @js begin
    @var THREE = this.THREE
    @var camera = this.camera
    camera.position.set(100, 100, 1400)
    camera.updateProjectionMatrix();
end)


text:
using Documenter, TimedSound
makedocs(
  modules = [TimedSound],
  format = :html,
  sitename = "TimedSound.jl",
  html_prettyurls = true,
  pages = Any[
    "User guide" => Any[
      "Creating Sounds" => "stimulus.md",
    ],
    "Reference" => Any[
      "Sound" => "sound.md",
    ]
  ]
)
deploydocs(
  repo = "github.com/haberdashPI/TimedSound.jl.git",
  julia = "0.6",
  osname = "osx",
  deps = nothing,
  make = nothing,
  target = "build"
)